Direitos de acesso a arquivos e diretórios de restauração ext4 do Linux após backup/restauração incorretos

A solução padrão recomendada é direta:

find . -type d -exec chmod 0755 "{}" \+
find . -type f -exec chmod 0644 "{}" \+

Isso acrescentará tantos nomes de arquivo quanto possível como argumentos a um único comando, até o comprimento máximo da linha de comando do sistema. Se a linha exceder esse comprimento, o comando será chamado várias vezes.

Se você quiser chamar o comando uma vez por arquivo, você pode fazer:

find . -type d -exec chmod 0755 "{}" \;
find . -type f -exec chmod 0644 "{}" \;

chmod -R a=,u+rwX,go+rX $DIR seems to work fine, and is very likely to be the fastest, however you look at it.

(I checked with strace, and it makes only one fchmodat() syscall per file/directory -- for files that is with 644 and for directories with 755).

The trick is the X permmission, documented in man chmod, which acts like x for directories only -- the very distinction you wanted.

What is not documented is my guess that they would be applied in the same sequence as they are specified, and not just in some random order, but repeated tests with several variants have convinced me that they do indeed run in the order given, so I am pretty sure this is always going to work like this.

I should mention this is on Linux, though a cursory reading of the BSD manpage for chmod suggest that it should work there also.

Eu comparei a resposta de sitaram , o comentário de Peter Cordes , a resposta de Fanatique e a resposta de harrymc , mas esta resposta tem o caminho mais rápido .

Médias:

• Resposta de Deltik* – 7.480 segundos
  ^{_{* Crédito para Peter Cordes por sugerir paralelismo}}
• resposta do sitaram – 12,962 segundos (73,275% mais lento que o melhor)
• Comentário de Peter Cordes – 14,414 segundos (92,685% mais lento que o melhor)
• Resposta do Fanatique – 14,570 segundos (94,772% mais lento que o melhor)
• Resposta atualizada de harrymc – 14,791 segundos (97,730% mais lento que o melhor)
• Resposta original de harrymc - 1061,926 segundos (14096,113% mais lento que o melhor)

Resumo estatístico completo:

Author              N      min     q1      median  q3      max     mean    stddev
------------------  --     ------- ------- ------- ------- ------- ------- --------
Deltik              10     7.121   7.3585  7.4615  7.558   8.005   7.4804  0.248965
sitaram             10     12.651  12.803  12.943  13.0685 13.586  12.9617 0.276589
Peter Cordes        10     14.096  14.2875 14.375  14.4495 15.101  14.4136 0.269732
Fanatique           10     14.219  14.512  14.5615 14.6525 14.892  14.5697 0.211788
harrymc (updated)   10     14.38   14.677  14.8595 14.9025 15.119  14.791  0.21817
harrymc (original)  1      1061.93 1061.93 1061.93 1061.93 1061.93 1061.93 N/A

Comando de Deltik, em formato de benchmark:

encontre "$(pwd)" -type d -print0 | xargs -0 -P4 chmod 755 & \
encontre "$(pwd)" -type f -print0 | xargs -0 -P4 chmod 644 e aguarde

comando do sitaram, em formato de benchmark:

chmod -R a=,u+rwX,go+rX "$(pwd)"

Comando de Peter Cordes, em formato de benchmark:

encontre "$(pwd)" \( -type d -exec chmod 755 {} + \) \
           -o \( -type f -exec chmod 644 {} + \)

Comando do Fanatique, em formato de benchmark:

encontre "$(pwd)" -type d -print0 | xargs -0 chmod 755 ; \
encontre "$(pwd)" -type f -print0 | xargs -0 chmod 644

comando atualizado do harrymc, em formato de benchmark:

encontre "$(pwd)" -type d -exec chmod 755 {} + ; \
encontre "$(pwd)" -type f -exec chmod 644 {} +

comando original do harrymc, em formato de benchmark:

localize "$(pwd)" -type d -exec chmod 755 {} \; ; \
localize "$(pwd)" -type f -exec chmod 644 {} \;

Meu comando foi o mais rápido graças aos quatro chmodprocessos paralelos por tipo de arquivo. Isso permitiu que vários núcleos de CPU fossem executados chmod, o que move o gargalo para os threads de E/S do kernel ou para o disco.

o comando do sitaram foi o vice-campeão porque tudo é feito dentro do chmodcomando. Isso reduz substancialmente a sobrecarga em comparação com as outras respostas porque:

• Os arquivos só precisam ser verificados uma vez (semelhante a fazer um findem vez de dois) e
• Nenhum processo filho precisa ser criado.

Este comando é o menos flexível, no entanto, porque depende de um truque envolvendo o significado diferente do bit executável entre arquivos e diretórios regulares.

O comentário de Peter Cordes, que usa um findcomando, evita pesquisas duplas de entradas de diretório. Quanto mais arquivos houver, mais substancial será essa melhoria. Ele ainda tem a sobrecarga de criar chmodprocessos filho, e é por isso que é um pouco mais lento do que a chmodsolução -only.

Entre o comando do Fanatique e o comando atualizado do harrymc, findcanalizado para xargs( find | xargs) foi mais rápido porque o fluxo de resultados é processado de forma assíncrona. Em vez de findpausar seu comportamento de localização para -exec, os resultados encontrados são enviados xargspara processamento simultâneo.
(O delimitador de bytes nulos ( find -print0 | xargs -0) não parece afetar o tempo de execução.)

O comando original do harrymc era muito lento devido à sobrecarga de um novo chmodcomando para cada arquivo e pasta, cada um executado em sequência.

Na configuração de teste, havia 1000002 arquivos regulares contidos em 1001 diretórios:

root@demo:~# echo {0..999} | xargs mkdir -p
root@demo:~# find -type d -exec bash -c "cd {}; echo {0..999} | xargs touch" \;
root@demo:~# localizar | wc-l
1001003
root@demo:~# find -type d | wc-l
1001
root@demo:~# find -type f | wc-l
1000002

Eu configurei todos os arquivos e pastas para ter 777permissões, como as condições iniciais da pergunta.

Em seguida, comparei os comandos dez vezes, sempre restaurando as permissões antes 777de chmod -R 0777 "$(pwd)"executar o teste.

Ao representar um OUTPUTarquivo que contém a saída de cada comando de benchmark, calculei o tempo médio usando:

bc <<< "scale=3; ($(grep real OUTPUT | grep -Po '(?<=m).*(?=s)' | xargs | sed 's/ /+/g'))/10"

Resultados do benchmark da resposta de Deltik

root@demo:~# for i in {0..9} ; faça chmod -R 0777 "$(pwd)" ; time { find "$(pwd)" -type d -print0 | xargs -0 -P4 chmod 755 & localize "$(pwd)" -type f -print0 | xargs -0 -P4 chmod 644 & aguarde ; } ; feito
[1] 9791
[2] 9793
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.634s reais
usuário 0m2.536s
sys 0m23.384s
[1] 9906
[2] 9908
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.443s reais
usuário 0m2.636s
sistema 0m23.106s
[1] 10021
[2] 10023
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

reais 0m8.005s
usuário 0m2.672s
sistema 0m24.557s
[1] 10136
[2] 10138
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.480s reais
usuário 0m2.541s
sys 0m23.699s
[1] 10251
[2] 10253
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.397s reais
usuário 0m2.558s
sys 0m23.583s
[1] 10366
[2] 10368
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.482s reais
usuário 0m2.601s
sys 0m23.728s
[1] 10481
[2] 10483
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.679s reais
usuário 0m2.749s
sys 0m23.395s
[1] 10596
[2] 10598
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.243s reais
usuário 0m2.583s
sys 0m23.400s
[1] 10729
[2] 10731
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.320s reais
usuário 0m2.640s
sys 0m23.403s
[1] 10844
[2] 10847
[1]- Find "$(pwd)" -type d | xargs -P4 chmod 755
[2]+ Feito encontrar "$(pwd)" -type f | xargs -P4 chmod 644

0m7.121s reais
usuário 0m2.490s
sys 0m22.943s

Tempo médio: 7.480 segundos

Resultados do benchmark da resposta do sitaram

root@demo:~# for i in {0..9} ; faça chmod -R 0777 "$(pwd)" ; time chmod -R a=,u+rwX,go+rX "$(pwd)" ; feito

0m12.860s reais
usuário 0m0.940s
sys 0m11.725s

0m13.059s reais
usuário 0m0.896s
sys 0m11.937s

0m12.819s reais
usuário 0m0.945s
sys 0m11.706s

0m13.078s reais
usuário 0m0.855s
sys 0m12.000s

0m12.653s reais
usuário 0m0.856s
sys 0m11.667s

0m12.787s reais
usuário 0m0.820s
sys 0m11.834s

0m12.651s reais
usuário 0m0.916s
sys 0m11.578s

0m13.098s reais
usuário 0m0.939s
sys 0m12.004s

0m13.586s reais
usuário 0m1.024s
sys 0m12.372s

0m13.026s reais
usuário 0m0.976s
sys 0m11.910s

Tempo médio: 12.962 segundos

Resultados do benchmark do comentário de Peter Cordes

root@demo:~# for i in {0..9} ; faça chmod -R 0777 "$(pwd)" ; time find "$(pwd)" \( -type d -exec chmod 755 {} + \) -o \( -type f -exec chmod 644 {} + \) ; feito

0m14.096s reais
usuário 0m1.455s
sys 0m12.456s

0m14.492s reais
usuário 0m1.398s
sys 0m12.897s

0m14.309s reais
usuário 0m1.518s
sys 0m12.576s

0m14.451s reais
usuário 0m1.477s
sys 0m12.776s

0m15.101s reais
usuário 0m1.554s
sys 0m13.378s

0m14.223s reais
usuário 0m1.470s
sys 0m12.560s

0m14.266s reais
usuário 0m1.459s
sys 0m12.609s

0m14.357s reais
usuário 0m1.415s
sys 0m12.733s

0m14.393s reais
usuário 0m1.404s
sys 0m12.830s

0m14.448s reais
usuário 0m1.492s
sys 0m12.717s

Tempo médio: 14.414 segundos

Resultados do benchmark da resposta da Fanatique

root@demo:~# for i in {0..9} ; faça chmod -R 0777 "$(pwd)" ; time { find "$(pwd)" -type d -print0 | xargs -0 chmod 755 ; encontre "$(pwd)" -type f -print0 | xargs -0 chmod 644 ; } ; feito

0m14.561s reais
usuário 0m1.991s
sys 0m13.343s

0m14.521s reais
usuário 0m1.958s
sys 0m13.352s

0m14.696s reais
usuário 0m1.967s
sys 0m13.463s

0m14.562s reais
usuário 0m1.875s
sys 0m13.400s

0m14.609s reais
usuário 0m1.841s
sys 0m13.533s

0m14.892s reais
usuário 0m2.050s
sys 0m13.630s

0m14.291s reais
usuário 0m1.885s
sys 0m13.182s

0m14.843s reais
usuário 0m2.066s
sys 0m13.578s

0m14.219s reais
usuário 0m1.837s
sys 0m13.145s

0m14.503s reais
usuário 0m1.803s
sys 0m13.419s

Tempo médio: 14.570 segundos

Resultados do benchmark da resposta atualizada de harrymc

root@demo:~# for i in {0..9} ; do chmod -R 0777 "$(pwd)" ; time { find "$(pwd)" -type d -exec chmod 755 {} + ; find "$(pwd)" -type f -exec chmod 644 {} + ; } ; done

real    0m14.975s
user    0m1.728s
sys     0m13.050s

real    0m14.710s
user    0m1.586s
sys     0m12.979s

real    0m14.644s
user    0m1.641s
sys     0m12.872s

real    0m14.927s
user    0m1.706s
sys     0m13.036s

real    0m14.867s
user    0m1.597s
sys     0m13.086s

real    0m15.119s
user    0m1.666s
sys     0m13.259s

real    0m14.878s
user    0m1.590s
sys     0m13.098s

real    0m14.852s
user    0m1.681s
sys     0m13.045s

real    0m14.380s
user    0m1.603s
sys     0m12.663s

real    0m14.558s
user    0m1.514s
sys     0m12.899s

Average time: 14.791 seconds

Results of the benchmark of harrymc's original answer

Due to how slow this command was, I only ran the benchmark once.

root@demo:~# for i in {0..0} ; do chmod -R 0777 "$(pwd)" ; time { find "$(pwd)" -type d -exec chmod 755 {} \; ; find "$(pwd)" -type f -exec chmod 644 {} \; ; } ; done
 
real    17m41.926s
user    12m26.896s
sys     4m58.332s

Time taken: 1061.926 seconds

Se os diretórios forem muito grandes e contiverem muitos arquivos, a maneira original que @harrymc mostrou para você falhará.

Se você tiver muitos arquivos , precisará canalizar findcom :xargschmod

find /base/dir -type d -print0 | xargs -0 chmod 755 
find /base/dir -type f -print0 | xargs -0 chmod 644