John P's questions

O MBR do disco contém essas informações e, portanto, quando chamo um comando como fdisk, um código de nível de kernel eventualmente é executado e o lê de uma parte específica do MBR? Se sim, qual parte dele? Qual compensação?

Se não estiver no MBR, como esses tipos de comandos podem encontrá-lo? Eles não podem lê-lo desde o início de uma partição, considerando que precisam calcular o endereço inicial dessa partição e precisam do tamanho do setor para fazer isso, não é?

Como os comandos são fdiskimplementados para encontrar essas informações? De onde eles lêem?

Então, quando tento usar o comando Xorg como um usuário normal, este é o erro que me dá:

/usr/lib/xorg/Xorg.wrap: Only console users are allowed to run the X server

mas eu não entendo, quais são os "usuários do console"? e quando mudo para root me dá outro erro:

_XSERVTransSocketUNIXCreateListener: ...SocketCreateListener() failed
_XSERVTransMakeAllCOTSServerListeners: server already running
(EE) 
Fatal server error:
(EE) Cannot establish any listening sockets - Make sure an X server isn't already running(EE) 
(EE) 
Please consult the The X.Org Foundation support 
     at http://wiki.x.org
 for help. 
(EE) Please also check the log file at "/var/log/Xorg.0.log" for additional information.
(EE) 
(EE) Server terminated with error (1). Closing log file.

Então, o que está acontecendo e qual é a razão para cada um desses erros?

UPDATE: e a saída do comando netstat -ln | grep -E '[.]X|:6[0-9][0-9][0-9]é:

unix  2      [ ACC ]     STREAM     LISTENING     18044    @/tmp/.X11-unix/X0
unix  2      [ ACC ]     STREAM     LISTENING     47610    @/tmp/.X11-unix/X1
unix  2      [ ACC ]     STREAM     LISTENING     18045    /tmp/.X11-unix/X0
unix  2      [ ACC ]     STREAM     LISTENING     47611    /tmp/.X11-unix/X1

Então eu estava lendo esta pergunta:

https://stackoverflow.com/questions/1762418/what-resources-are-shared-between-threads

e com base na resposta, "threads compartilham todos os segmentos, exceto a pilha, mas um thread ainda pode acessar a pilha de outro thread"?

mas ainda tenho três perguntas:

1. todas as threads de um processo funcionam no mesmo espaço de memória virtual?

2. quando dizemos que as threads ainda podem acessar a pilha de outras threads, isso significa, por exemplo, que nossa pilha começa de 0x00 a 0xff, então uma thread pode funcionar de 0x00 a 0x0f e a outra funciona de 0x10 a 0xff? ou ..?

3. a pilha é a única parte da memória virtual que é exclusiva por thread no linux?

Este é o resultado de olhar para a memória virtual de um processo em gdb; Tenho algumas dúvidas sobre isso:

1. Por que algumas partes da memória virtual são repetidas? Por exemplo, nosso programa (stack6) e biblioteca libc são repetidos 4 vezes; se eles os dividiram em partes diferentes, então por quê? Por que não apenas colocá-los todos juntos?

2. O caminho superior (/opt/pro...) é a seção de instruções (seção de texto) da nossa memória virtual e contém apenas as instruções?

3. Por que os tamanhos das 4 libc's são diferentes? Qual é o problema com o deslocamento, se já temos o tamanho e o endereço inicial, para que serve o deslocamento?

4. Onde estão as seções de dados, bss, kernel e heap e por que algumas partes da imagem acima não têm informações sobre elas? Existe alguma opção melhor no gdb que realmente mostre todas as partes?

5. Existe algum programa melhor que o gdb que mostre muito melhor a parte da memória virtual do nosso processo? Eu só quero ter um bom visual de uma memória virtual real, qual programa de depuração fornece o melhor resultado.

As seções que mencionei:

Esta é uma pergunta de acompanhamento da minha pergunta anterior .

Com base na resposta, uma chamada de sistema é um exemplo de quando pulamos para a parte do kernel da memória virtual do nosso processo.

1. Quais são outros exemplos de um processo normal (não kernel) usando essa parte da memória virtual além das chamadas do sistema? como existe alguma chamada de função que salta diretamente para esta parte do kernel ou ..?

2. Quando pulamos para esta seção da memória, o processador define automaticamente o bit do modo kernel para 1 para que nosso processo acesse essa parte ou não há necessidade de definir esse bit?

3. Toda a execução dentro desta parte do kernel acontece sem a necessidade de mudança de contexto para um processo do kernel?

(Eu não queria fazer essas perguntas de acompanhamento nos comentários, então abri outro tópico.)

Então eu sempre pensei que o MMU é parte do kernel unix que traduz endereços para endereços físicos, mas na página wiki do MMU diz que é um hardware de computador que geralmente tem sua própria memória, mas essa página não fala muito sobre sistemas operacionais Unix/Linux

Então estou confuso, toda a tradução acontece no hardware e o kernel não faz nenhuma tradução? e basicamente o sistema operacional não sabe nada sobre o endereço físico real?

Estou perguntando sobre sistemas operacionais baseados em Unix, mas se você conhece outros sistemas operacionais, bem como o Windows ou se é uma coisa geral em computadores modernos, me avise, obrigado.

Então o cara desse vídeo:

https://www.youtube.com/watch?v=1S0aBV-Waeo

estourou a pilha, adulterou o endereço de retorno, apontou-o na pilha e copiou o código executável na pilha com um deslizamento NOP

mas eu pensei que todos os sistemas linux modernos, incluindo os debian, têm uma defesa contra isso usando um tipo de bit NX (não executável) na tabela de páginas e usando essas instruções de parada como essa para trabalhar na pilha? Ou eu estou esquecendo de alguma coisa?

Encontrei uma pergunta semelhante, mas ainda não responde às minhas perguntas Os espaços de endereço virtual de todos os processos têm o mesmo conteúdo em suas partes "Kernel"?

1. Primeiro, considerando que os processos do usuário não têm acesso a essa parte e acho que se eles tentarem acessá-la, isso levaria a um erro, então por que incluir essa parte no espaço virtual do processo do usuário? Vocês podem me dar um cenário da vida real dessa parte sendo essencial e útil?

2. Além disso, mais uma pergunta é que eu sempre pensei que a parte do kernel da memória é dinâmica, o que significa que pode crescer, por exemplo, quando usamos bibliotecas dinâmicas em nossos programas, então é verdade? Em caso afirmativo, como o sistema operacional pode determinar o tamanho do kernel no espaço virtual de nossos processos?

3. E quando nosso kernel na memória física cresce ou muda, o mesmo efeito acontece na parte do kernel da memória virtual para todos os processos? O mapeamento desse kernel virtual para o kernel real é um mapeamento de um para um?