PSkocik's questions

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.

Então eu encontrei um bug, consertei e quero enviar o patch para ele.

Segui o vídeo do youtube Write and submit your first kernel patch patch , configurei o git-email, formatei tudo, etc., e quero enviá-lo.

Meu problema: não quero enviá-lo sozinho, mas com uma mensagem de acompanhamento e um código de espaço de usuário de amostra que é corrigido pelo patch. Ambos parecem inadequados para a mensagem de confirmação.

Devo enviá-lo através de um e-mail separado? Isso também precisa ser formatado de alguma forma especial?

Suponha que eu esteja criando um arquivo ou diretório com algum argumento de nome e modo usando uma chamada de sistema e que as operações falhem com EEXIST.

Supondo que eu conheça meu umask, euide egid, como posso saber se esse arquivo/diretório existente tem permissões equivalentes ao que a chamada do sistema teria criado se a operação fosse bem-sucedida.

AFAIK, para permissões clássicas, a resposta seria true iff .st_gid == egid && .st_uid == euid && (.st_mode & 07777) == (RequestedMode & 07777 & ~CurrentUmask)e os tipos de arquivo encontrados/esperados correspondem.

Como isso poderia ser estendido a um sistema com listas de controle de acesso?

De C, qual é a maneira mais fácil de executar um utilitário padrão (por exemplo, ps) e nenhum outro?

O POSIX garante que, por exemplo, um padrão psestá em /bin/psou devo redefinir a variável de ambiente PATH para o que recebo confstr(_CS_PATH, pathbuf, n);e, em seguida, executar o utilitário por meio da pesquisa PATH?

O MacOS tem uma contrapartida para o unshare(2) do Linux ?

Eu gostaria que o seguinte falhasse em ambos os sistemas.

#define _GNU_SOURCE
#include <stdlib.h>
#include <sched.h>
int main()
{
#if __linux__
    if(0>unshare(CLONE_NEWNET)) return EXIT_FAILURE;
#elif __APPLE__
    /*?*/
#endif
    //this should fail on either system
    if(0!=system("curl www.google.com")) return EXIT_FAILURE;
}

Quando eu faço

( sleep 1; read x ; echo x=$x; echo done ) & 

então, com as configurações padrão do terminal, o trabalho é interrompido por SIGTTIN.

Se eu fizer

( ( sleep 1; read x ; echo x=$x; echo done ) & )

o readsyscall dentro readrecebe EOF (retorna com 0)` e nenhuma parada por SITTIN acontece.

Qual é a explicação para esses comportamentos

Eu queria saber se existe uma abreviação para esse tipo de coisa.

Atualmente posso fazer.

var_empty=; [ -n "$var" ] || var_empty=1; #intermediary variable
echo "REPL_if_var_empty_otherwise_empty=${var_empty:+REPL}"

Isso é possível sem o intermediário?

eu tentei

sh -c 'readonly SAME=SAME; var=; echo test0=${var:-SAME} test1=${SAME:+REPL}; echo REPL_if_var_empty_otherwise_empty=${${var:-SAME}:+REPL}'

mas isso resulta em um bad substitutionerro no último echo( test0=SAME test1=REPL). Por que é que? Existe outra maneira?

Eu esperava isso:

nc -l localhost 7000 </dev/null &
nc localhost 7000 </etc/profile

e isto

nc -l localhost 7000 </etc/profile &
nc localhost 7000 </dev/null

para terminar depois de imprimir meu /etc/profile mas ambos os grupos de comandos acabam travando (ambos os processos no primeiro caso; no segundo caso, o servidor termina mas o cliente não).

Por que os comandos não terminam?

Isso é um bug no meu nc/Linux (4.15)? Eu tentei no MacOS e Cygwin e apenas os comandos do Linux não estão terminando.

Este comando:

rm -f testfile && touch testfile && chown 0 testfile

está falhando no Cygwin com erro:

chown: changing ownership of 'testfile': Invalid argument

Por quê?

É possível usar xargs para invocar um comando para que o último argumento do comando seja corrigido?

Minha tentativa:

printf '%s\n' a b c d | xargs -I{} echo {} LAST

acaba fazendo

echo a LAST  
echo b LAST  
echo c LAST  
echo d LAST  

Eu quero que xargs invoque

echo a b c d LAST
#fit as many as you can but always finish wiht LAST

É possível fazer isso, de preferência de forma portátil?

Existe um teste portátil para saber se uma variável (cujo nome é conhecido estaticamente em um script) não está definida (que é diferente de vazia)?

Estou tentando executar um script na inicialização como root.

(Apenas configura um diretório de propriedade do root em /tmp ).

Atualmente, estou usando este script para configurar o gancho de inicialização e parece fazer o trabalho:

#!/bin/sh -eu
if [ 0 -eq $((${1:-0})) ]; then
    #install
    [ -x /etc/init.d/tmpsetup ] ||  {
        cat > /etc/init.d/tmpsetup <<'EOF'
#!/bin/sh -eu
[ $(id -u) -eq 0 ]
umask 0222
mkdir -p /tmp/u/
EOF
        chmod a+rx /etc/init.d/tmpsetup
        update-rc.d tmpsetup defaults 99
        }
else
    #uninstall
        rm -f /etc/init.d/tmpsetup
        update-rc.d tmpsetup remove
fi

Existe uma maneira mais portátil / melhor de fazer isso?

(É para implementar um recurso /tmp por usuário. Deve fazer parte de um script de instalação que adapta um sistema existente.)