All perguntas(unix)

Estou basicamente tentando descobrir como alguém faria uma GUI a partir do zero com nada além do kernel linux e programação em C.

Não estou procurando criar um ambiente de desktop GUI a partir do zero, mas gostaria de criar alguns aplicativos de desktop e em minha busca por conhecimento, todas as informações que consegui encontrar estão em APIs e kits de ferramentas de GUI. Eu gostaria de saber, pelo menos para minha compreensão dos fundamentos de como a GUI do linux é feita, como alguém faria um ambiente de GUI ou um aplicativo de GUI sem usar APIs ou kits de ferramentas.

Pergunto-me se por exemplo:

1. APIs e kits de ferramentas existentes funcionam por meio de chamadas de sistema para o kernel (e o kernel é responsável no nível mais baixo por construir uma imagem GUI em pixels ou algo assim)

2. esses kits de ferramentas executam syscalls que simplesmente passam informações para drivers de tela (existe um formato padrão para enviar essas informações que todos os drivers de tela obedecem ou as APIs GUI precisam ser capazes de produzir essas informações em vários formatos, dependendo da tela/driver específico? ) e também se isso for aproximadamente verdade, o kernel linux bruto geralmente envia informações para a tela na forma de caracteres de 8 bits?

Eu realmente quero entender o que acontece entre o kernel do linux e o que eu vejo na minha tela (controle/fluxo de informações através de software e hardware, se você souber, qual formato a informação leva, etc). Eu apreciaria muito uma explicação detalhada, eu entendo que isso pode ser uma merda para explicar em detalhes suficientes, mas acho que tal explicação seria um ótimo recurso para outros que estão curiosos e aprendendo. Por contexto, sou um estudante de sci do 3º ano que começou recentemente a programar em C para o meu curso de programação de sistemas e tenho uma compreensão intermediária (ou assim eu descreveria) de linux e programação. Mais uma vez obrigado a quem me ajudar!!!

Eu tenho um laptop Debian (Buster) com 8 GB de RAM e 16 GB de swap. Estou executando uma tarefa muito longa. Isso significa que meu laptop foi deixado ligado nos últimos seis dias enquanto ele roda.

Ao fazer isso, periodicamente preciso usar meu laptop como laptop. Isso não deve ser um problema; a tarefa de longa execução é limitada por E/S, trabalhando em um disco rígido USB e não consome muita RAM (<200 MB) ou CPU (<4%).

O problema é que quando eu voltar ao meu laptop depois de algumas horas, ele ficará muito lento e pode levar 30 minutos para voltar ao normal. Isso é tão ruim que os monitores de falhas sinalizam seus respectivos aplicativos como congelados (especialmente as janelas do navegador) e as coisas começam a falhar incorretamente.

Olhando no monitor do sistema, dos 2,5 GB usados, cerca de metade é trocado. Confirmei que esse é o problema removendo o espaço de troca ( swapoff /dev/sda8). Se eu deixá-lo sem espaço de troca, ele volta à vida quase instantaneamente, mesmo após 24 horas. Com a troca, é praticamente um tijolo nos primeiros cinco minutos, restando apenas seis horas. Confirmei que o uso de memória nunca excede 3 GB , mesmo quando estou ausente.

Eu tentei reduzir o swappiness ( veja também: Wikipedia ) para valores de 10e 0, mas o problema ainda persiste. Parece que após um dia de inatividade, o kernel acredita que toda a GUI não é mais necessária e a limpa da RAM (troca-a para o disco). A tarefa de longa duração é ler através de uma vasta árvore de arquivos e ler todos os arquivos. Portanto, pode ser que o kernel esteja confuso ao pensar que o cache ajudaria. Mas em uma única varredura de um HD USB de 2 TB com ~ 1 bilhão de nomes de arquivos, uma RAM extra de GB não ajudará muito o desempenho. Este é um laptop barato com um disco rígido lento. Ele simplesmente não pode carregar dados de volta na RAM com rapidez suficiente.

Como posso dizer ao Linux para usar apenas o espaço de troca em uma emergência? Eu não quero correr sem swap. Se algo inesperado acontecer, e o sistema operacional de repente precisar de alguns GBs extras, não quero que as tarefas sejam eliminadas e prefiro começar a usar o swap. Mas no momento, se eu deixar a troca habilitada, meu laptop simplesmente não pode ser usado quando eu precisar.

A definição precisa de uma "emergência" pode ser motivo de debate. Mas para esclarecer o que quero dizer: uma emergência seria onde o sistema fica sem outra opção além de trocar ou matar processos.

O que é uma emergência? - Você realmente tem que perguntar?... Espero que você nunca se encontre em um prédio em chamas!

Não me é possível definir tudo o que possa constituir uma emergência nesta questão. Mas, por exemplo, uma emergência pode ser quando o kernel é tão pressionado pela memória que começa a matar processos com o OOM Killer . Uma emergência NÃO é quando o kernel pensa que pode melhorar o desempenho usando swap.

Edição final: aceitei uma resposta que faz exatamente o que pedi no nível do sistema operacional. Os futuros leitores também devem tomar nota das respostas que oferecem soluções em nível de aplicativo.

root@system:~# less myfile
-bash: /bin/less: Input/output error

O sistema de arquivos raiz está morto. Mas meu gato ainda está vivo (na minha memória):

root@system:~# cat > /tmp/somefile
C^d
root@system:~#

Ele é meio solitário, porém, todos os seus amigos se foram:

root@system:~# mount
-bash: /bin/mount: Input/output error
root@system:~# dmesg
-bash: /bin/dmesg: Input/output error
root@system:~# less
-bash: /bin/less: Input/output error
root@system:~# chmod
-bash: /bin/chmod: Input/output error

O sistema ainda está em execução e cumprindo seu propósito. Eu sei, eu sei, a única resposta sensata para isso é desligar o sistema e substituir a unidade raiz. Infelizmente, isso não é uma opção, pois custaria muito tempo e dinheiro. Além disso, mataria meu gato, e isso me deixaria triste.

Pensei em trazer-lhe os amigos habituais de um doador. Não me atrevo a tentar scp, caso o ssh tente carregá-lo e corte a linha (o binário desapareceu de qualquer maneira). Isso soa como um trabalho para o primo do meu gato:

root@system:~# netcat -l 1234 > /tmp/less
-bash: netcat: command not found

Infelizmente ele se foi há muito tempo.

Agora, posso tentar enganar meu gato para fazer um ritual para ressuscitá-lo:

cat > netcat < /dev/tcp/localhost/9999

E esse tipo de trabalho. Ele está quase vivo:

root@system:/tmp# /tmp/netcat
-bash: /tmp/netcat: Permission denied

Ele só precisa de uma pequena centelha de vida. Aquele pequeno+x encantamento mágico que não posso recitar no momento.

Você pode me ajudar a trazer os amigos do meu gato de volta?

Estou tentando ssh para a máquina remota, a tentativa falha:

$ ssh -vvv [email protected]
OpenSSH_7.7p1, OpenSSL 1.0.2o  27 Mar 2018
.....
debug2: ciphers ctos: aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc
debug2: ciphers stoc: aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc
debug2: MACs ctos: [email protected],[email protected],[email protected],[email protected],[email protected],[email protected],[email protected],hmac-sha2-256,hmac-sha2-512,hmac-sha1
debug2: MACs stoc: [email protected],[email protected],[email protected],[email protected],[email protected],[email protected],[email protected],hmac-sha2-256,hmac-sha2-512,hmac-sha1
debug2: compression ctos: none,[email protected]
debug2: compression stoc: none,[email protected]
debug2: languages ctos: 
debug2: languages stoc:
debug2: first_kex_follows 0 
debug2: reserved 0 
debug1: kex: algorithm: curve25519-sha256
debug1: kex: host key algorithm: rsa-sha2-512
Unable to negotiate with 192.168.100.14 port 22: no matching cipher found. Their offer: aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc

Até onde eu entendo a última string do log, o servidor se oferece para usar um dos 4 algoritmos de cifra a seguir: aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc. Parece que meu cliente ssh não suporta nenhum deles, então o servidor e o cliente não conseguem negociar mais.

Mas meu cliente suporta todos os algoritmos sugeridos:

$ ssh -Q cipher
3des-cbc
aes128-cbc
aes192-cbc
aes256-cbc
[email protected]
aes128-ctr
... and there are several more.

E se eu especificar explicitamente o algoritmo assim:

ssh -vvv -c aes256-cbc [email protected]

Posso logar com sucesso no servidor.

My ~/.ssh/confignão contém nenhuma diretiva relacionada à cifra (na verdade, eu a removi completamente, mas o problema permanece).

Então, por que cliente e servidor não podem decidir qual cifra usar sem minhas instruções explícitas? O cliente entende que o servidor suporta aes256-cbc, o cliente entende que ele mesmo pode usar, por que não apenas usá-lo?

Algumas notas adicionais:

• Não havia esse problema algum tempo (cerca de um mês) atrás. Eu não mudei nenhum arquivo de configuração ssh desde então. Eu atualizei os pacotes instalados.

• Há uma pergunta que descreve um problema de aparência muito semelhante, mas não há resposta à minha pergunta: ssh incapaz de negociar - nenhum método de troca de chave correspondente encontrado

ATUALIZAÇÃO: problema resolvido

Como a telcoM explicou, o problema é com o servidor: ele sugere apenas os algoritmos de cifra obsoletos. Eu tinha certeza de que o cliente e o servidor não estão desatualizados. Eu entrei no servidor (a propósito, é Synology, atualizado para a versão mais recente disponível) e examinei o arquivo /etc/ssh/sshd_config. A primeira (!) linha deste arquivo foi:

Ciphers aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc

Isso é muito estranho (o fato dessa linha ser a primeira no arquivo), tenho certeza de que nunca toquei no arquivo antes. No entanto, alterei a linha para:

Ciphers aes256-ctr,aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc

reiniciei o servidor (não descobri apenas como reiniciar o sshdserviço) e agora o problema desapareceu: posso ssh para o servidor como de costume.

Eu não entendo a melhor maneira de definir fs.inotify.max_user_watchescom sysctl. Na verdade, não entendo muito do que está acontecendo aqui além do fato de que preciso definir o número de arquivos que podem ser observados por um determinado processo.

Acredito que posso ver o número máximo de usuários executando este comando:

cat /proc/sys/fs/inotify/max_user_watches

Meu entendimento é que algumas pessoas sugerem mudar /proc/sys/fs/inotify/max_user_watchesabrindo /etc/sysctl.confem um editor e adicionando isto a ele:

fs.inotify.max_user_watches=524288

Em seguida, execute sudo sysctl -ppara - presumivelmente - processar as alterações feitas no arquivo.

Outros sugerem a execução de comandos como este:

sudo sysctl -w fs.inotify.max_user_instances=1024
sudo sysctl -w fs.inotify.max_user_watches=12288

Eu sei que -wsignifica escrever, mas o que está sendo escrito e onde? É só que este comando muda /proc/.../max_user_watches?

Qual das duas abordagens descritas acima é a melhor? Entendo que 524288 e 12288 são números diferentes, mas não entendo a diferença entre o efeito de correr -pe -w.

Estou definindo um script de shell que um usuário deve sourceexecutar em vez de.

Existe uma maneira convencional ou inteligente de sugerir ao usuário que esse é o caso, por exemplo, por meio de uma extensão de arquivo?

Existe um código shell que eu possa escrever no próprio arquivo, o que fará com que ele ecoe uma mensagem e saia se for executado em vez de originado, para que eu possa ajudar o usuário a evitar esse erro óbvio?

Estamos servindo uma porta no localhost e queremos verificar em outro processo se a porta está disponível. Devido a um bug em nosso código, ele está tentando se conectar ao IP 0.0.0.0:<port>e, por algum motivo, consegue - como prova o strace:

[...]
connect(3, {sa_family=AF_INET, sin_port=htons(10002), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
[...]

O que isto significa? Por que funciona?

Digamos que eu tenha um script fazendo:

some-command "$var1" "$var2" ...

E, caso var1esteja vazio, prefiro que seja substituído por nada ao invés da string vazia, para que o comando executado seja:

some-command "$var2" ...

e não:

some-command '' "$var2" ...

Existe uma maneira mais simples do que testar a variável e incluí-la condicionalmente?

if [ -n "$1" ]; then
    some-command "$var1" "$var2" ...
    # or some variant using arrays to build the command
    # args+=("$var1")
else
    some-command "$var2" ...
fi

Existe uma substituição de parâmetro que pode expandir para nada em bash, zsh ou algo semelhante? Talvez eu ainda queira usar o globbing no restante dos argumentos, portanto, desativá-lo e remover as aspas da variável não é uma opção.

[4.13.12-1-ARCH com gnome3 e gdm no Xorg]

Eu já defini meus env-vars VISUAL e EDITOR para vim. Da mesma forma, tentei SYSTEMD_EDITOR="vim"; export SYSTEMD_EDITOR em meu ~/.bashrc, sem sucesso.

Ao modificar arquivos de unidade no Arch (systemd) via

 $ sudo systemctl edit _unit_ 

Eu me pego encarando nano. A vida é muito curta e eu quero vimpor todos os meios. Como eu faço isso ?

Fiz uma instalação limpa do Arch Linux e importei minha chave privada gpg de backup. Como uma verificação de sanidade, corri:

gpg —list-keys

Tudo apareceu normalmente, exceto pelo uidque agora diz:

uid [ unknown ] User < [email protected] >

Quando criei essa chave antes da instalação limpa, ela dizia:

uid [ ultimate ] User < [email protected] >

Por que mudaria de [ ultimate ]para [ unknown ]depois de importá-lo para uma instalação limpa?

Desde já, obrigado.