JoL's questions

Eu tenho um SSD com 2 partições formatadas com ext4. Na segunda partição, habilitei discardcomo opção padrão no nível do sistema de arquivos com este comando:

$ sudo tune2fs -o discard /dev/sda2
tune2fs 1.45.5 (07-Jan-2020)
$ sudo tune2fs -l /dev/sda2 | grep 'mount options'
Default mount options:    user_xattr acl discard

Eu também adicionei a discardopção para ambas as partições em /etc/fstab:

/dev/sda2 /     ext4 rw,relatime,discard,stripe=8191 0 1
/dev/sda1 /boot ext4 rw,relatime,discard,stripe=8191 0 2

No entanto, quando observo a saída de mount, apenas aquele sem a discardopção de montagem padrão do nível fs parece tê-lo ativado:

$ mount | grep '^/dev'
/dev/sda2 on / type ext4 (rw,relatime,stripe=8191)
/dev/sda1 on /boot type ext4 (rw,relatime,discard,stripe=8191)

Percebo que as outras opções mencionadas por tune2fstambém não são mencionadas.

Então, posso confiar que discardestá habilitado na montagem atual , /dev/sda2apesar de mountnão mencioná-lo? Existe alguma maneira de verificar isso? Quero dizer, mesmo tune2fsa saída de 's não é sobre a montagem atual.

EDIT: Devo mencionar que também tentei montar mount -o discardna linha de comando e ainda não aparece na mountsaída:

$ sudo tune2fs -o discard /dev/sda1
tune2fs 1.45.5 (07-Jan-2020)
$ sudo umount /boot
$ sudo mount -o discard /boot
$ mount | grep sda1
/dev/sda1 on /boot type ext4 (rw,relatime,stripe=8191)

Dado o arquivo m.sh:

f() {
  echo foo
}

g() {
  f | sed -r 's/^|$/:/g' # random work
}

e e.sh:

. m.sh

old_f="$(type f | sed '3,$!d')"

f() {
  echo "$(eval "$old_f")bar"
}

g

existe uma solução melhor do que usar typee evalpara chamar a função antiga da função de substituição, mantendo o mesmo nome para que as referências em outras funções ainda funcionem?

Ambos m.she e.shfazem parte do mesmo projeto, e por isso podemos modificar m.shsem preocupação.

Existe uma maneira de open()um arquivo e fazê-lo encolher? Pode-se, é claro, abri-los no modo de acréscimo ou procurar até o fim e escrever para fazê-los crescer. No entanto, até onde eu sei, não há método para reduzir um arquivo por meio de interfaces típicas de chamada de sistema no estilo unix.

A única maneira de fazer isso, até onde eu sei, é fingindo, criando um novo arquivo mais curto e rename()substituindo o antigo.

Eu só queria uma confirmação, porque vi uma resposta que sugeria que era possível fazer editores de arquivos que funcionassem diretamente em um arquivo em vez de passar pelo processo de criar um novo e renomeá-lo no local.

Eu sempre pensei que a api de arquivo nas interfaces de chamada de sistema libc e unix não permitia a redução de arquivos para facilitar a implementação de sistemas de arquivos e talvez evitar padrões de uso que possam contribuir para a fragmentação.

Estou tentando entender o que causa a diferença nessas 2 construções que pensei serem funcionalmente equivalentes:

$ ( echo foo >&2 ) 2> >(sed 's/^/stderr: /') | sed 's/^/stdout: /'   
stdout: stderr: foo
$ ( echo foo >&2 ) 2> >(sed 's/^/stderr: /') > >(sed 's/^/stdout: /')
stderr: foo

EDIT: Se eu entendi user1133275 direito, ele sugere que >(sed 's/^/stdout: /')não seja executado, a menos que o subshell seja enviado ( echo foo >&2 )para stdout. No entanto, isso significaria que o seguinte:

$ ( echo foo >&2 ) 2> >(sed 's/^/stderr: /') > >(echo baz)   
baz
stderr: foo

não deve exibir baz.

EDIT 2: Talvez também de interesse, o sed não produz stdout:na entrada vazia, mesmo quando canalizado:

$ sed 's/^/stdout: /' < /dev/null
$ printf "" | sed 's/^/stdout: /'
$

poweroffreclama que não pode se conectar ao systemd via DBus (claro, não está vivo). Eu fiz syncseguido por kill $$, pensando que a morte do pid 1 faria com que o kernel fosse desligado, mas isso causou um pânico no kernel. Em seguida, segurei o botão liga / desliga para forçar o desligamento.

Qual é a maneira mais adequada de desligar neste cenário?

É um padrão glob estendido zsh. O objetivo é combinar todos os arquivos com um padrão em uma hierarquia de diretórios, com exceção de sub-hierarquias específicas. O padrão no título funciona, mas eu queria algo que não exigisse repetição long/path/.

Eu tentei o seguinte:

long/path/(^(bad-1|bad-2)/|)**/^*.(complex|pattern)(.)
long/path/(**~(bad-1|bad-2)/*)/^*.(complex|pattern)(.)

com KSH_GLOBadicionado:

long/path/?(^(bad-1|bad-2)/)**/^*.(complex|pattern)(.)

Todos eles resultam em um erro de padrão ruim. Parece que o problema é ter um /entre parênteses. A documentação diz:

Como mencionado acima, um `/' usado como separador de diretório pode não aparecer entre parênteses

Isso me confundiu porque (dir/)#é um bom padrão. É até mencionado nos documentos:

Um componente de nome de caminho no formato `(foo/)#' corresponde a um caminho que consiste em zero ou mais diretórios correspondentes ao padrão foo.

Acho que é a exceção.

Para ser claro, estou procurando equivalentes. Isso exclui:

long/path/^(bad-1|bad-2)/**/^*.(complex|pattern)(.)

uma vez que exclui coisas como long/path/good.pattern, e

long/path/(^(bad-1|bad-2)/)#/^*.(complex|pattern)(.)
long/path/**/^*.(complex|pattern)~*/(bad-1|bad-2)/*(.)

uma vez que excluem coisas como o que está sob long/path/good/bad-1.

EDIT: Só para mencionar, uma solução não precisa necessariamente usar apenas globbing. Se isso puder ser feito adicionando o uso de brace ou expansão de histórico ou algum outro recurso zsh, isso é ótimo.

EDIT 2: Seguindo minhas próprias ideias, tentei a expansão do histórico:

long/path/**/^*.(complex|pattern)~!{#$:s/\**//}/(bad-1|bad-2)/*(.)

No entanto, isso falhou porque 1) a última palavra da linha atual é a anterior àquela em que a expansão está e 2) porque a substituição do histórico parece ser feita após a expansão glob (devo estar entendendo mal algo aqui porque isso parece para ir contra os documentos; talvez todas as expansões sejam feitas palavra por palavra).

Eu também tentei expansão de chaves:

( IFS=\~; printf "%s\n" long/path/{**/^*.(complex|pattern),(bad-1|bad-2)/*(.)} )

Não funcionou. Os 2 padrões glob ainda foram tomados como palavras separadas em vez de serem unidos em um único padrão. Eu acho que IFSnão é levado em consideração aqui. Faz sentido.

Eu também tentei substituição em qualificadores glob:

+/**/^*.(complex|pattern)~+/(bad-1|bad-2)/*(.:s,+,long/path,)

Mas, é claro, isso não funcionaria porque a substituição seria feita após a correspondência, não antes.

Eu sempre pensei que os shells analisam scripts inteiros, construindo um AST e, em seguida, executam esse AST da memória. No entanto, acabei de ler um comentário de Stéphane Chazelas e testei a execução deste script, edit-while-executing.sh:

#!/bin/bash

echo start
sleep 10

e então enquanto ele estava dormindo correndo:

$ echo "echo end" >> edit-while-executing.sh

e funcionou para fazer com que ele imprimisse "fim" no final.

No entanto, ao tentar modificar isso:

#!/bin/bash

while true; do
  echo yes
done

fazendo:

$ printf "%s" "no " | dd of=edit-while-executing.sh conv=notrunc seek=35 bs=1

Não funcionou e continuou imprimindo "sim".

Também me perguntei se outros intérpretes não shell também funcionavam assim e tentei o equivalente ao primeiro script com python, mas não funcionou. No entanto, talvez o python não seja mais um interpretador e seja mais um compilador JIT.

Então, para reiterar minha pergunta, esse é um comportamento onipresente aos shells e limitado a eles ou também presente em outros interpretadores (aqueles que não são considerados shells)? Além disso, como isso funciona de modo que eu possa fazer a primeira modificação, mas não a segunda?