Rick's questions

Eu sei ver se estou em uma tela: fiz um alias alias inscreen = 'echo $STY'.

Mas hoje cedo, eu acidentalmente digitei screendentro de um screensem perceber e de alguma forma isso me fez cometer um erro mais tarde.

Coisas que observo quando digito screen(tela interna) dentro de uma screen(tela externa):

1. screen -lsmostra apenas 1 resultado relacionado a essa tela
2. echo $STYé o mesmo na tela interna e externa
3. ctrl + Ae ctrl + Dpode se separar da tela interna para nenhuma tela, mas quando screen -rvoltar, existe a tela interna e a tela externa
4. agora posso exitduas vezes: tela interna exit-> tela externaexit

Então, minha pergunta é , existe alguma maneira de eu saber que estou em uma tela de uma tela?

PS Ao digitar screenpela primeira vez, aparecerá algum texto:

se digitar screendentro de um screen, ele não mostrará essas dicas.

Depois de ler esta diferença de pergunta entre libc6-dev e libc6 , iniciei um novo Ubuntu 20.04 LTSVPS e verifiquei quais arquivos estão incluídos em alguns pacotes do Ubuntu.

Eu verifiquei libc6-dev( https://packages.ubuntu.com/focal/amd64/libc6-dev/filelist ) e libc6( https://packages.ubuntu.com/focal/amd64/libc6/filelist ).

Como podemos ver, as libc6-devbibliotecas de compartilhamento estão em /usr/lib/x86_64-linux-gnu/e libc6as bibliotecas de compartilhamento estão em /lib/x86_64-linux-gnu/.

Mas o que me deixa curioso é que:

1. Eu também tenho libc.so.6 sob /usr/lib/x86_64-linux-gnu/( libc.so.6 -> libc-2.31.so*). E apt install remove libc6-devnão remove libc.so.6. De onde vem isso libc.so.6?

2. O -rw-r--r-- 1 root root 298 Apr 7 09:24 libc.soinstalado pelo libc6-devpackge é apenas 298bytes, o que? Por quê?

sudo apt list --installedsaída: https://pastebin.com/geDjY2z2
ll -h | grep libc saída: https://pastebin.com/UHn5QVt1

ll -h | grep libcsaída, esquerda(remover libc6-dev):

Veio desta pergunta: Qual é o encaminhamento de porta ssh e qual é a diferença entre o encaminhamento de porta ssh local e remoto , estou confuso sobre esse uso:

ssh -L 123:farawayhost:456 remotehost

ssh -L sourcePort:forwardToHost:onPort connectToHostsignifica: conectar com ssh para connectToHost, e encaminhar todas as tentativas de conexão para a porta local na máquina chamada , que pode ser acessada pela máquina.sourcePortonPortforwardToHostconnectToHost

O que significa "..., que pode ser alcançado a partir da connectToHostmáquina." quer dizer exatamente?

Se bem entendi, ssh -L 123:localhost:456 remotehosté um caso específico para o comando acima, onde ambos farawayhoste remotehostestão na mesma máquina.

Então, quando farawayhostestá e remotehostnão está na mesma máquina, como funciona? Isso significa que eu preciso fazer login remotehostprimeiro e depois farawayhost?

Estou lendo a Interface de programação do Linux .

49.9 MAP_NORESERVE e superalocação de espaço de swap

Alguns aplicativos criam mapeamentos grandes (geralmente anônimos privados), mas usam apenas uma pequena parte da região mapeada. Por exemplo, certos tipos de aplicativos científicos alocam um array muito grande, mas operam em apenas alguns elementos amplamente separados do array (um chamado array esparso).

Se o kernel sempre alocasse (ou reservasse) espaço de troca suficiente para todos esses mapeamentos, muito espaço de troca seria potencialmente desperdiçado. Em vez disso, o kernel pode reservar espaço de troca para as páginas de um mapeamento apenas quando elas forem realmente necessárias (ou seja, quando o aplicativo acessar uma página). Essa abordagem é chamada de reserva de troca lenta e tem a vantagem de que a memória virtual total usada pelos aplicativos pode exceder o tamanho total da RAM mais o espaço de troca.

Para colocar as coisas de outra forma, a reserva de troca lenta permite que o espaço de troca seja supercomprometido. Isso funciona bem, desde que todos os processos não tentem acessar todo o intervalo de seus mapeamentos. ...

Tanto quanto sei, o espaço de troca é um pedaço de espaço em disco, reservado para troca de memória. Quando essas páginas na memória estão inativas, elas são trocadas no espaço de troca no disco. É como um cache de segundo nível para memória/ram.

Então, o que diabos é esse mecanismo de reserva de swap preguiçoso ?

Deixe-me demonstrar minha confusão com um exemplo.

1. Alguns aplicativos criam mapeamentos grandes (geralmente anônimos privados)....

Ok, então suponha que eu tenha mallocum grande array de 16384(4096*4)bytes (crie mapeamentos grandes (geralmente anônimos privados)) e opere apenas alguns elementos amplamente separados do array.

Então algumas páginas inativas são trocadas em espaço de troca, certo? Digamos que 0-4095(4096B), 8192-12287(4096B)estejam na memória e todas as outras páginas inativas, 4096-8191(4096B), 12288-16383(4096B)sejam trocadas no espaço de troca.

Então o que significa dizer:

Em vez disso, o kernel pode reservar espaço de troca para as páginas de um mapeamento apenas quando elas forem realmente necessárias (ou seja, quando o aplicativo acessar uma página).

Onde mais essas páginas inativas ( 4096-8191(4096B)e 12288-16383(4096B)) podem ficar, se não ficarem no espaço de troca ? O texto parece indicar que existe um cache de 3º nível para o espaço de troca.

memory -> swap space (disk) -> ????

Isso é mais como uma questão conceitual. Preciso de alguns esclarecimentos.

Hoje eu estava aprendendo algumas coisas de programação de soquete e escrevi um servidor de bate-papo simples e um cliente de bate-papo baseado no Guia de programação de rede de Beej . (servidor de chat recebe mensagens de clientes e envia mensagens para todos os outros clientes)

Copiei o servidor de bate -papo e escrevi meu próprio cliente de bate-papo .

O cliente de bate-papo é apenas um programa para enviar stdinentrada para o servidor e imprimir dados de soquete do servidor.

Mais tarde notei que o guia diz que posso usar apenas telnetpara me conectar ao servidor. Eu tentei e funcionou.

Eu não estava familiarizado com telnet e por muito tempo não sei exatamente o que é.

Então agora minha experiência me confunde:

O telnet não é apenas um simples programa de envio/eco de TCP? O que torna tão especial ser uma coisa de protocolo ? Meu programa cliente de bate-papo burro não cria um protocolo [aplicativo].

De Wikipedia Communication_protocol :

Em telecomunicações, um protocolo de comunicação é um sistema de regras que permite que duas ou mais entidades de um sistema de comunicação transmitam informações por meio de qualquer tipo de variação de uma quantidade física.

Que regras o Telnet cria? telnet host port, abra um soquete de fluxo TCP para entrada/saída bruta? Isso não é uma regra.

Me corrija se eu estiver errado:

Se bem me lembro, um comando no terminal está vinculado a um executável específico (ou talvez um script também seja permitido?) no sistema de arquivos/disco.

Por exemplo, pythonexecuta python2.7 e python3executa python3.

Agora o problema é que instalo 2 pacotes com o mesmo comando de terminal.

pip install packageA
pip3 install packageA

Ambos tem o comando packageACommand run. Então, eu quero verificar as packageACommandinformações de comando atuais para ver qual python/quais ambientes ele está usando.

E, geralmente, estou querendo saber como posso visualizar as informações (meta) de um comando? Como verificar o que realmente faz/ligou nos bastidores?

Vejo uma pergunta antiga mostrando que, ao sshse conectar a um servidor, uma impressão digital hexadecimal é exibida.

Por que agora é dado no formato base64? Qual é o benefício?

Eu sei que MD5está quebrado e agora o padrão é sha256, mas quanto ao formato da impressão digital, no entanto, a codificação base64 e as strings hexadecimais são/indicam a mesma coisa. Qual é o benefício em mudar o formato então?

Eu queria dar uma olhada na página de manual do pthread_mutex_trylock.

Digitando man pthread_mutex_trylock, eu tenho No manual entry for pthread_mutex_trylock.

Então eu vi um post sugerindo fazer sudo apt-get install manpages-posix manpages-posix-dev.

Depois disso, vejo uma descrição como:

PTHREAD_MUTEX_LOCK(3POSIX)                               POSIX Programmer's Manual                              PTHREAD_MUTEX_LOCK(3POSIX)

PROLOG
       This manual page is part of the POSIX Programmer's Manual.  The Linux implementation of this interface may differ (consult the cor‐
       responding Linux manual page for details of Linux behavior), or the interface may not be implemented on Linux.

1. Qual é a diferença entre este Manual do Programador POSIX e o Manual do Programador Linux que eu costumo ver?

2. O que significa dizer:

A implementação Linux desta interface pode ser diferente (consulte a página de manual do Linux correspondente para obter detalhes sobre o comportamento do Linux), ou a interface pode não ser implementada no Linux.

Então, onde posso encontrar a página de manual para a implementação do Linux pthread_mutex_trylock ? Posso usar pthread_mutex_trylockno meu sistema? Estou usando o Ubuntu.

Suponha que em mainI registre 2 manipuladores de sinal para SIGUSR1e SIGUR2, digamos sig_ur1e sig_ur2. O que vai acontecer quando o sinal SIGUR2chegar quando sig_ur1estiver funcionando?

sig_ur1executando ----> sinal SIGUR2chega ----> :

1. sig_ur1continua rodando -> sig_ur1termina -> sig_ur2começa a rodar -> sig_ur2termina -> retorna paramain

2. sig_ur2começa a ser executado -> sig_ur2termina -> retorna paramain

3. sig_ur2começa a ser executado -> sig_ur2termina -> sig_ur1restaura (as variáveis ​​mantêm o mesmo valor quando são sig_ur1deixadas) -> sig_ur1termina -> retorna paramain

4. sig_ur2começa a executar -> sig_ur2termina -> sig_ur1reinicia (todas as variáveis ​​são inicializadas novamente) -> sig_ur1termina -> retorna paramain

Qual opção é a correta? Ou nenhum está correto? Não encontrei nenhum artigo/post falando sobre isso, portanto, fornecer qualquer material/links relacionado seria muito apreciado. :)

Estou lendo APUE e o capítulo de Chamadas de Sistema Interrompidas me confunde.

Eu gostaria de escrever minha compreensão com base no livro, por favor, corrija-me.

1. Uma característica dos sistemas UNIX anteriores era que, se um processo captava um sinal enquanto o processo estava bloqueado em uma chamada de sistema "lenta", a chamada de sistema era interrompida. A chamada do sistema retornou um erro e errnofoi definida como EINTR. Isso foi feito sob a suposição de que, como ocorreu um sinal e o processo o capturou, há uma boa chance de que algo tenha acontecido que deva ativar a chamada de sistema bloqueada.

   Então está dizendo que os sistemas UNIX anteriores têm um recurso: se meu programa usa uma chamada de sistema, ela seria interrompida/parada, se a qualquer momento o programa pegasse um sinal. (O manipulador padrão também conta como uma captura?)

   Por exemplo, se eu tiver uma readchamada de sistema, que lê 10 GB de dados, quando estiver lendo, eu envio qualquer um dos sinais (por exemplo kill -SIGUSR1 pid), então readfalharia e retornaria.

2. Para evitar que os aplicativos tenham que lidar com chamadas de sistema interrompidas, o 4.2BSD introduziu o reinício automático de certas chamadas de sistema interrompidas. As chamadas do sistema que foram reiniciadas automaticamente são ioctl, read, readv, write, writev, waite waitpid. Como mencionamos, as cinco primeiras dessas funções são interrompidas por um sinal somente se estiverem operando em um dispositivo lento; waite waitpid são sempre interrompidos quando um sinal é captado. Como isso causou um problema para alguns aplicativos que não queriam que a operação fosse reiniciada se ela fosse interrompida, o 4.3BSD permitiu que o processo desabilitasse esse recurso por sinal.

Portanto, antes que a reinicialização automática fosse introduzida, eu tive que lidar sozinho com a chamada do sistema interrompida. Eu preciso escrever código como:

O problema com chamadas de sistema interrompidas é que agora temos que tratar o retorno de erro explicitamente. A sequência de código típica (assumindo uma operação de leitura e assumindo que queremos reiniciar a leitura mesmo que ela seja interrompida) seria:

again:
    if ((n = read(fd, buf, BUFFSIZE)) < 0) {
        if (errno == EINTR)
        goto again; /* just an interrupted system call */
        /* handle other errors */
}

Mas hoje em dia não preciso escrever esse tipo de código, por causa do mecanismo de reinicialização automática .

Então, se meu entendimento estiver correto, o que / por que devo me preocupar com a chamada do sistema interrompida agora ..? Parece que o sistema/SO lida com isso automaticamente.

Eu sei que telneté um aplicativo de login remoto inseguro comparado ao ssh.

Eu ligo o telnetserviço no meu VPS e consigo logar nele com telnet.

Assim telneté para login remoto , mas como funcionam esses "telnet BBS"? Parece que estou visualizando uma página da Web em vez de logar como usuário do sistema.

Estou lendo o APUE e ele continua se referindo ao loginprograma, mas ainda não sei o que ele está fazendo no meu sistema operacional (Ubuntu).

§8.11:

Normalmente, o ID de usuário real é definido pelo login(1)programa quando efetuamos login e nunca muda. Por loginser um processo de superusuário, ele define todos os três IDs de usuário quando chama setuid

ps aux | grep login:

root       840  0.0  0.0  70732  6120 ?        Ss   15:13   0:00 /lib/systemd/systemd-logind
root      1120  0.0  0.0 419680  9468 ?        Sl   15:13   0:00 gdm-session-worker [pam/gdm-autologin]
tianhe    1151  0.0  0.1 445184 20540 ?        SLl  15:13   0:05 /usr/bin/gnome-keyring-daemon --daemonize --login
tianhe   10838  0.0  0.0  21536  1060 pts/0    S+   21:50   0:00 grep --color=auto login

Então, em resumo, que funcionalidade esse loginprograma oferece para o sistema operacional?

Em que circunstâncias é usado ou executado?

Btw, como é logincomparado a ssh?

Leia da APUE , fique curioso:

O arquivo de senha é usado sempre que um usuário efetua login em um sistema UNIX e sempre que alguém executa um ls -lcomando.

Inverti as declarações em if/else, corrigidas agora.

Estou lendo um trecho de código de Programação Avançada no Ambiente UNIX® :

O programa testa sua entrada padrão para ver se é capaz de buscar.

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main(void){

    if(lseek(STDIN_FILENO,0, SEEK_CUR) == -1)
        printf("cannot seek\n");
    else{
        printf("seek ok\n");
    }
}

Eu compilo e executo (em Ubuntu 18.04.2 LTS), mas não entendo os seguintes comportamentos.

//1
$ ./a.out 
cannot seek

//2
$ ./a.out < /etc/passwd
seek OK

//3
$ cat < /etc/passwd | ./a.out
cannot seek

//4
$ ./a.out < /var/spool/cron/FIFO
cannot seek

Por que //1é cannot seek? Vazio stdindeve ser capaz de procurar eu acho. É porque stdinainda não foi aberto? Porque eu ouvi isso normalmente stdin, stdoute stderrsão abertos quando um programa começa a rodar.

Por que //2está bem e //3não está? Acho que são iguais.

De Programação Avançada no Ambiente UNIX® :

Para _PC_ASYNC_IO, _PC_PRIO_IOe _PC_SYNC_IO, o arquivo referenciado não deve ser um diretório.

Name of option   |   Indicates ...                          |name argument
_POSIX_SYNC_IO   |whether synchronized I/O can be used with |_PC_SYNC_IO
                  the associated file

Então eu suponho que o uso seria
long return_value = pathconf("/a/path/filename",_PC_SYNC_IO).

Parece que é uma maneira de obter a "configuração" de um arquivo específico.

É esta coisa pode ser definida para um arquivo? Como posso configurá-lo?

E o que significa E/S sincronizada para um arquivo? Quer dizer, eu não entendo como a E/S sincronizada pode ser uma configuração de um arquivo? Não deveria ser uma coisa de aspecto de programação em vez de apenas uma "configuração"?