All perguntas(unix)

Recentemente encontrei o driver de dispositivo Linux Null Block , null_blkenquanto fazia benchmarking da pilha de E/S em vez de em um dispositivo de bloco específico. Achei os dispositivos criados sob este driver (vamos usar o nome do dispositivo /dev/nullb0como exemplo) bastante intrigantes, especialmente considerando sua semelhança de nome com o /dev/nulldispositivo. Como não encontrei nenhuma dúvida existente sobre esse assunto, resolvi entrar em contato para obter esclarecimentos.

Minha pergunta principal é: quais são as diferenças entre /dev/nullo dispositivo de bloco criado no null_blkdriver do dispositivo?

Até este ponto: já notei algumas distinções.

• Primeiro, (até onde entendi), o dispositivo nulo /dev/nullnão passa por nenhum driver. No entanto, os dispositivos criados null_blksão verdadeiros drivers de bloco pelos quais os dados devem passar. Também confirmei isso executando fioem ambos os dispositivos; /dev/nulltem um desempenho muito melhor em termos de IOPS de leitura aleatória e latência de envio.
• Segundo, sabemos que a leitura from /dev/nullresulta em um EOF (por exemplo, cat /dev/null), mas quando tento cat /dev/nullb0, ele não retorna um EOF e, em vez disso, trava.
• Além disso, como observação lateral, a documentação do kernel null_blkmenciona parâmetros para configuração, mas não vejo nenhuma opção semelhante para /dev/nullser configurada.

Parece que existe um grande número de diferenças sob nomes semelhantes. Alguém pode fornecer mais informações formais ou esclarecimentos sobre essas diferenças? Obrigado!

Gosto nanoe uso muito. Um aplicativo relacionado é o rnano.

Do rnanomanual:

DESCRIPTION
       rnano  runs  the  nano  editor in restricted mode.  This allows editing
       only the specified file or files, and doesn't allow the user access  to
       the filesystem nor to a command shell.

       In restricted mode, nano will:

       • not allow suspending;

       • not allow saving the current buffer under a different name;

       • not allow inserting another file or opening a new buffer;

       • not allow appending or prepending to any file;

       • not make backup files nor do spell checking.

Quando devo usar rnano?

Quando tenho dois terminais separados logados via SSH no meu servidor, notei que quando um dos terminais digita a senha para o sudo, o outro terminal tem acesso ao sudo sem senha. Isso parece incomum/inseguro. É isso?

Encontrei o inode de um arquivo usando ls -li. Então encontrei o bloco inicial a partir do qual este arquivo está gravado no disco. Copiei o conteúdo do bloco do comando dd para outro diretório. Em seguida, destruí o arquivo usando o utilitário Shred "shred -uvz -n = 10 file1.txt" e executei novamente o mesmo comando dd. arquivo foi novamente recuperado. Eu deveria obter 00000 depois que o arquivo fosse destruído. o que estou perdendo?

Na segunda iteração, não removi o arquivo e, em vez disso, executei "shred -vz -n = 10 file2.txt" Seguindo as etapas mencionadas anteriormente, consegui novamente recuperar o arquivo original usando o comando dd e a posição do bloco. No entanto, o conteúdo do arquivo fragmentado contém 00000, conforme mostrado no hexdump file2.txt. o que estou perdendo?

Estou executando o Debian Bookworm em um TS412 (QNAP); ele armazena o kernel e o initrd em flash. Tem um total de 16 MB de flash. Portanto, mesmo depois de ajustar as partições MD, o melhor que consigo é um initrd de 12 MB. Estou usando compactação xz. Mas mesmo assim, o initrd inicial era de 12,5 MB. Eu sei que a solução comum é reduzir os módulos, mas eles não são o verdadeiro problema.

2984    .../usr/lib/modules
6036    .../usr/share
18824   .../usr/lib/arm-linux-gnueabi

Procurando em arm-linux-gnueabi tinha coisas como libX11... Essa máquina nem tem console (até conseguir uma linha serial é difícil) certamente não precisa de "X".

Então eu removi muitos pacotes totalmente (apt-get remove ...), na verdade, um pouco mais do que deveria. Mas o resultado foi um initrd muito menor (cerca de 5 MB IIRC) que inicializa e funciona perfeitamente.

O problema é que, se eu fizer ssh na caixa e executar o emacs(1), seria bom projetar a versão da GUI de volta para minha área de trabalho normal (que tem muita memória e telas grandes, etc.), mas isso exigiria a instalação do Bibliotecas cliente X no TS412.

Agora não vejo por que só porque tenho o pacote com as bibliotecas do cliente X instaladas, uma cópia precisa ser mantida no initrd, elas não são necessárias durante a inicialização. Existe uma maneira de limitar a entrada de outras coisas no initrd, não apenas nos módulos (que não são os culpados)

Já tentei pesquisas em documentos em busca de guias para limitar o initrd.

Hoje notei que algo mudou no Perl, provavelmente recentemente, na forma como ele executa comandos shell. Alguém poderia explicar o que mudou? Não consigo encontrar a resposta sozinho e, infelizmente, aprendemos sobre essa mudança da maneira mais difícil possível. Alguns novos usuários obtiveram conteúdos interessantes de seus novos diretórios pessoais...

Estou executando um comando/script simples:

#!/usr/bin/perl -w

system("ls -R /etc/skel/.[^.]*");

No Debian 11: perl v5.32.1, a saída é apenas o conteúdo de /etc/skel(como esperado):

.  ..  .bash_logout  .bashrc  .face  .face.icon  .kshrc  .profile

Mas no Debian 12: perl v5.36.0o globbing ^é ignorado e o todo /etcé lido, o que significa ..que não é ignorado .

Quando mudo ^para o símbolo alternativo !: system("ls -R /etc/skel/.[!.]*");, ele funciona conforme o esperado novamente.

A questão é: o que mudou no Perl no tratamento de símbolos !e ^na system()invocação?

EDITAR: 29.09.2023, 19h50

Fiz alguns testes nos dois servidores e parece que algo mudou dash?

Debian 11: dash Version: 0.5.11+git20200708+dd9ef66-5(não vejo uma --versionbandeira no traço, então é do APT).

root@s:~# dash -c 'ls -R /etc/skel/.[^.]*'
/etc/skel/.bash_logout  /etc/skel/.bashrc  /etc/skel/.forward+spam  /etc/skel/.kshrc  /etc/skel/.profile
root@s:~# dash -c 'ls -R /etc/skel/.[!.]*'
/etc/skel/.bash_logout  /etc/skel/.bashrc  /etc/skel/.forward+spam  /etc/skel/.kshrc  /etc/skel/.profile

Debian 12:dash Version: 0.5.12-2

[students] ~ ➽ $ dash -c 'ls -R /etc/skel/.[^.]*' | more
/etc/skel/..:
a2ps.cfg
a2ps-site.cfg
adduser.conf
adjtime
aliases
aliases.db
alsa
alternatives

[students] ~ ➽ $ dash -c 'ls -R /etc/skel/.[!.]*'
/etc/skel/.bash_logout  /etc/skel/.bashrc  /etc/skel/.face  /etc/skel/.face.icon  /etc/skel/.kshrc  /etc/skel/.profile

Atenciosamente, Kamil

Eu tenho um alto-falante aleatório e quero desenvolver um driver para ele, para que eu possa relatar estatísticas, bateria, etc. ao devsistema de arquivos. No entanto, estou tendo dificuldade em encontrar o fornecedor do alto-falante e a identificação do dispositivo para associá-lo corretamente ao driver.

Eu nem sei quem é o fabricante e minha máquina Linux não detecta ( lsusb, e outros utilitários), T&G tem um alto-falante exatamente igual ao meu, mas o meu tem um logotipo diferente (flor de laranjeira), não O da T&G.

• Cada dispositivo tem um ID de fornecedor e produto associado a ele?

• em caso afirmativo, como você o encontra se não conhece seu dispositivo e sua máquina não o reconhece?

• É possível relatar bateria e outras estatísticas para minha máquina por meio de uma porta USB do meu alto-falante, que acredito ser usado com um cartão USB?

Eu tenho um arquivo que é originário .bashrce .zshrcque contém algumas funções. Anteriormente, eram dois arquivos separados (para cada shell), mas agora estou usando um único arquivo, pois os arquivos eram quase idênticos e é mais fácil para mim gerenciar um único arquivo de funções.

Existe uma função que é diferente para os dois shells, então pensei em usar uma declaração condicional para que a correta seja usada:

[[ $BASH_VERSION ]] && shell=bash
[[ $ZSH_VERSION ]] && shell=zsh

# Search man page for string
if [[ $shell == bash ]]; then
  mans() {
    local q="\'"
    local q_pattern="'${1//$q/$q\\$q$q}'"
    local MANPAGER="less -+MFX -p $q_pattern"
    man "$2"
  }
elif [[ $shell == zsh ]]; then
  mans() MANPAGER="less -+MFX -p ${(q+)1}" man $2
fi

Isso parece funcionar bem no zsh, mas ao mudar para o bash, recebo um erro da linha zsh, mesmo que não deva ser usado no bash. Existe alguma maneira de impedir que ele analise essa linha?

Eu quero criar um arquivo ISO virtual de /dev/sr0, sem ter que criar um arquivo ISO real. O objetivo é compartilhá-lo com um dispositivo Android executando o VLC. Android/VLC só é capaz de abrir discos (com suporte de menu, etc) como um arquivo ISO.

Espero entender o conceito de arquivo esparso. Eu também sei cpos comandos--sparse=...

No entanto, ao pesquisar no Google os aplicativos práticos, encontrei declarações ambíguas sobre como é transparente para um aplicativo que lê/grava arquivos usando a API de E/S de arquivo do sistema operacional comum (quero dizer, não no nível extremamente baixo, apenas fopen (), fclose () etc)

Não é limpo ao ler blogs, explicações que falam sobre como um aplicativo, por exemplo, um editor de teste "arruina" um arquivo esparso gravando explicitamente zeros nele. Eu pensei que este é o ponto, que se houver um arquivo esparso e o aplicativo gravar zeros, isso não será armazenado fisicamente. O aplicativo não precisa saber disso e não precisa lidar com lacunas e coisas do tipo, isso é responsabilidade do sistema de arquivos.

Pergunta

Suponha que haja um arquivo existente que seja esparso. Será totalmente transparente para a aplicação ou não? Digamos que haja um arquivo esparso de 1G, cujo primeiro byte é diferente de zero, todos os outros bytes são zero. Quando um aplicativo "comum" abrir esse arquivo, suponho que possa abri-lo, e verá que seu comprimento é 1G e pode buscar no meio (0,5G), como não era esparso, pode escrever um byte diferente de zero para meio, salve, feche e vai ficar esparso no sistema de arquivos, não vai?

Um arquivo será esparso 'automaticamente'? Quero dizer, um aplicativo simplesmente cria um arquivo, depois escreve um monte de zeros e depois escreve, será esparso ou não? Se não, o que um aplicativo deve fazer para criar esse arquivo como esparso?