Perché alcuni valori di umask non hanno effetto?

Sto cercando di capire meglio le autorizzazioni, quindi sto facendo alcuni "esercizi". Ecco una sequenza di comandi che sto usando con i rispettivi output:

$ umask
0022
$ touch file1
$ ls -l file1
-rw-r--r-- 1 user group 0 Mar 16 12:55 file1
$ mkdir dir1
$ ls -ld dir1
drwxr-xr-x 2 user group 4096 Mar 16 12:55 dir1

Questo ha senso perché sappiamo che le autorizzazioni di file predefinite sono 666( rw-rw-rw-) e le autorizzazioni predefinite delle directory sono 777( rwxrwxrwx). Se sottraggo il valore umask da queste autorizzazioni predefinite che ho 666-022=644, rw-r--r--per la file1, in modo che sia coerente con l'uscita precedente; 777-022=755, rwx-r-x-r-xper il dir1, anche coerente.

Ma se cambio l'umask da 022ad 021essa non è più.

Ecco l'esempio per il file:

$ umask 0021
$ touch file2
$ ls -l file2
-rw-r--rw- user group 0 Mar 16 13:33 file2

-rw-r--rw-è 646ma dovrebbe essere 666-021=645. Quindi non funziona secondo il calcolo precedente.

Ecco l'esempio per la directory:

$ touch dir2
$ ls -ld dir2
drwxr-xrw- 2 user group 4096 Mar 16 13:35 dir2

drwxr-xrw-è 756, 777-021=756. Quindi in questo caso il risultato è coerente con il calcolo precedente.

Ho letto l'uomo ma non ho trovato nulla su questo comportamento.

Qualcuno può spiegare perché?

SPIEGAZIONE

Come sottolineato nelle risposte: umaskil valore non viene sottratto matematicamente dalla directory predefinita e dalle autorizzazioni del file.

L'operazione effettivamente coinvolta è una combinazione di operatori booleani AND (&) e NOT (!). Dato:

R = autorizzazioni risultanti
D = autorizzazioni predefinite
U = umask corrente

R = D &! U

Per esempio:

666 e! 0053 = 110 110 110 e 
            ! 000 101 011 
             110 110 110 e  
             111 010 100
           = 110 010 100 = 624 = rw - wr--
 

777 e! 0022 = 111 111 111 e 
            ! 000 010 010
             111 111 111 &  
             111 101 101
           = 111 101 101 = 755 = rwxr - xr-x 

MANCIA

Un modo semplice per conoscere rapidamente le autorizzazioni risultanti (almeno mi ha aiutato) è pensare che possiamo usare solo 3 valori decimali:

r = 100 = 4 
w = 010 = 2
x = 001 = 1

Le autorizzazioni saranno una combinazione di questi 3 valori.
" "viene utilizzato per indicare che non è stata concessa l'autorizzazione relativa.

666 = 4+2+" "   4+2+" "   4+2+" "  = rw rw rw  

Quindi, se la mia umask corrente è 0053che sto rimuovendo i (4+1) permessi di lettura ed esecuzione dal gruppo e la scrittura e l'esecuzione (2+1)da altri risultanti

 4+2     " "+2+" "     4+" "+" "   = 624 = rw--w-r--  

(gruppo e altro non avevano già il permesso di esecuzione)

umaskè una maschera , non è un valore sottratto. Così:

• modalità 666, maschera 022: il risultato è 666 e ~ 022, ovvero 666 e 755, che è 644;
• modalità 666, maschera 021: il risultato è 666 e ~ 021, ovvero 666 e 756, ovvero 646.

Pensa ai pezzi coinvolti. 6 in una modalità significa che i bit 1 e 2 sono impostati, letti e scritti. 2 in una maschera maschera il bit 1, il bit di scrittura. 1 in una maschera maschera il bit 0, il bit di esecuzione.

Un altro modo per rappresentarlo è esaminare le autorizzazioni in forma di testo. 666 è rw-rw-rw-; 022 è ----w--w-; 021 è ----w---x. La maschera elimina i bit impostati dalla modalità, quindi rw-rw-rw-mascherata da ----w--w-diventa rw-r--r--, mascherata da ----w---xdiventa rw-r--rw-.

Devi pensare in binario, non decimale. In particolare, ci sono tre numeri binari a 3 bit: uno ciascuno per Proprietario, Gruppo e Altro. Ognuno con valori compresi tra 000 e 111 (0-7 in decimale).

ad es. rw-rw-rw (666) è 110 110 110.

Il umaskvalore è una maschera che specifica quali bit saranno attivati ​​o disattivati ​​(1 o 0) durante la creazione di un nuovo file o directory. ad es. 022 decimale è 000 010 010 binario, mentre 021 decimale è 000 010 001

I bit di autorizzazione sono AND-ed insieme all'umask negata per arrivare al valore finale. "negato" significa che tutti i bit sono invertiti, ovvero tutti gli 1 sono capovolti a 0 e viceversa. per esempioNOT 022 (000 010 010) = 755 (111 101 101)

Esempio: 666 & !022 = 644. In binario, questo è:

  Owner  Group  Other     mode
   110    110    110      666 
&  111    101    101      755   (this is the negated 022)
   ---    ---    ---      ---
   110    100    100      644

Inoltre 777 & !022 = 755:

  Owner  Group  Other     mode
   111    111    111      777 
&  111    101    101      755
   ---    ---    ---      ---
   111    101    101      755

Si noti come il valore finale di ogni bit può essere solo 1 se è 1 in entrambi il valore di autorizzazione originale (666 o 777) e nella umask negata. Se uno di questi è 0, il risultato è 0. Cioè, 1 & 1 = 1 , mentre 1 & 0 = 0 .

A rigor di termini c'è un quarto numero binario a 3 bit per i bit setuid, setgid e sticky. Ecco perché spesso vedi autorizzazioni e maschere specificate con uno 0 iniziale (o qualche altro numero iniziale compreso tra 0 e 7). ad es. 0777 o 2755.