Scott M's questions

Em um raspberry pi (um raspian recente), escrevi um aplicativo que, sob demanda por meio de solicitação de rede, gera um aplicativo e, sob demanda, por meio de solicitação de rede diferente, o mata. O mecanismo de desova é apenas fork/exec. Matar é feito com kill(childPid, SIGQUIT). É um simples pedaço de C++ como você pensa e funciona bem.

Ou seja, funciona bem, a menos que eu o inicie em /etc/rc.local. O comando para iniciá-lo a partir daí é apenas um cd apropriado e depois

    ./effectPlayer &

e ele inicia bem, recebe solicitações bem, gera bem (abrange um aplay, por isso é trivial saber quando funciona), mas falha completamente ao matar o subprocesso aplay a pedido. Ele chama kill() normalmente e kill() retorna 0. Mas aplay continua.

Eu suponho que isso seja alguma estranheza tendo a ver com o fato de que spawná-lo de /etc/rc.local dá a ele algum comportamento especial em fork ou kill, mas não entendo o quê. o que estou perdendo?

Edit: adicionando respostas às perguntas. Execute a partir de /etc/rc.local com o log ativado, o aplicativo relata:

    23:10:06 10-11-2019 (effectPlayer) 7: P1 64 elvenHall  #command to start playing
    23:10:06 10-11-2019 (sound) launched 1083: /usr/bin/aplay -q -... #what it forks/execs
    23:10:10 10-11-2019 (effectPlayer) 7: X1000 #command to stop playing
    23:10:10 10-11-2019 (sound) sending 3 to 1083, result 0 0 #what kill() is asked to do

Tradução, é solicitado a tocar um efeito específico e gera um aplay para lidar com isso. Funciona (ouço o áudio) e depois mando um comando para parar toda a reprodução. Ele chama kill() com sucesso no PID correto com o sinal correto e kill() retorna 0 com errno=0. Exceto que o aplay ainda está em execução.

Quando faço a mesma sequência na linha de comando, tudo age da mesma forma, exceto que um jogo realmente morre.

Quando troco SIGQUIT por SIGKILL, funciona como esperado: aplay morre independentemente de como o effectsPlayer é iniciado.

Vou atribuir isso a alguma estranheza em uma peça por enquanto. Eu não gosto de usar o SIGKILL - pode haver uma limpeza importante sendo ignorada. Mas funciona...

Por razões melhor descritas como filosóficas, gostaria de saber o seguinte. Suponha que eu vou ler de /dev/random (ou /dev/urandom) no tempo X. Em um cenário eu apenas faço isso, mas em outro, com /dev/random no estado idêntico, eu empurro algum número de bytes em /dev/urandom logo antes do tempo X. As saídas são as mesmas? Ignore o caso em que, por uma grande e estranha coincidência, os bytes específicos que escrevo deixam o estado de /dev/random no mesmo estado em que estavam antes.

Outra maneira de perguntar: escrever em /dev/random altera imediatamente (exceto coincidência improvável) o estado de /dev/random, ou existe algum tipo de buffer (de entrada ou saída) que significa que /dev/random será afetado por minhas gravações, mas apenas em um futuro potencialmente distante?

Nota: não estou usando o ioctl para reivindicar entropia extra disponível quando escrevo.

Quero enfatizar que esta não é uma questão "importante", e eu groco completamente que, pelo que sei, algum hardware de aleatoriedade quântica pode mudar de estado porque alguém em todo o mundo bocejou ou não bocejou, muito menos se eu bocejo ou não. não faça uma escrita. Esta questão é estritamente sobre se o ato de escrever em /dev/random faz uma mudança imediata de estado no software, ou se /dev/random armazenou em buffer o que você vai obter em seguida (ou armazena em buffer o que você escreve nele até ele decide reenviar algo) e, portanto, o efeito das gravações é atrasado.

Uma vez que esta pergunta está claramente fora da parede, deixe-me explicar por que estou perguntando. Eu corro um jogo onde as saídas de /dev/random são usadas para decidir os resultados do jogo. Durante o jogo, as pessoas estão falando sobre o mumble e eu pego uma cópia em tempo real desse fluxo de áudio, faço o hash e coloco em /dev/random. O que estou tentando decidir é se posso afirmar, com precisão, mas absurdamente, "Se você não tivesse dito isso, você não teria lançado aquele 1", ou se eu deveria apenas fazer a afirmação mais fraca "o que você disse vai voltar para assombrar suas jogadas de dados algum dia."

Também é interessante saber se "afeta agora" provavelmente será uma propriedade permanente de /dev/random ou é apenas um acaso da implementação atual.

Obrigado!

Problema: meu código de servidor de música, usando uma conexão TCP simples em um soquete de bloqueio, precisa transmitir bytes para um cliente (acontece ser um squeezebox da Logitech). Não é complicado - leia 64k de um arquivo, grave-o no squeezebox, repita. Está tudo rodando em uma LAN local não ocupada, e o servidor e o cliente squeezebox estão conectados ao mesmo switch. O squeezebox não consome o fluxo muito rapidamente, então o servidor, em praticamente qualquer hardware, não deve ter problemas para manter o cliente alimentado.

E quando o servidor é executado em um Raspberry pi 3B+, na verdade não há nenhum problema. Um pi zero provavelmente poderia acompanhar. Quando é executado no meu laptop Linux, idem, está tudo bem. Posso perguntar ao squeezebox periodicamente o quão cheio está o buffer interno e ele rapidamente chega a cerca de 99+% e permanece lá. As gravações do servidor (após as primeiras) passam a maior parte do tempo bloqueadas, como seria de esperar.

Mas eu movo o servidor para um Azulle Inspire rodando Linux, conectado ao mesmo switch, e algo dá muito errado. A música começa a tocar, mas rapidamente gagueja e morre. O squeezebox informa que o buffer está começando a encher, mas então algo trava e o buffer esvazia rapidamente (às vezes aumentando um pouco, então acho que algum tráfego passa, mas não o suficiente), interrompendo a música. O servidor afirma que continua escrevendo, embora as gravações demorem mais do que eu esperava.

Observe que o Azulle tem outras funções de rede ocasionais e todas funcionam bem, embora eu provavelmente não notaria pequenos atrasos de rede para a maioria desses outros aplicativos. Mas quando o servidor de música está em execução, o NUC (e a rede) ficam ociosos - isso não é um problema de CPU ou largura de banda.

Já tentei trocar cabos, trocar switches e usar portas diferentes nos switches. Eu tentei enviar tamanhos de buffer diferentes. Sem efeito. Tudo o que posso dizer é que há algo muito instável sobre a pilha TCP ou o hardware ethernet.

Como depuro isso? O laptop linux, que funciona muito bem, está executando o Linux 4.15.0-55-generic (e o apt upgrade não muda isso). O Azuelle está rodando Linux 4.15.0-64-generic, Mint. Eu não posso acreditar que há uma mudança radical no tratamento do TCP no 4.15.0. Eu não estou muito familiarizado com ferramentas como tcpdump, deixe ao longo da configuração do kernel ou depuração, então estou procurando por alguns ...

os tempos de ping entre o laptop Linux e o Azuelle são consistentemente em torno de 0,2 ms e 0,35 ms, com 0,33 ms típico.

Estou perdido. TIA.

Eu tenho um aplicativo CGI que entra em ação assim que é carregado. Infelizmente, os bots do google o encontraram e estão ignorando os norobots, então as ações estão sendo acionadas em momentos aleatórios. Então eu quero proteger com senha o código CGI. Não quero que o cgi-binscript lide com a senha - quero que o Apache faça isso antes que o script seja executado.

Não consigo ver como fazer isso? O Apache encontra cgi-binpor meio de um arquivo ScriptAlias. Não há Directorytag para definir um AuthTypeon. Criar um diretório para o script e manipulá-lo <Directory>não o executa como um script.

Existe um truque para isso?

Isso pode não ser possível, mas... Eu tenho um aplicativo de terceiros (mumble para os curiosos) que pode ser instruído a abrir um arquivo para gravação (eu forneço o nome) e despejar bytes nele até que seja dito para parar. Ele não abre o arquivo para anexar e se o arquivo já existir muda o nome e tenta novamente. Tudo bem, bom e bastante padrão. Ele pode gravar por horas (e preencherá o disco com prazer, que é o problema).

Eu quero interceptar tudo que ele escreve e ler de outro processo; idealmente, ele nunca chegaria ao disco, mas aceitarei compromissos onde alguns deles chegarem.

A solução óbvia, para ler o arquivo como está escrito, truncate() o que eu leio e leio novamente, não funcionará para mim, porque o arquivo não ficará menor quando eu truncar - mumble não especifica append, então continuará escrevendo de onde parou. Idealmente, eu preciso de alguma maneira de enganá-lo para pensar que ele criou e está escrevendo um arquivo normal, enquanto na verdade está apenas canalizando tudo para mim. Não quero escrever meu próprio código de sistema de arquivos para isso (a menos que seja muito mais fácil do que parece).

Em última análise, eu quero obter o som gravado, fazer um hash e alimentá-lo para /dev/random. Apenas apontar mumble para /dev/random não funciona porque /dev/random existe, então ele não será usado.

existe um truque inteligente para isso? Se não, existe alguma maneira de escrever código de userland que se pareça com um diretório? Se tudo mais falhar, é bastante simples escrever um sistema de arquivos que possa fazer o que eu preciso?

Estou tentando alterar a cor do texto em um rótulo em tempo de execução. Eu tentei aplicar um estilo css, tentei dois métodos depreciados e nada disso funciona. Isso pode ser feito e, se não, por que algo tão simples não está disponível?

Aplicar um estilo css em tempo real funciona parcialmente: quando eu especifico

.pinkStyle {
    background-color: rgb(241, 135, 135);
    color: black;
}

em tempo de execução, posso ver o fundo ficar rosa. Mas o texto permanece branco.

Tentando novamente com uma pergunta mais curta e mais focada. Observe que esta NÃO é a pergunta usual "por que o arquivo nr está relatando um número menor do que o esperado". Eu tenho o problema oposto.

Um sistema Linux 2.6 está vazando identificadores de arquivo. Eu sei disso porque periodicamente cat /proc/sys/fs/file-nr. O primeiro número tende a aumentar em algumas horas, o segundo número é sempre 0. Quando o primeiro número atinge o terceiro, o login torna-se impossível, não há novos shells etc. um vazamento significativo de identificador de arquivo. (O sistema nem sempre faz isso e não encontramos rima ou razão para o que faz isso começar a acontecer, mas é bastante comum.)

Agora a parte estranha. Executando como root, eu faço ls -l em todos os fds, via /proc/each process id/fd. Observe que estou fazendo isso como root, portanto, devo ver todos os identificadores de arquivo de todos os processos.

De acordo com meu entendimento limitado, a saída de ls deve revelar aproximadamente o mesmo número de identificadores que o file-nr mostra. Eu não esperaria que fosse exato, porque os processos podem ir e vir e eles podem abrir ou fechar arquivos enquanto eu estou andando /proc/#. Mas feito o suficiente, eu esperaria, em média, um acordo aproximado. Portanto, a primeira pergunta é: essa suposição é razoável e, se não, por que não?

Eu pergunto porque file-nr mostra a contagem de identificador aumentando lentamente, marchando para 65536. Mas a saída agregada de /proc/ids../fd mostra milhares de identificadores a menos. Em um ponto, por exemplo, file-nr parecia algo como "9900 0 65536", mas a contagem dos identificadores de arquivo por processo no proc chegou a menos de 2.000 e, feita repetidamente, permaneceu mais ou menos constante. O que quer que esteja vazando, as alças não estão aparecendo como um processo.

Uma diferença de mais de 7000? Quando os processos não estão iniciando e parando descontroladamente e não deveriam estar abrindo e fechando arquivos freneticamente? Observe que o limite de manuseio de arquivo físico por processo é 1024, portanto, não é como se algum processo estivesse causando isso. O sistema mostra algumas dezenas de processos extintos, mas não pensei que processos extintos pudessem reter identificadores de arquivo. E eu tenho outras pessoas verificando meu trabalho para que não pareça ser um mau uso estúpido de ls ou algo assim.

Este é um problema crítico para mim e se alguém puder explicar por que há tanta discordância nas contagens, isso poderia me colocar no caminho certo para resolver um problema crítico e de interrupção da produção.

Observe que não estou usando lsof - ele foi removido do sistema. Mas, como estou interessado apenas em manipulações de arquivos reais, que podem ser diferentes de "arquivos abertos", percorrer /proc/#s deve ser bom o suficiente. Ou então eu pensei.