All perguntas(unix)

Preciso executar vários scripts de shell sequencialmente (s1.sh, s2.sh, s3.sh) com o seguinte requisito:

• Se um script não produzir nenhuma saída (stdout ou stderr) por 1 minuto, ele deve ser encerrado
• Após o término, o próximo script na sequência deve ser executado automaticamente
• Isso deve continuar até que todos os scripts sejam processados

Situação atual:

• Os scripts não saem sozinhos quando sua tarefa é concluída
• Atualmente, monitoro manualmente cada script e pressiono Ctrl-cquando não percebo nenhuma saída por um tempo
• É preciso automatizar esta intervenção manual

Exemplo de fluxo de trabalho:

1. Execute s1.sh
2. Se s1.sh ficar em silêncio por 1 minuto → encerre-o → execute s2.sh
3. Se s2.sh ficar em silêncio por 1 minuto → encerre-o → execute s3.sh
4. ...e assim por diante

Abordagem potencial que estou considerando: Estou pensando em redirecionar stdout e stderr para um arquivo e verificar o tempo de modificação do arquivo a cada segundo. Se o arquivo não tiver sido gravado por 1 minuto, eu poderia assumir que o script não tem saída e matá-lo. No entanto, não tenho certeza se essa abordagem é viável ou se há soluções melhores.

Alguém implementou algo parecido? Obrigado.

function tail() {
    shift 1
    echo $@
}

% tail one two three
two three

Como posso escrever o oposto desta função simples?

Eu quero alcançar

% init one two three
one two

e obter todos os argumentos, exceto o último, na $@variável, para que a função possa ser escrita como

function init() {
    # ???
    echo $@
}

Eu tentei unset '@[-1]', unset '[@:-1]', de https://unix.stackexchange.com/a/611717/696135 mas estes não funcionam

Eu tentei set -- "${@:1:$(($#-1))}", unset "@[${#@[@]}-1]", set -- "${@:1:$#-1}"de https://stackoverflow.com/questions/20398499/remove-last-argument-from-argument-list-of-shell-script-bash mas eles não funcionam

Um exemplo de um script que não funciona:

function init() {
    set -- ${@:1:$#-1}
    echo $@
}

init one two three

Usando a versão GNU de todas as 3 ferramentas (role para baixo para ver as tentativas do FreeBSD), se eu quisesse encontrar 'na entrada usando o awk com um 'script delimitado por -, poderíamos tentar corresponder usando as sequências de escape hexadecimais e octais:

$ echo "'" | awk '/\x27/'
'

$ echo "'" | awk '/\047/'
'

$ echo "'" | awk '/\o047/'
awk: cmd. line:1: warning: regexp escape sequence `\o' is not a known regexp operator

então os 2 primeiros funcionam e o 3º não, como você esperaria intuitivamente.

Agora vamos tentar o mesmo com sed (com ou sem -E):

$ echo "'" | sed -n '/\x27/p'
'

$ echo "'" | sed -n '/\047/p'
$

$ echo "'" | sed -n '/\o047/p'
'

e grep (também com ou sem -E):

$ echo "'" | grep '\x27'
grep: warning: stray \ before x

$ echo "'" | grep '\047'
grep: warning: stray \ before 0

$ echo "'" | grep '\o047'
grep: warning: stray \ before o

Então:

1. Mais importante: por que eles são diferentes?
2. Curiosidade secundária: Existe uma maneira de usar uma sequência de escape no grep para corresponder 'sem recorrer à opção não portátil do GNU grep -Pe sem expandir a sequência de escape antes que o grep a veja usando construções de shell como grep $'\047'?

Vale ressaltar que octal \047é a sequência de escape recomendada no awk (veja http://awk.freeshell.org/PrintASingleQuote ou https://web.archive.org/web/20230530010453/http://awk.freeshell.org/PrintASingleQuote se estiver inativo).

Para os propósitos desta questão, não estou interessado em alternativas que permitam literal 'ou o que qualquer outra ferramenta faz ou qualquer outra coisa, estou apenas tentando descobrir por que essas 3 ferramentas específicas de correspondência de regexp tratam sequências de escape ASCII de forma diferente umas das outras. Eu estaria, no entanto, interessado em aprender como o BSD ou outras variantes dessas 3 ferramentas se comportam, dados os mesmos scripts mostrados acima.

Informações adicionais:

FreeBSD

Este é o comportamento do FreeBSD 13.1:

% echo "'" | awk '/\x27/'
'
% echo "'" | awk '/\047/'
'
% echo "'" | sed -n '/\x27/p'
'
% echo "'" | sed -n '/\047/p'
% echo "'" | sed -n '/\o047/p'
sed: 1: "/\o047/p": RE error: trailing backslash (\)
% echo "'" | grep '\x27'
grep: trailing backslash (\)
% echo "'" | grep '\047'
% 

POSIX

Veja o que os padrões POSIX para Expressões Regulares e as 3 ferramentas em questão dizem sobre isso:

• expressões regulares: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap09.html
• awk: https://pubs.opengroup.org/onlinepubs/9799919799/utilities/awk.html
• sed: https://pubs.opengroup.org/onlinepubs/9799919799/utilities/sed.html
• grep: https://pubs.opengroup.org/onlinepubs/9799919799/utilities/grep.html

Da especificação regexp vemos que nem xnem 0são "Caracteres Especiais" em um BRE ou ERE , portanto são "Caracteres Ordinários" e que

Quando não está dentro de uma expressão entre colchetes, a interpretação de um caractere comum precedido por um caractere sem escape é indefinida, exceto para:

seguido por listas de caracteres, nenhum dos quais inclui 0ou xpara BREs ou EREs, então minha conclusão é que nem \x27nem \047são comportamentos definidos em uma expressão regular por POSIX.

A seção Expressões Regulares da especificação POSIX awk diz:

\ddd
Um caractere seguido pela sequência mais longa de um, dois ou três caracteres de dígito octal (01234567). Se todos os dígitos forem 0 (ou seja, representação do caractere NUL), o comportamento é indefinido. Se os dígitos produzirem um valor maior que o octal 377, o comportamento é indefinido.

então sabemos que \0é definido para um awk POSIX, mas \xnão é, então o comportamento do awk \xnão é definido pelo POSIX para o awk e, portanto, é deixado para as várias implementações do awk.

A seção Expressões regulares da especificação POSIX sed adiciona algumas alterações ao regexp, mas não menciona \0or \xe remete às definições de regexp POSIX e, portanto, \0or \xnão são definidos pelo POSIX para sed.

A seção Descrição da especificação grep do POSIX se refere inteiramente às definições de expressões regulares do POSIX e, portanto \0, \xnão são definidas pelo POSIX para grep.

Então, aparentemente, o significado de \xddé deixado para os implementadores de ferramentas para grep, sed e awk, enquanto o significado de \0ddé definido para awk, mas deixado para os implementadores de grep e sed.

Manuais GNU

A seção Sequências de escape do manual do GNU awk diz:

\nnn
O valor octal nnn, onde nnn representa de 1 a 3 dígitos entre '0' e '7'. Por exemplo, o código para o caractere ASCII ESC (escape) é '\033'.

\xhh…
O valor hexadecimal hh, onde hh representa uma sequência de dígitos hexadecimais ('0'–'9', e 'A'–'F' ou 'a'–'f'). São permitidos no máximo dois dígitos após '\x'...

então é aí que \x47o GNU awk é definido.

A seção Sequências de Escape do manual do GNU sed diz:

\oxxx
Produz ou corresponde a um caractere cujo valor ASCII octal é xxx.

\xxx
Produz ou corresponde a um caractere cujo valor hexadecimal ASCII é xx.

então é onde \o047e \x27são definidos para o GNU sed.

O manual do GNU grep não contém nenhuma referência que eu tenha encontrado sobre sequências de escape hexadecimais ou octais, o que explica as mensagens de aviso que vemos quando tentamos usá-las e provavelmente significa que elas simplesmente não são suportadas no GNU grep.

De acordo com pipe(7):

Se todos os descritores de arquivo referentes à extremidade de leitura de um pipe tiverem sido fechados, então a write(2)fará com que um SIGPIPEsinal seja gerado para o processo de chamada. Se o processo de chamada estiver ignorando esse sinal, write(2)falhará com o erro EPIPE.

Por que o Unix precisa ter o SIGPIPEsinal quando write()pode simplesmente retornar EPIPEdiretamente? Meu entendimento é que os sinais são destinados a coisas que são inerentemente assíncronas (por exemplo, encerramento de um filho, interrupção terminal). Mas SIGPIPEsó é gerado como o resultado imediato de uma chamada to write(); nesse caso, ele sempre pode simplesmente retornar EPIPEto to caller para indicar o erro ao chamador.

Por que foi considerado necessário ter SIGPIPEalém de EPIPE?

Não é exatamente uma questão de “inicialização dupla”, porque não estou instalando o Kali Linux em uma unidade interna. A situação é que eu instalo o Kali em um disco rígido externo/removível de um pendrive usando Ventoy . Eu defini as prioridades de inicialização do BIOS para percorrer os anexos USB primeiro, antes de inicializar a partir da unidade interna que abriga a cópia do Windows 11. Portanto, tudo funciona bem, desde que eu não inicialize no Win11 enquanto a coisa estiver conectada Remover a unidade antes de inicializar no Win11 evita que o Win11 exclua os dados do GRUB que o mantêm em uma configuração de inicialização estável, com o GRUB instalado na unidade removível. Mas assim que o Win11 inicializa, ele chega ao meu drive USB e mexe com ele, o que não deveria fazer, mas isso não vem ao caso... Como faço para consertar, devo esquecer de desconectá-lo, para não tem que ficar reinstalando tudo usando o Ventoy?

Para referência, esta postagem reflete mais de perto a situação atual: Resolvendo o problema de inicialização do Kali Linux com GNU Grub em inicialização dupla com Windows Triste por ter tantos votos negativos. Eles obviamente estavam fazendo algo certo se chegassem ao prompt do initramfs. Pesquisei um pouco sobre os comandos do GRUB e como configurar tudo de volta, copiei os argumentos da linha de comando de um sistema em funcionamento e descobri o seguinte:

grub> linux (hd0,gpt2)/boot/vmlinuz-6.8.11-amd64 BOOT_IMAGE=/boot/vmlinuz-6.8.11-amd64 root=UUID=[uuid-of-drive] ro quiet splash
grub> inirtrd (hd0,gpt2)/boot/initrd.img-6.8.11-amd64

O que me leva a esta tela:

O que me levou àquele post sobre dual boot kali/win e me inspirou a criar este: Para onde alguém iria a partir daqui? Existe um parâmetro de inicialização ou algo que estou faltando? Como fazer para inicializar normalmente novamente a partir do GRUB?

O cenário

Digamos que você tenha um arquivo esparso de 1 GB em um sistema de arquivos de 2 GB e o arquivo esparso ocupe apenas 0,1 GB de espaço.

As questões)

Acho que você teria 1,9 GB para armazenar dados em disco, certo?

Se houver realmente 1,9 GB de espaço livre no disco, e se eu armazenasse 1,5 GB fora do arquivo esparso, deixando apenas 0,4 GB de espaço livre (1,5 GB fora do arquivo esparso + 0,1 GB do arquivo esparso)? Isso significaria que, mesmo que eu veja o arquivo esparso como 1 GB, só conseguirei armazenar 0,5 GB no total dentro dele (0,1 GB em uso + 0,4 GB disponíveis)?

O que o sistema operacional faria neste caso?

Pensamentos

Se o que foi dito acima for verdade, usar um arquivo esparso parece bom por causa do espaço economizado, mas digamos que estou usando esse arquivo como um ponto de armazenamento (dispositivo de loop) e quero contar com esse espaço, acho que usando o arquivo esparso não seria uma boa ideia porque caso eu precisasse de 1 GB inteiro não conseguiria usá-lo. Talvez seja melhor usar um arquivo não esparso.

Estou tentando imprimir a data de nascimento do arquivo ( crtime), estou trabalhando com ext4 e suporte para crtime enable:

stat a
  File: a
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: 254,5   Inode: 393233      Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1006/    user)   Gid: ( 1006/    user)
Access: 2024-06-24 13:35:25.672343713 +0200
Modify: 2024-06-24 13:35:25.672343713 +0200
Change: 2024-06-24 13:35:25.672343713 +0200
 Birth: 2024-06-24 13:35:25.672343713 +0200

ao tentar exibir a data de nascimento find -printf '%B@'conforme indicado no manual:

%Bk    File's  birth  time,  i.e., its creation time, in the format 
specified by k, which is the same as for %A. 
This directive produces an empty string if the underlying operating 
system  or  filesystem does not support birth times.

Eu obtenho esse resultado:

find -name a -printf '%B@ %p\n' 
-1.-000000010 ./a

É um bug ou um recurso que não conheço ou algo mais. Estou usando o find versão 4.9.0-5 (e testei a versão -4 também).

Eu tentei no Ubuntu e no Debian.

Gostaria de incluir alguns caracteres não ASCII em meus comentários de script de shell POSIX . Observe que isso não é de forma alguma uma duplicata de, por exemplo, "Quais codificações de caracteres são suportadas pelo posix?" já que me importo apenas com a seção de comentários. Portanto, não me importo se posso usar Unicode para codificação real. Eu me importo se todos os shells compatíveis com POSIX serão capazes de ler meu arquivo ou se alguns falharem devido à codificação não ASCII.

Portanto, meu editor (VS Code) salvará esse arquivo com codificação UTF-8.

Aqui estão dois arquivos identificados com o fileutilitário (não tenho certeza se ele se importa com o BOM):

$ file script1*
script1:     POSIX shell script, ASCII text executable
script1.utf: POSIX shell script, Unicode text, UTF-8 text executable

A questão é: se os scripts shell POSIX devem estar apenas em ASCII. Não consigo encontrar nada relevante sobre este tópico. Obrigado.

tldr: O mtrace ainda funciona ou estou fazendo errado?

Eu estava tentando usar o mtrace e não consegui gravar dados em um arquivo. Eu segui as instruções em man 3 mtrace:

t_mtrace.c:

#include <mcheck.h>
#include <stdlib.h>
#include <stdio.h>

int
main(int argc, char *argv[])
{
    mtrace();

    for (int j = 0; j < 2; j++)
        malloc(100);            /* Never freed--a memory leak */

    calloc(16, 16);             /* Never freed--a memory leak */
    exit(EXIT_SUCCESS);
}

Em seguida, execute isso no bash:

gcc -g t_mtrace.c -o t_mtrace
export MALLOC_TRACE=/tmp/t
./t_mtrace
mtrace ./t_mtrace $MALLOC_TRACE

mas o arquivo /tmp/t(ou qualquer outro arquivo que tento usar) não foi criado. Quando eu crio um arquivo vazio com esse nome, ele permanece com comprimento zero. Tentei usar caminhos relativos no MALLOC_TRACE. Tentei adicionar setenv("MALLOC_TRACE", "/tmp/t", 1);dentro do programa antes da mtrace()chamada. Tentei adicionar muntrace()antes que o programa termine. Tentei essas táticas no Ubuntu 22.04 e no Fedora 39 e obtive o mesmo resultado: o arquivo de rastreamento está vazio. O ctime e o mtime no arquivo (se eu criá-lo com antecedência) permanecem inalterados quando executo o programa. Verifiquei que as permissões do arquivo e seu diretório pai são de leitura/gravação. stracenão está mostrando que o arquivo em questão está stateditado, muito menos aberto.

Isso ocorre usando Glibc 2.35 no Ubuntu e 2.38 no Fedora.

Esta não é uma questão de como criar um perfil ou verificar vazamentos de memória. Sei que posso fazer isso com valgrindmeia dúzia de outros programas, isso é principalmente uma curiosidade e eu quero saber se isso é um bug que precisa ser corrigido ou se a página de manual precisa ser atualizada (ou se estou apenas entendendo mal alguma coisa e o único problema é sentar na minha cadeira).

Citando https://www.kernel.org/doc/Documentation/process/adding-syscalls.rst :

Pelo menos no x86 de 64 bits, será um requisito difícil a partir da v4.17 não chamar funções de chamada do sistema no kernel. Ele usa uma convenção de chamada diferente para chamadas de sistema, onde struct pt_regs é decodificada dinamicamente em um wrapper syscall que então transfere o processamento para a função syscall real. Isso significa que apenas os parâmetros que são realmente necessários para um syscall específico são passados ​​durante a entrada do syscall, em vez de preencher seis registros da CPU com conteúdo aleatório do espaço do usuário o tempo todo (o que pode causar sérios problemas na cadeia de chamadas).

A que problema sério na cadeia de chamadas se refere a última cláusula entre parênteses?

Para mim, parece estúpido não carregar os seis registros na preparação genérica para o syscall. Forçar cada wrapper do syscall a fazer isso os torna maiores e as funções do syscall se tornam um novo caso especial, então estou me perguntando qual é o "problema sério" de ter conteúdo de usuário não intencional em registros de argumentos não utilizados.