erdequake
(usa Ubuntu)
Enviado em 21/09/2019 - 01:41h
tentar
lsmod:
Lista quais módulos estão carregados atualmente pelo kernel. O nome lsmod é uma contração de ls+módulos - Listar Módulos. A listagem feita pelo lsmod é uma alternativa ao uso do comando cat /proc/modules.
A saída deste comando tem a seguinte forma:
Module Size Pages Used by
nls_iso8859_1 8000 1 1 (autoclean)
nls_cp437 3744 1 1 (autoclean)
ne 6156 2 1
8390 8390 2 [ne] 0
A coluna Module indica o nome do módulo que está carregado, a coluna Used mostra qual módulos está usando aquele recurso. O parâmetro (autoclean) no final da coluna indica que o módulo foi carregado manualmente (pelo insmod ou modprobe) ou através do kmod e será automaticamente removido da memória quando não for mais usado.
insmod
Carrega um módulo manualmente. Para carregar módulos que dependem de outros módulos para que funcionem, você duas opções: Carregar os módulos manualmente ou usar o modprobe que verifica e carrega as dependências correspondentes.
A sintaxe do comando é: insmod [módulo] [opções_módulo]
Onde:
módulo
É o nome do módulo que será carregado.
opções_módulo
Opções que serão usadas pelo módulo. Variam de módulo para módulo, alguns precisam de opções outros não, tente primeiro carregar sem opções, caso seja mostrada uma mensagem de erro verifique as opções usadas por ele. Para detalhes sobre que opções são suportadas por cada módulo, veja a sua documentação no código fonte do kernel em /usr/src/linux/Documentation
Exemplo: insmod ne io=0x300 irq=10
modprobe
Carrega um módulo e suas dependências manualmente. Este comando permite carregar diversos módulos e dependências de uma só vez. O comportamento do modprobe é modificado pelo arquivo /etc/modules.conf .
A sintaxe deste comando é: modprobe [módulo] [opções_módulo]
Onde:
módulo
É o nome do módulo que será carregado.
opções_módulo
Opções que serão usadas pelo módulo. Variam de módulo para módulo, alguns precisam de opções outros não, tente primeiro carregar sem opções, caso seja mostrada uma mensagem de erro verifique as opções usadas por ele. Para detalhes sobre que opções são suportadas por cada módulo, veja a sua documentação no código fonte do kernel em /usr/src/linux/Documentation
Nem todos os módulos são carregados corretamente pelo modprobe, o plip, por exemplo, mostra uma mensagem sobre porta I/O inválida mas não caso seja carregado pelo insmod.
Exemplo: modprobe ne io=0x300 irq=10, modprobe sb io=0x220 irq=5 dma=1 dma16=5 mpuio=0x330
depmod
Verifica a dependência de módulos. As dependências dos módulos são verificadas pelos scripts em /etc/init.d usando o comando depmod -a e o resultado gravado no arquivo /lib/modules/versao_do_kernel/modules.dep. Esta checagem serve para que todas as dependências de módulos estejam corretamente disponíveis na inicialização do sistema. O comportamento do depmod pode ser modificado através do arquivo /etc/modules.conf . É possível criar a dependência de módulos imediatamente após a compilação do kernel digitando depmod -a [versão_do_kernel].
Exemplo: depmod -a
modconf
Este programa permite um meio mais fácil de configurar a ativação de módulos e opções através de uma interface através de menus. Selecione a categoria de módulos através das setas acima e abaixo e pressione enter para selecionar os módulos existentes. Serão pedidas as opções do módulo (como DMA, IRQ, I/O) para que sua inicialização seja possível, estes parâmetros são específicos de cada módulo e devem ser vistos na documentação do código fonte do kernel no diretório /usr/src/linux/Documentation. Note que também existem módulos com auto-detecção mas isto deixa o sistema um pouco mais lento, porque ele fará uma varredura na faixa de endereços especificados pelo módulo para achar o dispositivo. As opções são desnecessárias em alguns tipos de módulos.
As modificações feitas por este programa são gravadas no diretório /etc/modutils em arquivos separados como /etc/modutils/alias - alias de módulos, /etc/modutils/modconf - opções usadas por módulos, /etc/modutils/paths - Caminho onde os módulos do sistema são encontrados. Dentro de /etc/modutils é ainda encontrado um sub-diretório chamado arch que contém opções específicas por arquiteturas.
A sincronização dos arquivos gerados pelo modconf com o /etc/modules.conf é feita através do utilitário update-modules. Ele é normalmente executado após modificações nos módulos feitas pelo modconf.
Recompilando o kernel
Será que vou precisar recompilar o meu kernel? você deve estar se perguntando agora. Abaixo alguns motivos para esclarecer suas dúvidas:
Melhora o desempenho do kernel. O kernel padrão que acompanha as distribuições GNU/Linux foi feito para funcionar em qualquer tipo de sistema e garantir seu funcionamento e inclui suporte a praticamente tudo. Isto pode gerar desde instabilidade até uma grade pausa do kernel na inicialização quando estiver procurando pelos dispositivos que simplesmente não existem em seu computador!
A compilação permite escolher somente o suporte aos dispositivos existentes em seu computador e assim diminuir o tamanho do kernel, desocupar a memória RAM com dispositivos que nunca usará e assim você terá um desempenho bem melhor do que teria com um kernel pesado.
Incluir suporte a alguns hardwares que estão desativados no kernel padrão (SMP, APM, ACPI, Virtualização, Firewall, Bridge, memory cards, drivers experimentais, etc).
Se aventurar em compilar um kernel (sistema operacional) personalizado em seu sistema.
Tornar seu sistema mais seguro
Impressionar os seus amigos, tentando coisas novas.
Serão necessários uns 300Mb de espaço em disco disponível para copiar e descompactar o código fonte do kernel e alguns pacotes de desenvolvimento como o gcc, cpp, binutils, gcc-i386-gnu, bin86, make, dpkg-dev, perl, kernel-package (os três últimos somente para a distribuição Debian).
Na distribuição Debian, o melhor método é através do kernel-package que faz tudo para você (menos escolher o que terá o não o suporte no kernel) e gera um pacote .deb que poderá ser usado para instalar o kernel em seu sistema ou em qualquer outro que execute a Debian ou distribuições baseadas (Ubuntu, etc). Devido a sua facilidade, a compilação do kernel através do kernel-package é muito recomendado para usuários iniciantes e para aqueles que usam somente um kernel no sistema (é possível usar mais de dois ao mesmo tempo, veja o processo de compilação manual adiante neste capítulo). Siga este passos para recompilar seu kernel através do kernel-package:
Descompacte o código fonte do kernel (através do arquivo linux-2.6.XX.XX.tar.bz2) para o diretório /usr/src
aso use os pacotes da Debian eles terão o nome de kernel-source-2.6.XX.XX, para detalhes de como instalar um pacote
Após isto, entre no diretório onde o código fonte do kernel foi instalado com cd /usr/src/linux (este será assumido o lugar onde o código fonte do kernel se encontra).
Como usuário root, digite make config. Você também pode usar make menuconfig (configuração através de menus) ou make xconfig (configuração em modo gráfico) mas precisará de pacotes adicionais para que estes dois funcionem corretamente.
Serão feitas perguntas sobre se deseja suporte a tal dispositivo, etc. Pressione Y para incluir o suporte diretamente no kernel, M para incluir o suporte como módulo ou N para não incluir o suporte. Note que nem todos os drivers podem ser compilados como módulos.
Escolha as opções que se encaixam em seu sistema. se estiver em dúvida sobre a pergunta digite ? e tecle Enter para ter uma explicação sobre o que aquela opção faz. Se não souber do que se trata, recomendo incluir a opção (pressionando Y ou M. Este passo pode levar entre 5 minutos e 1 Hora (usuários que estão fazendo isto pela primeira vez tendem a levar mais tempo lendo e conhecendo os recursos que o GNU/Linux possui, antes de tomar qualquer decisão). Não se preocupe se esquecer de incluir o suporte a alguma coisa, você pode repetir o passo make config (todas as suas escolhas são gravadas no arquivo .config), recompilar o kernel e instalar em cima do antigo a qualquer hora que quiser.
Após o make config chegar ao final, digite make-kpkg clean para limpar construções anteriores do kernel.
Agora compile o kernel digitando make-kpkg --revision=teste.1.0 kernel-image. A palavra teste pode ser substituída por qualquer outra que você quiser e número da versão 1.0 serve apenas como controle de suas compilações (pode ser qualquer número).
Observação: Não inclua hífens (-) no parâmetro --revision, use somente pontos.
Agora após compilar, o kernel será gravado no diretório superior (..) com um nome do tipo linux-image-2.6.23.6-i386_teste.1.0.deb. Basta você digitar dpkg -i kernel-image-2.6.23.6-i386_teste.1.0.deb e o dpkg fará o resto da instalação do kernel para você e perguntará se deseja criar um disquete de inicialização (recomendável).
Reinicie seu computador, seu novo kernel iniciará e você já perceberá a primeira diferença pela velocidade que o GNU/Linux é iniciado (você inclui somente suporte a dispositivos em seu sistema). O desempenho dos programas também melhorará pois cortou o suporte a dispositivos/funções que seu computador não precisa.
Caso alguma coisa sair errada, coloque o disquete que gravou no passo anterior e reinicie o computador para fazer as correções.
Para recompilar o kernel usando o método manual, siga os seguintes passos:
Descompacte o código fonte do kernel (através do arquivo linux-2.6.XX.XX.tar.bz2) para o diretório /usr/src. O código fonte do kernel pode ser encontrado em
ftp://ftp.kernel.org/.
Após isto, entre no diretório onde o código fonte do kernel foi instalado com cd /usr/src/linux (este será assumido o lugar onde o código fonte do kernel se encontra).
Como usuário root, digite make config. Você também pode usar make menuconfig (configuração através de menus) ou make xconfig (configuração em modo gráfico) mas precisará de pacotes adicionais.
Serão feitas perguntas sobre se deseja suporte a tal dispositivo, etc. Pressione Y para incluir o suporte diretamente no kernel, M para incluir o suporte como módulo ou N para não incluir o suporte. Note que nem todos os drivers podem ser compilados como módulos.
Escolha as opções que se encaixam em seu sistema. se estiver em dúvida sobre a pergunta digite ? e tecle Enter para ter uma explicação sobre o que aquela opção faz. Se não souber do que se trata, recomendo incluir a opção (pressionando Y ou M. Este passo pode levar entre 5 minutos e 1 Hora (usuários que estão fazendo isto pela primeira vez tendem a levar mais tempo lendo e conhecendo os recursos que o GNU/Linux possui antes de tomar qualquer decisão). Não se preocupe se esquecer de incluir o suporte a alguma coisa, você pode repetir o passo make config, recompilar o kernel e instalar em cima do antigo a qualquer hora que quiser.
Caso esteja compilando um kernel 2.4 ou inferior, Digite o comando make dep para verificar as dependências dos módulos. Se estiver compilando um kernel 2.6 ou superior, pule esse comando.
Digite o comando make clean para limpar construções anteriores do kernel.
Digite o comando make para iniciar a compilação do kernel e seus módulos. Aguarde a compilação, o tempo pode variar dependendo da quantidade de recursos que adicionou ao kernel, a velocidade de seu computador e a quantidade de memória RAM disponível.
Caso tenha acrescentado muitos ítens no Kernel, é possível que o comando make zImage falhe no final (especialmente se o tamanho do kernel estático for maior que 505Kb). Neste caso use make bzImage. A diferença entre zImage e bzImage é que o primeiro possui um limite de tamanho porque é descompactado na memória básica (recomendado para alguns Notebooks), já a bzImage, é descompactada na memória estendida e não possui as limitações da zImage.
A compilação neste ponto está completa, você agora tem duas opções para instalar o kernel: Substituir o kernel anterior pelo recém compilado ou usar os dois. A segunda questão é recomendável se você não tem certeza se o kernel funcionará corretamente e deseja iniciar pelo antigo no caso de alguma coisa dar errado.
Se você optar por substituir o kernel anterior:
É recomendável renomear o diretório /lib/modules/versão_do_kernel para /lib/modules/versão_do_kernel.old, isto será útil para restauração completa dos módulos antigos caso alguma coisa der errado.
Execute o comando make modules_install para instalar os módulos do kernel recém compilado em /lib/modules/versão_do_kernel.
Copie o arquivo zImage que contém o kernel de /usr/src/linux/arch/i386/boot/zImage para /boot/vmlinuz-2.XX.XX (2.XX.XX é a versão do kernel anterior)
Verifique se o link simbólico /vmlinuz aponta para a versão do kernel que compilou atualmente (com ls -la /). Caso contrário, apague o arquivo /vmlinuz do diretório raíz e crie um novo link com ln -s /boot/vmlinuz-2.XX.Xx /vmlinuz apontando para o kernel correto.
Execute o comando lilo para gerar um novo setor de partida no disco rígido
Reinicie o sistema (shutdown -r now).
Caso tudo esteja funcionando normalmente, apague o diretório antigo de módulos que salvou e o kernel antigo de /boot. Caso algo tenha dado errado e seu sistema não inicializa, inicie a partir de um disquete, apague o novo kernel, apague os novos módulos, renomeie o diretório de módulos antigos para o nome original, ajuste o link simbólico /vmlinuz para apontar para o antigo kernel e execute o lilo. Após reiniciar seu computador voltará como estava antes.
Se você optar por manter o kernel anterior e selecionar qual será usado na partida do sistema (útil para um kernel em testes):
Execute o comando make modules_install para instalar os módulos recém compilados do kernel em /lib/modules/versao_do_kernel.
Copie o arquivo zImage que contém o kernel de /usr/src/linux/arch/i386/boot/zImage para /boot/vmlinuz-2.XX.XX (2.XX.XX é a versão do kernel anterior)
Crie um link simbólico no diretório raíz (/) apontando para o novo kernel. Como exemplos será usado /vmlinuz-novo.
Modifique o arquivo /etc/lilo.conf para incluir a nova imagem de kernel. Por exemplo:
Antes da modificação:
boot=/dev/hda
prompt
timeout=200
delay=200
map=/boot/map
install=menu
image = /vmlinuz
root = /dev/hda1
label = 1
read-only
Depois da modificação:
boot=/dev/hda
prompt
timeout=200
delay=200
map=/boot/map
install=menu
image = /vmlinuz
root = /dev/hda1
label = 1
read-only
image = /vmlinuz-new
root = /dev/hda1
label = 2
read-only
Se você digitar 1 no aviso de boot: do Lilo, o kernel antigo será carregado, caso digitar 2 o novo kernel será carregado. Para detalhes veja Criando o arquivo de configuração do LILO, Seção 6.1.1 e Um exemplo do arquivo de configuração lilo.conf, Seção 6.1.3.
Execute o comando lilo para gravar o novo setor de boot para o disco rígido.
Reinicie o computador
Carregue o novo kernel escolhendo a opção 2 no aviso de boot: do Lilo. Caso tiver problemas, escolha a opção 1 para iniciar com o kernel antigo e verifique os passos de configuração (o arquivo lilo.conf foi modificado corretamente?.
Em alguns casos (como nos kernels empacotados em distribuições GNU/Linux) o código fonte do kernel é gravado em um diretório chamado kernel-source-xx.xx.xx. É recomendável fazer um link com um diretório GNU/Linux, pois é o padrão usado pelas atualização do código fonte através de patches (veja Aplicando Patches no kernel, Seção 16.13).
Para criar o link simbólico, entre em /usr/src e digite: ln -s kernel-source-xx.xx.xx linux.
Se quiser mais detalhes sobre a compilação do kernel, consulte o documento kernel-howt
