Neste artigo, veremos o processo de download sistema operacional Linux. Vamos dar uma olhada mais de perto nos estágios pelos quais o computador e o sistema operacional passam durante o processo de inicialização. O artigo é direcionado principalmente a novos usuários que estão apenas começando a se familiarizar com o Linux. Compreender como funciona o processo de inicialização do Linux é importante para solucionar possíveis problemas com o processo de inicialização, caso surjam.

Imediatamente após iniciar o computador, você será solicitado a pressionar uma tecla especial para iniciar Menu BIOS, se isso não for feito, o sistema continuará a inicializar. A seguir veremos o que acontece em cada estágio da inicialização do Linux.

BIOS (sistema básico de entrada e saída) - este é um software pré-integrado no chipset placa-mãe. O BIOS inicializa o computador e verifica todo o seu hardware, verificando a presença e funcionalidade de dispositivos como disco rígido, CD ROM, RAM. Neste ponto, o processo de inicialização do sistema operacional Linux começa.

O BIOS então procura o MBR (Master Boot Record), que geralmente está localizado no primeiro setor disco rígido e inicia o gerenciador de inicialização de primeiro grau gravado lá, por exemplo Grub ou Lilo. O BIOS prepara o carregador de boot MBR, carrega todos os dados na RAM e os executa.

MBR ocupa os primeiros 512 bytes do disco rígido. Contém informações sobre o carregador do sistema operacional, os carregadores da maioria dos sistemas operacionais estão escritos lá, por exemplo: Linux, Unix, WIndows.

Embora o MBR ocupe espaço em disco, esta área não pertence a nenhuma partição. O endereço MBR normalmente é trilha 0, cilindro 0. Este espaço é reservado para programas de inicialização. Inclui não apenas o programa bootloader executável, mas também a tabela de partição no disco.

O BIOS verifica o MBR, encontra o carregador de inicialização de primeiro estágio, depois verifica a tabela de partições e encontra o carregador de inicialização de segundo estágio na partição marcada como inicializável.

Carregador

Se você dividir o processo de inicialização do Linux em estágios, este será o segundo estágio. A primeira parte do bootloader, localizada no MBR, carrega-se na RAM.

Em seguida, os arquivos da segunda parte do bootloader são carregados do bootloader seção difícil disco. Por exemplo, Grub ou Lilo. Essa divisão é necessária porque todo o código do bootloader não cabe em 512 bytes.

Depois que o carregador de inicialização Grub é iniciado, ele lê seu arquivo de configuração e solicita ao usuário que selecione o sistema operacional para inicializar.

O arquivo de configuração de cada item contém um kernel que precisa ser carregado. Normalmente os kernels estão localizados na pasta /boot. O Grub então carrega a versão desejada do kernel vmlinuz

Preparando o Kernel

O carregamento começa aqui Núcleos Linux. Grub reserva espaço em BATER para a imagem Initrd e carrega essa imagem lá. Esta imagem contém o sistema de arquivos inicial, módulos e utilitários necessários para carregamento antecipado, por exemplo, para trabalhar com Btrfs ou uma partição criptografada. O carregador de boot prepara o kernel para inicialização e carrega os módulos necessários para que o processo de inicialização possa começar.

No Linux, a maioria dos drivers proprietários são empacotados como módulos e hospedados em disco de inicialização initrd.img. Desta forma, quando o kernel inicializar, todos os módulos necessários já estarão disponíveis no initrd.

Depois que o kernel carregou tudo o que precisa e concluiu a inicialização, o kernel Linux é considerado completo e o processo de inicialização do sistema, o chamado processo init, é iniciado e pode ser configurado manualmente, por exemplo, com a opção init kernel; .

Inicialização do kernel

A inicialização do kernel inclui as seguintes etapas:

• Inicializando componentes do processador, como o MMU
• Inicialização do agendador (PID 0)
• Montagem sistema de arquivos em modo de leitura e gravação
• Bifurque o processo de inicialização (PID 1)

Durante o processo de inicialização, o kernel executa as seguintes tarefas:

• Iniciando o sistema principal e o gerenciador geral de recursos (RAM, processador, disco rígido)
• Iniciando o processo de inicialização (/sbin/init)

Sistema de inicialização

É neste ponto que o processo de inicialização do Linux está mais sujeito a erros. Depois que o kernel transfere o controle para o sistema de inicialização, o sistema começa a se preparar para operação e iniciar todos os serviços necessários - registro, mensagens do sistema, configuração de rede, preparação de sistemas de arquivos de rede, configuração de som, montagem de sistemas de arquivos locais e outros componentes do sistema. Sobre no momento Na maioria dos casos, um dos dois sistemas de inicialização mais populares é usado - SysVinit ou Systemd.

O processo de download é um pouco diferente em cada caso, mas a essência é a mesma.

O SysVinit primeiro executa o programa /sbin/init e depois lê o arquivo de opções /etc/inittab para determinar o nível de execução padrão desejado. Estes são os níveis de inicialização do Linux:

• 0 - desligamento
• 1 - Modo de usuário único
• 2 – Modo multiplayer sem rede
• 3 - Modo completo
• 4 – Não utilizado
• 5 - Inicie o X11

Os níveis de inicialização do Linux também podem ser alterados manualmente usando o comando telinit. O padrão geralmente é o nível 5.

Em seguida, o script /etc/rc.d/rc.sysinit é executado, bem como todos os scripts da pasta /etc/rc.d/rcx, onde x é o número do nível de execução. Por exemplo, se inicializarmos com o nível de execução 5, todos os scripts da pasta /etc/rc.d/rc5.d serão executados.

Os nomes dos scripts de inicialização começam com a letra S, e os scripts de encerramento começam com a letra K. Depois de observar essa estrutura, você já entendeu como funciona os serviços de inicialização automática no Linux? Agora você pode adicionar o script à inicialização manualmente, simplesmente criando um link simbólico na pasta desejada.

Após concluir todas essas etapas, o sistema só precisa iniciar todos os consoles virtuais TTY e um gerenciador de login, como XDM ou SDDM.

No Systemd, o processo de carregamento é um pouco diferente aqui, ao contrário da versão anterior, não são usados ​​​​scripts, mas arquivos de configuração especiais - unidades. Isso resolve muitos problemas, como portabilidade, e também adiciona novos recursos, como dependências e carregamento paralelo.

Mas a essência do processo de download é a mesma, os mesmos serviços são lançados. Em vez de níveis de lançamento, são usadas unidades especiais - .target. O nome da unidade contém o número do nível de execução e a palavra nível de execução. Por exemplo: runlevel0.target - desabilitar, etc. Essas unidades puxam consigo, em dependências, todos os serviços necessários para operação normal sistemas.

Na verdade, existem duas sequências de eventos necessárias para inicializar um computador Linux e torná-lo utilizável: inicialização e inicialização. A sequência de inicialização começa quando o computador é ligado e termina quando o kernel é inicializado e o systemd é iniciado. O processo de inicialização completa então a tarefa de colocar o computador Linux em funcionamento. condição de trabalho.

No geral, o processo de download e execução do Linux é bastante fácil de entender. Consiste nas etapas a seguir, que serão descritas com mais detalhes nas seções a seguir.

POSTAGEM DO BIOS;
- carregador de inicialização (GRUB2);
- inicialização do kernel;
- lançar o systemd, o componente pai de todos os processos.

Observe que este artigo cobre GRUB2 e systemd, pois eles são o carregador de inicialização e o sistema de inicialização atuais para a maioria das principais distribuições. Outras variantes de tais programas foram usadas anteriormente e ainda são usadas em algumas distribuições.

Processo de inicialização

O processo de download pode ser iniciado de várias maneiras. Primeiro, se a energia estiver desligada, ligá-la iniciará o processo de inicialização. Se o computador já estiver funcionando, usuário local incluindo raiz ou usuário normal, pode iniciar programaticamente a sequência de inicialização usando GUI ou linha de comando para reiniciar o computador. O computador será primeiro desligado e depois reiniciado.

POSTAGEM DA BIOS

A primeira etapa do processo de inicialização do Linux, na verdade, não tem nada a ver com o Linux. Esta é a parte de hardware do processo de inicialização e é a mesma para qualquer sistema operacional. Quando a energia é fornecida ao computador, ele inicia o procedimento POST (Power On). Autoteste), que faz parte do BIOS (Basic I/O System).

Quando a IBM desenvolveu o primeiro computador, em 1981, o BIOS foi desenvolvido para inicializar componentes de hardware. O POST faz parte do BIOS, cuja função é garantir o correto funcionamento do hardware. Se o POST não funcionar corretamente, o computador poderá não estar em uso e o processo de inicialização não continuará.

BIOS POST verifica a funcionalidade básica hardware e, em seguida, emite a interrupção do BIOS, INT 13H, que localiza setores de inicialização em todos os dispositivos de inicialização conectados. O primeiro setor de inicialização com um registro de inicialização válido encontrado é carregado na RAM e, em seguida, o controle é transferido para o código carregado de setor de inicialização.

O setor de boot é na verdade o primeiro estágio do bootloader. Existem três gerenciadores de boot usados ​​pela maioria das distribuições Linux: GRUB, GRUB2 e LILO. GRUB2 é o mais moderno e é usado com muito mais frequência hoje do que as versões mais antigas.

GRUB2

GRUB2 significa "GRAND Unified Bootloader Versão 2" e é o principal carregador de boot para a maioria das distribuições Linux atualmente. GRUB2 é um programa que torna o computador inteligente o suficiente para encontrar o kernel do sistema operacional e carregá-lo na memória. Como o GRUB é mais fácil de escrever e dizer do que o GRUB2, usarei o termo GRUB ao longo deste documento, mas me referirei ao GRUB2, salvo indicação em contrário.

O GRUB foi projetado para ser compatível com a especificação de inicialização múltipla, que permite ao GRUB inicializar vários Versões Linux e outros sistemas operacionais gratuitos; ele também pode inicializar o registro de inicialização de sistemas operacionais proprietários.

GRUB também permite que o usuário escolha inicializar um dos vários kernels diferentes para qualquer distribuição Linux. Isso torna possível inicializar a partir de versão anterior kernel, se a versão atualizada não funcionar corretamente ou for incompatível com parte programas. O GRUB pode ser configurado usando o arquivo /boot/grub/grub.conf.

GRUB1 é agora considerado obsoleto e foi substituído na maioria das distribuições modernas pelo GRUB2, que é uma reescrita do GRUB1. As distribuições baseadas em Red Hat foram atualizadas para GRUB2, começando com Fedora 15 e CentOS/RHEL 7. GRUB2 fornece a mesma funcionalidade que GRUB1, mas GRUB2 também fornece mais flexibilidade na fase de pré-inicialização. GRUB2 é configurado usando o arquivo /boot/grub2/grub.cfg.

A principal função do GRUB é carregar o kernel do Linux na memória e executá-lo. Ambas as versões do GRUB funcionam basicamente da mesma forma e o processo envolve as mesmas três etapas, mas usarei o GRUB2. Configurar o GRUB ou GRUB2 e usar comandos do GRUB2 está além do escopo deste artigo.

Embora o GRUB2 não use oficialmente a notação de estágio para os três estágios de inicialização do GRUB2, é conveniente referir-se a eles dessa forma, que é o que farei neste artigo.

Estágio 1

Conforme mencionado na seção POST BIOS, no final do POST o BIOS examina as unidades conectadas em busca entrada de inicialização, geralmente localizado no registro mestre de inicialização (MBR), carrega o primeiro encontrado na RAM e então começa a executar o registro de inicialização. O código de bootstrap, ou seja, o estágio 1 do GRUB2, é muito pequeno, pois deve caber no primeiro setor de 512 bytes do disco rígido junto com a tabela de partição. A quantidade total de espaço alocado para o código de inicialização real no MBR compartilhado clássico é de 446 bytes. O arquivo de 446 bytes para o Estágio 1 é chamado boot.img e não contém uma tabela de partição, que é adicionada separadamente ao registro de inicialização.

Como o registro de inicialização precisa ser muito pequeno, ele não é muito inteligente e não entende a estrutura do sistema de arquivos. Portanto, o único propósito do estágio 1 é encontrar e carregar o estágio 1.5. Para fazer isso, o estágio 1.5 do GRUB deve estar localizado no espaço entre o próprio registro de inicialização e a primeira partição do disco. Após o estágio 1.5 do GRUB ser carregado na RAM, o estágio 1 transfere o controle para o estágio 1.5.

Estágio 1.5

Conforme mencionado acima, o estágio 1.5 do GRUB deve estar localizado no espaço entre o próprio registro de inicialização e a primeira partição do disco. Por razões técnicas, este espaço não foi utilizado historicamente. A primeira partição do disco rígido começa no setor 63 com o MBR no setor 0, o que deixa setores de 62.512 bytes – 31.744 bytes – que armazenam o arquivo core.img, que é o estágio 1.5 do GRUB. O arquivo core.img tem 25389 bytes de tamanho, portanto há muito espaço entre o MBR e a primeira partição do disco espaço livre para armazená-lo.

Devido à maior quantidade de código que pode estar envolvido no estágio 1.5, ele pode conter vários drivers para sistemas de arquivos comuns, como EXT e outros sistemas de arquivos Linux, FAT e NTFS. GRUB2 core.img é muito mais complexo e inteligente em comparação com o antigo estágio 1.5 do GRUB1. Isso significa que o estágio 2 do GRUB2 pode estar localizado em um sistema de arquivos EXT padrão, mas não pode estar localizado em um volume lógico. Assim, o local padrão para arquivos do estágio 2 é o sistema de arquivos /boot, ou seja, /boot/grub2.

Observe que o diretório /boot deve estar em um sistema de arquivos suportado pelo GRUB. Nem todos os sistemas de arquivos são adequados para isso. A função do estágio 1.5 é carregar os drivers do sistema de arquivos necessários para procurar arquivos do estágio 2 no sistema de arquivos /boot e carregar os drivers necessários.

Estágio 2

Todos os arquivos do estágio 2 do GRUB estão localizados no diretório /boot/grub2 e em vários de seus subdiretórios. GRUB2 não possui um arquivo de imagem como as etapas 1 e 2. Em vez disso, ele consiste principalmente em módulos do kernel que são carregados conforme necessário no diretório /boot/grub2/i386-pc.

A função do estágio 2 do GRUB2 é encontrar e carregar o kernel Linux na RAM e transferir o controle do computador para o kernel. O kernel e seus arquivos associados estão localizados no diretório /boot. Os arquivos do kernel podem ser identificados porque todos os seus nomes começam com vmlinuz. Você pode visualizar o conteúdo do diretório /boot para ver os kernels instalados em seu sistema.

GRUB2, assim como GRUB1, suporta inicialização a partir de um dos kernels do Linux. O gerenciador de pacotes da Red Hat, DNF, suporta o armazenamento de múltiplas versões do kernel, portanto, se houver um problema com o próprio kernel nova versão, você pode baixar mais versão antiga grãos. Por padrão, o GRUB fornece um menu de pré-inicialização de kernels instalados, incluindo uma opção de inicialização segura e, se configurada, uma opção de recuperação.

Estágio 2 GRUB2 carrega o kernel selecionado na memória e transfere o controle do computador para o kernel do sistema.

Essencial

Todos os kernels são armazenados em um formato de arquivo autoextraível para economizar espaço. Os kernels estão localizados no diretório /boot junto com a imagem original do disco RAM e os mapas de dispositivos do disco rígido.

Uma vez que o kernel selecionado é carregado na memória e começa a ser executado, ele deve primeiro desarquivar-se antes de poder executar qualquer trabalho útil. Depois que o kernel é ejetado, ele carrega o systemd, que substituiu o antigo programa init do SysV, e muda o controle para ele.

Este é o fim do processo de download. Neste ponto, o kernel do Linux e o systemd estão em execução, mas não conseguem executar nenhuma tarefa produtiva para o usuário final porque nada está em execução.

Processo de inicialização

O processo de inicialização segue o processo de inicialização e coloca seu computador Linux em um estado de funcionamento onde pode ser usado para trabalho produtivo.

sistema

systemd é a mãe de todos os processos e é responsável por colocar o sistema Linux em um estado onde possa ser executado. Algumas de suas características que são muito mais amplas do que programa antigo init são projetados para gerenciar vários aspectos de um sistema Linux em execução, incluindo a criação de sistemas de arquivos e a inicialização e gerenciamento de serviços de sistema necessários para o dia-a-dia. Linux funciona. Qualquer uma das tarefas do systemd não relacionadas à sequência de inicialização está além do escopo deste artigo.

Primeiro, o systemd monta os sistemas de arquivos especificados em /etc/fstab, incluindo quaisquer arquivos ou partições de troca. Neste ponto, ela pode acessar os arquivos de configuração localizados em /etc, inclusive os seus próprios. Ele usa seu arquivo de configuração, /etc/systemd/system/default.target, para definir o estado (destino) no qual deve inicializar o sistema. O arquivo default.target é apenas um link simbólico para o arquivo de destino real. Para estação de trabalho ou computadores desktop normalmente será graphical.target, que é equivalente ao nível de execução 5 no antigo sistema de inicialização SystemV. Para o servidor padrão, provavelmente será multi-user.target, que é semelhante ao nível de execução 3 no SystemV. Emergency.target é semelhante ao modo single-player.

Observe que os alvos e os serviços são unidades do sistema.

A Tabela 1 abaixo fornece uma comparação de destinos do systemd com níveis de execução mais antigos do SystemV. Os aliases de destino são fornecidos pelo systemd para compatibilidade com versões anteriores. Os aliases de destino permitem que scripts e muitos administradores de sistema como eu usem comandos SystemV, como init 3, para alterar os níveis de execução. Obviamente, os comandos do SystemV são encaminhados ao systemd para interpretação e execução.

Tabela 1: Comparação de níveis de execução do SystemV com destinos do systemd.

Cada destino possui um conjunto de dependências descritas no arquivo de configuração. systemd executa as dependências necessárias. Essas dependências são serviços necessários para executar um host Linux em um determinado nível de funcionalidade. Quando todas as dependências listadas nos arquivos de configuração de destino forem baixadas e executadas, o sistema será executado nesse nível de destino.

O systemd também analisa os diretórios de inicialização legados do SystemV para ver se os arquivos de inicialização estão lá. Se estiverem presentes, o systemd os utiliza como arquivos de configuração para iniciar os serviços descritos nesses arquivos. Desatualizado serviço de redeé bom exemplo um daqueles casos em que o Fedora ainda usa arquivos de inicialização do SystemV.

A Figura 1 abaixo foi copiada diretamente da página de manual de inicialização. Ele mostra sequência geral eventos durante a inicialização do systemd e os requisitos básicos para seu pedido garantir uma inicialização bem-sucedida.

Os alvos sysinit.target e basic.target podem ser considerados como pontos de controle durante o processo de inicialização. Embora um dos objetivos de design do systemd fosse permitir que os serviços do sistema fossem executados simultaneamente, ainda existem determinados serviços e alvos funcionais que devem ser iniciados antes que outros serviços e alvos possam ser iniciados. Esses pontos de verificação não podem ser ultrapassados ​​até que todos os serviços e objetivos necessários tenham sido concluídos.

Assim, sysinit.target é alcançado quando todos os componentes dos quais depende foram concluídos. Montar sistemas de arquivos, configurar arquivos de paginação, iniciar o udev, instalar o gerador de números aleatórios, iniciar serviços de baixo nível e configurar serviços criptográficos se um ou mais sistemas de arquivos estiverem criptografados devem ser concluídos, mas dentro do sysinit.target essas tarefas podem ser executadas em paralelo.

Sysinit.target inicia todos os serviços e componentes de baixo nível necessários para a funcionalidade mínima do sistema e que serão necessários para migrar para basic.target.

Local-fs-pre.target | resgate.target v (várias montagens e (vários swap (vários serviços cryptsetup fsck...) dispositivos...) dispositivos...) (vários serviços de baixo nível (vários | | | de baixo nível: udevd, API VFS montagens: v v v tmpfiles , mqueue aleatório, configfs, local-fs.target swap.target cryptsetup.target seed, sysctl, ...) debugfs, ...) | | | | | emergência.alvo _________________|_________________ | ___________________|____________________/ \|/ v sysinit.target | multiusuário.target ____________________________________/|\________________________________________ / | | | \ | | | | | gráfico.target

v v | v v (vários (vários | (vários temporizadores de serviço de resgate...) caminhos...) | soquetes...) |

Após a execução do sysinit.target, o systemd executará o basic.target, iniciando todos os componentes necessários para executá-lo. basic.target fornece algumas funcionalidades adicionais executando componentes que são necessários para o próximo destino. Isso inclui a configuração de aspectos como caminhos para vários diretórios executáveis, soquetes de comunicação e temporizadores.

Finalmente, os destinos no nível do usuário, multi-user.target ou graphical.target, podem ser inicializados. Observe que o modo multijogador deve ser alcançado antes que as dependências gráficas sejam atendidas.

Os alvos sublinhados na Figura 1 são alvos de lançamento comuns. Quando um desses objetivos for alcançado, o lançamento estará completo. Se o padrão for multi-user.target, você deverá ver o login em modo texto no console. Se o padrão for graphical.target, você deverá ver uma tela de login gráfica; A tela de login específica que você verá dependerá do gerenciador de sessão padrão que você está usando.

Problemas

Recentemente tive que alterar o kernel padrão em uma máquina Linux rodando GRUB2. Descobri que alguns dos comandos não pareciam funcionar conforme o esperado ou talvez eu os estivesse usando incorretamente. Ainda não tenho certeza dos motivos, preciso fazer mais alguns testes.

O comando grub2-set-default não configurou o índice do kernel padrão corretamente em /etc/default/grub, então o kernel alternativo que eu queria não carregava. Em seguida, alterei manualmente /etc/default/grub GRUB_DEFAULT=saved para GRUB_DEFAULT=2, onde 2 é o índice do kernel instalado que eu queria inicializar. Em seguida, executei o comando grub2-mkconfig> /boot/grub2/grub.cfg para criar um novo arquivo de configuração do grub. Esta solução alternativa funcionou como eu esperava e inicializou um kernel alternativo.

Conclusão

GRUB2 e systemd são componentes-chave durante as fases de inicialização da maioria das distribuições Linux modernas. Esses dois componentes trabalham juntos para primeiro carregar o kernel e depois executar todos os serviços do sistema necessários para criar um sistema Linux totalmente funcional.

Embora eu ache o GRUB2 e o systemd mais complexos que seus antecessores, eles são bastante fáceis de aprender e gerenciar. As páginas de manual contêm muitas informações sobre o systemd e o freedesktop.org possui conjunto completo Páginas de manual do systemd disponíveis online.

Vamos dividir o processo de inicialização do sistema operacional Linux em nove etapas que se aplicam a quase todas as configurações do sistema operacional Linux:

1. A primeira etapa do carregamento é a leitura do BOIS do computador ou outro hardware e software do MBR do disco rígido ou outro dispositivo de inicialização(como um CD, disquete ou dispositivo de inicialização de rede, etc.).
2. O bootloader começa a funcionar. Linux na arquitetura x86 geralmente usa LILO ou GRUB. Alguns sistemas mais antigos podem usar loadlin para inicializar através de uma partição DOS secundária. EM Sistemas de energia PC® pode ser BootX ou yaboot. De forma alguma, carregadoré um programa simples que, no entanto, sabe onde procurar o kernel Linux, pode escolher qual inicializar a partir de várias versões do kernel ou até mesmo selecionar um sistema operacional diferente na mesma máquina.
3. O sistema de arquivos raiz está montado. Em alguns casos, um sistema de arquivos raiz inicial é montado temporariamente a partir do conteúdo de, por exemplo, um disco RAM inicializado pelo carregador de inicialização para permitir o carregamento de drivers e módulos especiais que podem ser necessários para executar o sistema de arquivos raiz real.

   Agora que temos um sistema de arquivos raiz, podemos iniciar a inicialização propriamente dita.

4. O processo init é iniciado, o ancestral de todos os outros processos no sistema operacional Linux.
5. O conteúdo do arquivo /etc/inittab é lido para determinar o progresso do download. É especialmente importante o que está escrito no arquivo /etc/inittab na linha que determina o nível de inicialização do sistema (e, portanto, os estágios de inicialização subsequentes).

   Na verdade, tudo o que acontece depois deste ponto é completamente determinado pelo conteúdo do arquivo /etc/inittab. Na verdade, os scripts e outras ferramentas que funcionam estão sujeitos às configurações apropriadas, mas em princípio você poderia alterar completamente o /etc/inittab para controlar como as várias ferramentas funcionam como desejar.

   Uma das configurações no arquivo /etc/inittab é especialmente importante. Esta é uma linha semelhante a:

   id:5:initdefault:

   Geralmente está localizado próximo ao início do arquivo e define o nível de execução do sistema. O nível de execução determina quais ações serão executadas nas instruções restantes no arquivo /etc/inittab.

   O que acontece quando o script /etc/inittab é executado? E principalmente, quais arquivos e diretórios participam do processo?

6. Inicialização independente de nível de execução. Há diversas ações que serão executadas independentemente do nível de execução definido. Essas etapas são indicadas em /etc/inittab por linhas semelhantes a:

   # Inicialização do sistema.
   si::sysinit:/etc/rc.d/rc.sysinit

   Em alguns sistemas Linux (principalmente sistemas baseados em Debian), é provável que você veja linhas mais parecidas com as seguintes:

   si::sysinit:/etc/init.d/rcS

   Neste último caso, o arquivo /etc/init.d/rcS é simplesmente um script que executa os scripts /etc/rcS.d/??* um por um. Por outro lado, se seu sistema utiliza /etc/rc.d/rc.sysinit, um script longo contido neste arquivo é suficiente para realizar a inicialização.

7. Inicialização dependente do nível de execução. Na verdade, você pode definir quantas atividades de nível de execução desejar e cada atividade pode ser atribuída a um ou mais níveis de execução. Normalmente /etc/inittab conterá linhas como:

   l0:0:espera:/etc/rc.d/rc 0
   # ...
   l5:5:espera:/etc/rc.d/rc 5
   l6:6:espera:/etc/rc.d/rc 6

   Por sua vez, o script /etc/rc.d/rc gerenciará todos os arquivos nomeados /etc/rc$1.d/??*. No exemplo a seguir, você pode ver que em um determinado sistema começando no nível de execução 5, o seguinte será executado (em ordem):

   /etc/rc5.d/K15postgresql
   /etc/rc5.d/S01switchprofile
   /etc/rc5.d/S05harddrake
   ...
   /etc/rc5.d/S55sshd
   ...
   /etc/rc5.d/S99linuxconf
   /etc/rc5.d/S99local

   Arquivos que começam com "K" ou "k" são matando scripts, completam processos ou organizam suas ações (consequências). Arquivos que começam com "S" ou "s" são scripts de inicialização, eles iniciam novos processos ou preparam o sistema para ser executado nesse nível de execução. A maioria deles são scripts de shell e a maioria deles serão links (geralmente para /etc/init.d/).

   Enquanto Sistema Linux inicia em um determinado nível de execução, você deseja efetuar login no sistema como usuário. Para garantir que a autorização seja bem-sucedida, o programa getty é usado. Muitos tipos de programas baseados em getty são usados ​​pelos criadores de distribuições como agetty, mgetty e mingetty. Mas todos eles fazem a mesma coisa.

8. Faça login no convite. O familiar /etc/inittab normalmente executa o getty em uma ou mais telas virtuais e em vários níveis de execução. Os níveis são definidos em linhas como:

   # Executa gettys em níveis de execução padrão
   1:2345:respawn:/sbin/mingetty tty1
   2:2345:respawn:/sbin/mingetty tty2
   3:2345:respawn:/sbin/mingetty tty3
   4:2345:respawn:/sbin/mingetty tty4
   5:2345:respawn:/sbin/mingetty tty5
   6:2345:respawn:/sbin/mingetty tty6

   O número no início indica em qual terminal virtual o programa getty será executado; os próximos números são os níveis de execução em que isso acontecerá (por exemplo, executando o mingetty em cada um dos níveis 2, 3, 4 e 5).

As etapas a seguir iniciam o início de serviços adicionais, a entrada no ambiente gráfico, a restauração das configurações da interface do usuário ou outros detalhes mais personalizados que estão além do escopo deste tutorial.

O conceito de nível de execução é pelo menos um tanto arbitrário, não está escrito no kernel do Linux; Os níveis de execução reais são mapeados para um conjunto de números para que você possa definir (ou alterar um nível de execução padrão existente) selecionando um número de 0 a 6. Por convenção, o seguinte significado é atribuído a cada número de nível de execução:

Esta convenção pode ser usada na distribuição Mandrake Linux, mas a maioria das distribuições usa a mesma convenção. Pode acontecer que distribuições de texto ou incorporadas não usem alguns dos níveis de execução, mas ainda assim reservarão os mesmos números.

Você viu muitas linhas /etc/inittab em exemplos, mas o que exatamente elas significam? Cada linha tem o formato:

id:níveis de execução:ação:processo

O campo id é uma abreviatura curta para uma linha de configuração. (1 - 4 letras em versões mais recentes iniciar; 1 - 2 nos mais velhos). O campo runlevels já foi discutido. O próximo campo de ação indica a ação realizada pela linha. Algumas ações podem ser "especiais", como:

ca::ctrlaltdel:/sbin/shutdown -t3 -r agora

Esta linha define a ação para a sequência de teclas Ctrl-Alt-Delete (independentemente do nível de execução). Mas a maioria das ações simplesmente inicia os processos correspondentes. Uma lista parcial de ações inclui:

• respawn: O processo será reiniciado sempre que sair (como é o caso do getty).
• wait: O processo será iniciado uma vez quando o nível de execução especificado for inserido e o init aguardará sua conclusão.
• uma vez: o processo será executado uma vez quando o nível de execução especificado for inserido.
• boot: O processo será executado durante a inicialização do sistema (mas após o sysinit). O nível de lançamento não importa.

Configurando o processo de inicialização e inicialização do sistema

Há alguns anos, um programa chamado LILO era usado principalmente para inicializar Linux em sistemas x86. O nome LILO é a abreviação de “LInux LOader”. Hoje em dia, um programa mais popular é chamado GRUB (GRand Unified Bootloader). Em sistemas não x86, diferentes carregadores de inicialização são usados, mas todos são configurados de maneira semelhante ao LILO e GRUB.

Embora existam diferenças em sua sintaxe de configuração, tanto o LILO quanto o GRUB executam basicamente a mesma tarefa. Essencialmente, cada um deles oferece uma escolha de sistema operacional (incluindo possivelmente vários kernels Linux) e carrega o kernel do sistema operacional selecionado na memória do computador. Ambos os programas permitem que você passe argumentos para o kernel Linux ao longo do caminho e ambos podem ser configurados para inicializar sistemas operacionais não Linux na mesma máquina.

O LILO ou o GRUB (ou algum outro carregador de boot) reside no MBR (Master Boot Record) do disco rígido principal, que é inicializado automaticamente pelo BIOS do sistema. LILO tem restrições no carregamento de matérias-primas especiais setor difícil disco. O gerenciador de inicialização GRUB é mais sofisticado e reconhece diferentes sistemas de arquivos, como ext2/3, ReiserFS, VFAT ou UFS. Isso significa que o GRUB não precisa reescrever o MBR toda vez que o arquivo de configuração for alterado (como o LILO faz).

O bootloader LILO é configurado usando o conteúdo do arquivo /etc/lilo.conf. Para uma visão mais detalhada das opções de configuração do LILO, leia as páginas man do lilo.conf. A natureza geral do comportamento é determinada por vários parâmetros iniciais. Por exemplo, você provavelmente verá boot=/dev/hda ou algo semelhante. Este comando instala o bootloader no MBR do disco rígido principal. Unidade IDE . Você também pode instalar o LILO dentro de uma partição específica, geralmente quando estiver usando um gerenciador de inicialização primário diferente. Por exemplo, boot=/dev/sda3 instala o LILO na terceira partição do primeiro disco SCSI. Outros parâmetros determinam aparência

Lembre-se que depois de fazer correções no arquivo /etc/lilo.conf, você precisa executar o LILO para realmente instalar um novo setor de inicialização que será usado no momento da inicialização. É fácil esquecer de definir novos parâmetros, mas o próprio bootloader não será capaz de ler a nova configuração a menos que os endereços reais do setor (que o LILO reconhece enquanto é executado) sejam anotados.

Se o LILO for usado, as linhas são de particular importância digite imagem= e talvez outro= se houver uma escolha entre Linux e outros sistemas operacionais. Um exemplo /etc/lilo.conf pode conter:

Esta configuração permite que você escolha o kernel 2.7.4, que está em desenvolvimento, ou o kernel estável (doravante declarado para ser usado como disco RAM de inicialização (initrd) durante o processo de inicialização). Você também pode selecionar DOS que está na terceira partição IDE principal disco.

A vantagem inegável do GRUB é que ele não precisa ser reinstalado toda vez que você altera as opções de inicialização. Claro, você ainda precisa instalar o GRUB pela primeira vez, geralmente com um comando como grub-install /dev/hda . Como regra geral, a distribuição faz isso para você durante o processo de instalação, então você nunca poderá fazer isso sozinho.

Tanto o LILO quanto o GRUB permitem que você passe parâmetros especiais para o kernel de sua escolha. Se você estiver usando o LILO, você pode passar opções para o prompt de inicialização anexando-as ao kernel de sua escolha. Por exemplo, para opções de inicialização normais, você poderia inserir:

LILO: linux ether=9.0x300.0xd0000 root=/dev/ha2 vga=791 acpi=on

Esta linha passa parâmetros especiais para o módulo Ethernet, especifica a partição raiz, seleciona o modo de vídeo, etc. É claro que nem tudo isso é conveniente, pois você deve saber exatamente os valores adequados para esses parâmetros e poder inseri-los corretamente.

De particular importância é o parâmetro que altera o nível de inicialização do sistema do carregador de boot. Por exemplo, para fins de recuperação do sistema, você deseja inicializar o sistema no modo de usuário único. Isso é feito da seguinte maneira:

LILO: single experimental

Outra opção especial é o argumento init=, que permite usar programas diferentes do init como processo primário. As opções para o modo de emergência poderiam ser init=/bin/sh , o que permitiria pelo menos que você tivesse linha de comando(shell Linux) se o init estiver completamente fora de serviço.

Com o gerenciador de inicialização GRUB você tem ainda mais flexibilidade. Na verdade, GRUB é um shell de linha de comando e fornece ao usuário funcionalidades básicas do shell. O GRUB torna possível não apenas alterar a configuração básica do carregador de boot, mas até mesmo ler sistemas de arquivos. Para configurar as opções de inicialização, pressione "e" na linha de comando do GRUB e adicione parâmetros (por exemplo, o número do nível de execução ou a palavra-chave "single" como no LILO). Todos os outros argumentos no prompt de inicialização que você pode inserir usando o LILO podem ser usados ​​na linha de comando do GRUB.

Para entender suas opções, você pode abrir o prompt de comando do GRUB. Por exemplo, suponha que você acha que seu arquivo /etc/inittab está mal configurado e deseja investigar antes de inicializar. Você poderia inserir:

grub>cat (hd0,2)/etc/inittab

Isso permitiria que você visualizasse seu arquivo de inicialização antecipadamente, sem iniciar o sistema operacional. Se houvesse um erro, seria possível inicializar no modo de usuário único e corrigi-lo.

Depois de entender as etapas de inicialização do Linux após a inicialização do kernel (em outras palavras, o processo init e tudo o que ele chama), você também entenderá como editá-los. Basicamente, toda configuração é feita editando o arquivo /etc/inittab e vários scripts no diretório /etc/rc?.d/.

Por exemplo, recentemente precisei configurar o BIOS de vídeo em um laptop Linux baseado em Debian usando soluções de terceiros. Se não fosse iniciado antes do início do X11s, meu driver XOrg não configuraria os modos de vídeo corretos. Depois que descobri qual era o problema, a solução foi tão simples quanto criar o script /etc/rcS.d/S56-resolution.sh. Em outras palavras, executei um script adicional sempre que o sistema inicializou.

Observe que me certifiquei de que esse script fosse executado antes de /etc/rcS.d/S70xorg-common devido à simples convenção de que os scripts são executados em ordem alfabética (se eu quisesse que meu script fosse executado mais tarde, eu poderia ter chamado a resolução S98 .sh em vez de /etc/rcS.d/S56-resolution.sh). Talvez eu colocasse esse script apenas no diretório /etc/rc5.d/ para que ele seja executado quando os X11s estiverem em execução, mas posso executar manualmente o startx em um nível de execução diferente.

Todas as configurações durante o processo de inicialização ficam abertas para edição, diretamente no sistema de arquivos; quase tudo pode ser corrigido usando scripts de texto.

Recuperação do sistema de arquivos

A grande vantagem do Linux do ponto de vista da manutenção do sistema é que tudo é um arquivo. Claro, de vez em quando surge a questão , em que arquivo que vive. Mas, como regra, restaurar o Linux significa usar utilitários básicos do sistema de arquivos, como cp, mv, rm e editor de texto digite vi. Ferramentas como grep, awk e bash são úteis para automatizar essas ações; ou em um nível superior, perl ou python. Mas neste tutorial não pretendemos estudar o manuseio de arquivos.

Supondo que você saiba como editar e gerenciar arquivos, em um sistema danificado, os arquivos afetados podem não ser utilizáveis.

Seu melhor amigo na restauração de um sistema de arquivos danificado fsck.

O comando fsck é na verdade apenas o começo do comando para grande quantidade outras ferramentas fsck.* são fsck.ext2, fsck.ext3 ou fsck.reiser. Você pode determinar o tipo explicitamente usando a opção -t, mas o fsck fará um esforço para descobrir isso sozinho. Leia a página de manual do fsck ou fsck.* para obter mais informações. informações detalhadas. A principal coisa que você precisa saber é que ao usar o argumento -a, o programa tentará corrigir quaisquer erros que encontrar.

Você pode verificar o sistema de arquivos desmontado mencionando a localização do dispositivo no qual ele está localizado. Por exemplo, digite fsck /dev/hda8 para verificar se há uma partição não utilizada. Você também pode verificar o sistema de arquivos raiz digitando fsck /home , mas normalmente só faz isso se o sistema de arquivos já estiver montado como somente leitura em vez de leitura e gravação.

Uma das principais vantagens dos sistemas Linux é a flexibilidade de controle do usuário ao montar e desmontar sistemas de arquivos. Ao contrário do Windows e de alguns outros sistemas operacionais, os locais das partições não são fixados automaticamente pelo kernel do Linux, mas são anexados à hierarquia do sistema de arquivos raiz com o comando mount. Além do mais, vários tipos

sistemas de arquivos (mesmo em dispositivos diferentes) podem ser montados na mesma hierarquia. Você pode desmontar uma partição específica com o comando umount, atribuir qualquer ponto de montagem (por exemplo, /home) ou endereço de dispositivo (por exemplo, /dev/hda7).

Quando um sistema de arquivos está sendo restaurado, a capacidade de controlar pontos de montagem permite analisar o estado das partições usando fsck ou outras ferramentas sem arriscar mais danos a um sistema de arquivos já danificado. Você também pode montar o sistema de arquivos normalmente usando várias opções; os mais importantes montam o sistema de arquivos para uso somente leitura usando um dos sinônimos -r ou -o ro.

Por exemplo, você pode querer substituir o local do diretório de um usuário pelo de outro, seja porque a partição está danificada ou simplesmente porque deseja expandir o espaço em disco ou mudar para uma unidade mais rápida. Essa alteração pode ser feita usando:
# umount /home # diretório inicial antigo /dev/hda7
# mount -t xfs /dev/sda1 /home # novo disco SCSI usando XFS

# mount -t ext3 /dev/sda2 /tmp # também coloca o /tmp no SCSI

/dev/hda7 / ext3 padrões 1 1 nenhum /dev/pts devpts mode=0620 0 0 /dev/hda9 /home ext3 padrões 1 2 nenhum /mnt/cdrom supermount dev=/dev/hdc,fs=auto,ro,- -,iocharset=iso8859-1,codepage=850,umask=0 0 0 nenhum /mnt/floppy supermount dev=/dev/fd0,fs=auto,--,iocharset=iso8859-1,sync,codepage=850,umask =0 0 0 nenhum /proc proc padrões 0 0 /dev/hda8 swap swap padrões 0 0 Provavelmente a tarefa mais primária e típica- Isto é para garantir que o sistema operacional inicialize corretamente.

Para isso, é absolutamente necessário que o administrador compreenda claramente os princípios de inicialização do sistema e as diversas etapas deste processo.

Deve-se dizer que as tarefas para eliminar vários problemas de funcionamento durante o carregamento do sistema são frequentemente encontradas em vários exames de certificação em áreas de sistema operacional.

O primeiro passo após ligar o computador é executar um código de inicialização especial, que é representado na forma do sistema básico de entrada/saída (BIOS). Sistema BIOS Quase toda a configuração do ferro é conhecida. Há informações de qual dispositivo ler os primeiros 512 bytes (MBR).

É no MBR (Master Boot Record) que é armazenado o programa de inicialização primário (estágio 1), que contém informações sobre onde no disco está localizado o programa de inicialização secundário (estágio 2), que carrega o próprio sistema operacional.

Tal carregador em nosso exemplo específicoé o GRUB (Grand Unified Boot Loader). Há também um estágio intermediário (o chamado estágio 1.5), que ajuda o carregador de boot do sistema operacional a determinar parâmetros especiais do sistema de arquivos. Esta rotina é usada se o carregador de boot GRUB não foi instalado diretamente no MBR.

Depois de assumir o controle, o GRUB exibe uma lista de sistemas operacionais (Linux/Windows e versões diferentes Kernels Linux) se disponível. Caso contrário, o controle passa para a linha de comando do GRUB.

Vamos supor que tudo está indo como deveria e que escolhemos o sistema operacional (ou versão do kernel) que precisamos. Nesse caso, o GRUB passa para sua coisa favorita - carregar o próprio sistema operacional.

Todas as informações sobre o andamento do processo de inicialização são exibidas na tela (se não houver nenhum parâmetro nas opções de inicialização do kernel quieto ), bem como para o arquivo de log /var/log/dmesg. Você pode visualizá-lo diretamente ou usando o utilitário dmesg.

Com base na saída de informações de serviço, pode-se tirar conclusões sobre parâmetros de hardware e software, como versões do kernel do sistema operacional, quantidade de RAM, número e características de processadores, discos rígidos e partições correspondentes, placas de rede, arquivo de troca e muito mais.

A análise destas informações em caso de impossibilidade de carregar o SO pode esclarecer o problema surgido, por isso este arquivo é considerado bastante importante para solução de problemas.

Ao carregar o kernel do sistema, é realizada a configuração básica dos dispositivos necessários, dos subsistemas LVM e RAID e do disco RAM initrd, permitindo o carregamento dos drivers necessários.

As etapas adicionais para carregar processos variam muito dependendo da versão do sistema operacional. RHEL5 usa o processo tradicional de carregamento de serviço SysV. O RHEL6 já possui paralelização parcial do carregamento do processo, conforme necessário, e não todos seguidos. Nas novas versões do RHEL (a partir da versão 3.0 do kernel), o processo é ainda mais otimizado através do uso do programa systemd, assim como no Fedora a partir da versão 15. Neste caso, é utilizado um modo de operação assíncrono, que acelera o carregamento do SO.

Tendo transferido o controle para o processo init, o kernel entra em um modo especial e aceita chamadas de todos os processos por meio de uma interface especial de chamada de sistema universal. Neste ponto, o download do Linux pode ser considerado completo.

Você também vai gostar de:

Sistema operacional Linux Curso de palestras. Tutorial Corrigindo a falha CVE-2015-0235 no Linux

Linux: Guia Completo Kolisnichenko Denis Nikolaevich

1.8. Primeiro lançando Linux

1.8. Primeiro lançamento do Linux

Se você escolheu o modo gráfico para fazer login (ou o próprio instalador o escolheu sem perguntar nada), você verá uma tela gráfica com um campo para inserir um nome e senha. Faça login no sistema (de preferência com o nome que você definiu para um usuário normal; use root somente se você ainda não tiver contas regulares) e você verá a área de trabalho do ambiente de janela que você definiu como ambiente padrão, que parece bastante semelhante à área de trabalho do Windows.

Como isso é possível, você já ouviu falar que usuários reais do Linux trabalham em um ambiente de linha de comando? Agora vamos encontrar a linha de comando.

Você sabe que o console, ou terminal (por computador pessoal Esses conceitos são sinônimos) são chamados de dispositivos de entrada-saída projetados para comunicação entre o sistema e o usuário, ou seja, teclado e monitor. Em sistemas do tipo UNIX, existe o conceito de consoles virtuais – consoles que se revezam ocupando fisicamente o mesmo monitor e teclado. Cada um deles pode abrir uma sessão de usuário separada, executar seus próprios aplicativos, em geral, são sistemas de computação quase independentes um do outro.

A maioria das distribuições Linux suporta seis consoles virtuais baseados em texto por padrão, sendo o sétimo um console gráfico. É aqui que você está. Para passar dele para o primeiro console de texto, pressione a combinação de teclas Ctrl+Alt+F1 (no sexto - Ctrl+Alt+F6).

Em resposta ao convite do programa Conecte-se: digite root e pressione<Ввод>. Em seguida, digite sua senha e sua sessão do console de texto será iniciada.

Informações sobre o nome da rede da máquina, versão do sistema operacional e arquitetura podem ser obtidas usando o comando uname -a.

Se conta Para o usuário médio, você ainda não o tem, é hora de obtê-lo. Digite o comando

#useradd< имя >

Se você foi respondido “comando não encontrado", então este comando é chamado adduser em seu sistema.

#senha< имя >

Agora você pode fazer login com um novo nome em um console virtual diferente. Para mudar de um console de texto para outro console de texto, pressione a combinação Alt+Fn, onde n é um número de 1 a 6. Você verá o prompt novamente Conecte-se:.

Você se registrou? Preste atenção na fila do convite. No console onde você fez login como root, termina com o símbolo #, e para qualquer usuário normal, com o símbolo $. Além deste símbolo, o prompt geralmente consiste no nome do usuário, nome do sistema e diretório atual, e pode ser alterado assim que você souber como fazê-lo. Em outros exemplos, as linhas que começam com # ou indicarão o comando que está sendo inserido, e as linhas sem esse símbolo indicarão suas mensagens.

Agora veja você mesmo que o Linux é realmente um sistema multitarefa e multiusuário, ou seja, ao contrário do Windows, vários usuários podem trabalhar simultaneamente. Pergunte quem está atualmente trabalhando no sistema digitando o comando who.

Você verá algo como:

raiz tty1<дата и время начала сеанса root>

Ivan Tty2<дата и время начала сеанса ivan>

raiz:0<дата и время начала сеанса root>

<на графической консоли>

ttyN é o número do console de texto virtual.

Se você estiver perdido e quiser saber em qual console está atualmente, execute o comando tty. Se você esqueceu o nome com o qual efetuou login no console atual, digite o comando whoami. O comando w mostrará não apenas os usuários em execução no momento, mas também as tarefas que eles estão executando.

Você pode rolar pela tela usando as combinações de teclas Shift+PgUp e Shift+PgDn.

Para copiar texto para a linha de comando, use o mouse: arrastando o mouse enquanto mantém pressionado o botão esquerdo seleciona um fragmento, clique botão direito insere-o na posição atual do cursor em qualquer console de texto virtual.

Se você quiser trabalhar com o nome de outro usuário sem sair deste console, digite su<имя>. Por padrão, o nome é root. Geralmente, isso é necessário para executar rapidamente alguma ação administrativa. Volte ao trabalho com seu nome usando o comando exit.

Para voltar ao console gráfico, pressione Alt+F7.

No modo gráfico, você também pode não apenas clicar nos ícones, mas também inserir comandos. Para fazer isso, inicie um terminal virtual (Fig. 1.13) - aplicação gráfica, em cuja janela você pode trabalhar no modo de linha de comando.

Arroz. 1.13. Janela de terminal virtual

O número de terminais virtuais, ao contrário do número de consoles virtuais, não é limitado por nada, nem mesmo pela tradição.

Para encerrar uma sessão em um terminal virtual ou console virtual, digite o comando exit (você também pode sair em um console virtual) ou pressione a combinação de teclas Ctrl+D.

Desligar um usuário não interrompe todo o sistema. Para desligar a máquina, você precisa emitir o comando com direitos de superusuário

# shutdown -h 19:00 [Fim do dia útil]

Neste caso, alguns minutos antes do horário especificado, será enviada uma mensagem de aviso “Fim do dia útil” a todos os que trabalham no sistema, após a qual o sistema será parado corretamente. A forma abreviada deste comando é halt , que interrompe o sistema imediatamente e sem aviso prévio. Você pode reiniciar com o comando reboot.