Interface de shell linux para o kernel Linux
Descrição:
Shell fornece um ambiente para o usuário em que o usuário pode executar vários programas executáveis e a saída desses programas é exibida na tela. Basicamente, a filosofia de trabalho do shell é que ele espera continuamente que o usuário insira a string. Em seguida, essa string é pesquisada e combinada com os programas executáveis conhecidos que estão presentes no ambiente da Shell. Se o programa executável correspondente for encontrado, o executável será lançado após a criação de um processo infantil. Este processo infantil recém -criado executa o programa. A saída do programa é entregue ao processo pai que é shell. Shell imprime a saída para o console se a saída não for redirecionada. Os locais onde o shell procura os programas executáveis está presente na variável de ambiente, "Path". A variável de caminho mantém o “:” separado em vários caminhos onde a shell procura os programas executáveis.
O diagrama de blocos para a concha é mostrado no seguinte:
No diagrama de blocos fornecido, podemos concluir que precisamos de um shell para executar qualquer executável C em ambiente Linux. Sem a concha, não é possível executar o programa C dinamicamente. Existem alguns programas executáveis predefinidos que são conhecidos como comandos de shell. Alguns exemplos dos comandos do shell são LS, PS, etc.
Vamos discutir os comandos do shell. Existem dois tipos de comandos de shell:
a) Comandos embutidos
Estes são os comandos que fazem parte da própria concha. Ao executar esses comandos, Shell não garra. Esses comandos são executados como parte da própria concha. Para atualizar nesses comandos, precisamos de uma atualização no próprio shell. Esses comandos estão ligados à concha.
Alguns exemplos dos comandos internos são CD, eco, matar, quebrar, pseudônimo, bg, etc. Podemos usar o comando "help" para ver toda a lista de comandos internos.
b) Comandos externos
Esses comandos são os executáveis do programa C separados. Isso não faz parte da concha. Estes são lugares no caminho específico. Shell olha para esses caminhos, executa os programas e exibe a saída. Adicionar um novo comando à lista de comandos conhecidos é fácil; Basta copiar um novo programa/comando executável para o caminho conhecido. Geralmente, esses comandos são colocados no caminho como /usr /bin, /usr /sbin, etc. Todos os locais são especificados no caminho.
No meu sistema, o caminho conhecido para o shell, que é o comando de eco pode ser verificado para obter a lista completa do caminho:
Ubuntu@srathore: $ eco $ caminho
/Home/Cienauser/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/
bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
Se queremos introduzir um novo caminho para esta lista, podemos atualizar os valores para as variáveis do ambiente do caminho. O comando "exportação" pode ser usado para atualizar o caminho com os novos valores.
Usando o comando "type", podemos obter que qualquer comando é interno ou externo. Vamos entender o uso de "tipo". A execução do tipo com "CD" fornece a seguinte saída:
Ubuntu@srathore: ~/$ type CD
CD é uma concha embutida
Ubuntu@srathore: ~/$
A saída do comando anterior é auto-explicativo.
Agora, vamos experimentar o comando "type" com o comando lspci:
Ubuntu@srathore: ~/$ type lspci
LSPCI IS/USR/BIN/LSPCI
Ubuntu@srathore: ~/$
Como a saída mostra o caminho do executável, podemos concluir que este é um comando externo.
variáveis ambientais
Existem poucas variáveis ambientais que são definidas para a concha. Até agora, entendemos a variável do caminho. O caminho é uma variável de ambiente que fornece a lista de caminho a ser pesquisada por comandos externos. A lista completa de variáveis de ambiente pode ser verificada com a ajuda do Comando Env. O comando ENV fornece a lista completa de variáveis de ambiente.
Alguns poucos exemplos para as variáveis ambientais do shell são:
- Caminho: a lista de caminhos para comandos externos.
- Shell: o tipo de shell que está atualmente ativo.
- Oldpwd: o último diretório de trabalho.
- PWD: refere -se ao presente diretório de trabalho.
- Usuário: o nome de usuário para a concha ativa.
- Home: o diretório doméstico para o usuário.
Há muito mais. Conforme discutido anteriormente, a lista completa pode ser verificada com o comando Env.
Alterando as variáveis de ambiente
Os valores necessários podem ser atribuídos diretamente à variável, pois o shell nos permite usar o operador de atribuição. O valor atual de qualquer variável shell pode ser visto com a ajuda do comando de eco. Por exemplo, se queremos verificar o valor do caminho. A execução do comando a seguir deve poder fazer isso:
Eco $ caminho
Usando o operador $ antes da variável dentro do shell imprime o valor da variável. Esta é a oferta do comando Echo. Da mesma forma, o eco pode ser usado para imprimir qualquer variável de ambiente.
Se queremos atualizar a variável do caminho, queremos atualizar o caminho personalizado como /usr /cutom, que queremos adicionar ao caminho. Colocamos nossos comandos Cutom neste caminho. Para que o shell execute esses comandos, seu valor precisa ser atualizado no caminho. Sem atualizar o caminho Se executarmos esses programas personalizados, recebemos o erro dizendo: "Nenhum arquivo ou diretório". Este erro diz claramente que o shell não consegue localizar os comandos.
Como um experimento, estamos no nosso comando personalizado, myls e myps, no/home/srathore/personalizado. Quando executamos myls ou myps de /home /srathore, temos a seguinte mensagem do shell:
srathore@srathore: ~ $ myls
Comando 'myls' não encontrado, você quis dizer:
comando 'tyls' da terminologia Deb
comando 'mmls' de deb sleuthkit
Tente: sudo apt install
srathore@srathore: ~ $ myps
Comando 'myps' não encontrado, você quis dizer:
comando 'mypy' de Deb mypy
Tente: sudo apt install
srathore@srathore: ~ $
As mensagens anteriores mostram que esses comandos não são encontrados e uma sugestão é dada pelo sistema operacional para instalar esses comandos.
Agora, vamos adicionar o novo caminho personalizado ao caminho existente da seguinte forma:
srathore@srathore: ~ $ echo $ caminho
/Home/Cienauser/.Local/bin:/usr/local/sbin:/usr/local/bin:
/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
srathore@srathore: ~ $ exportar caminho = $ caminho:/home/srathore/costume
srathore@srathore: ~ $ echo $ caminho
/Home/Cienauser/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:
/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/home/srathore/personalizado
srathore@srathore: ~ $
Nosso caminho recém -adicionado é destacado em negrito. Podemos ver que a variável de ambiente do caminho é atualizada com o novo valor.
Agora, vamos tentar novamente executar os comandos presentes em nosso caminho personalizado. Ao executar "Myps" e "Myls", temos a seguinte saída:
srathore@srathore: ~ $ myps
Pid tty time cmd
2112 pts/0 00:00:00
2783 pts/0 00:00:00 myps
srathore@srathore: ~ $ myls
a.OUT SPD_TOOL BUILD_ROOT_FS
Coreboot Kernel_ubuntu pcie_transfer_app Stime.c
BASH_ARM LMSensors personalizados RedfishTool telnet_scripts nvm_cli
OpenSsh Snap
srathore@srathore: ~ $
Os registros anteriores mostram que ambos os comandos funcionaram perfeitamente. Não tivemos nenhum erro, como observamos antes de atualizar a variável do caminho. Discutimos a variável de shell mais importante, que geralmente modificamos em nosso trabalho de desenvolvimento diário. Se instalarmos algum novo pacote, esta variável será atualizada para que os novos comandos da ferramenta possam ser facilmente localizados pelo shell.
Conclusão
Discutimos a definição de shell. Também vimos a filosofia por trás da implementação da Shell dos diferentes tipos de comandos fornecidos pelo Shell e pelas variáveis de ambiente do shell. Também passamos por poucas variáveis ambientais. O mais importante, discutimos sobre a variável do caminho. Também vimos a maneira de atualizar o caminho e a importância da variável que é demonstrada por um exemplo. Aprendemos a importância do shell e suas ofertas.