Interfaz de Shell Linux al kernel Linux
Descripción:
Shell proporciona un entorno al usuario donde el usuario puede ejecutar múltiples programas ejecutables y la salida de esos programas se muestra en la pantalla. Básicamente, la filosofía de trabajo del caparazón es que espera continuamente que el usuario ingrese la cadena. Luego, esta cadena se busca y coincide con los programas ejecutables conocidos que están presentes en el entorno de shell. Si se encuentra el programa ejecutable coincidente, el ejecutable se inicia después de crear un proceso infantil. Este proceso infantil recién creado ejecuta el programa. La salida del programa se entrega al proceso principal que es shell. Shell imprime la salida a la consola si la salida no se redirige. Las ubicaciones donde el shell busca los programas ejecutables está presente en la variable de entorno, "ruta". La variable de ruta mantiene la ":" separada en varias rutas donde shell busca los programas ejecutables.
El diagrama de bloques para la carcasa se muestra en lo siguiente:
Desde el diagrama de bloques proporcionado, podemos concluir que necesitamos un shell para ejecutar cualquier ejecutable de C en el entorno Linux. Sin el shell, no es posible ejecutar el programa C dinámicamente. Hay algunos programas ejecutables predefinidos que se conocen como comandos de shell. Algunos ejemplos de los comandos de shell son LS, PS, etc.
Discutamos los comandos de shell. Hay dos tipos de comandos de shell:
a) Comandos incorporados
Estos son los comandos que son la parte del shell en sí. Mientras ejecuta estos comandos, Shell no bifurca. Estos comandos se ejecutan como parte del propio Shell. Para actualizar en estos comandos, necesitamos una actualización en el shell en sí. Estos comandos están atados con el shell.
Algunos ejemplos de los comandos incorporados son CD, Echo, Kill, Break, Alias, BG, etc. Podemos usar el comando "Ayuda" para ver la lista completa de comandos incorporados.
b) comandos externos
Estos comandos son los ejecutables del programa C separados. Estos no son parte del caparazón. Estos son lugares en una ruta específica. Shell busca esas rutas, ejecuta los programas y muestra la salida. Agregar un nuevo comando a la lista de comandos conocidos es fácil; Simplemente copie un nuevo programa/comando ejecutable a la ruta conocida. En general, estos comandos se colocan en la ruta como /usr /bin, /usr /sbin, etc. Todas las ubicaciones se especifican en la ruta.
En mi sistema, la ruta conocida al shell, que es el comando Echo, se puede verificar para obtener la lista completa de la ruta:
Ubuntu@srathore: $ echo $ ruta
/Home/Cienauser/.Local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/
bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
Si queremos introducir una nueva ruta a esta lista, podemos actualizar los valores a las variables de entorno de ruta. El comando "Exportar" se puede usar para actualizar la ruta con los nuevos valores.
Usando el comando "tipo", podemos obtener que cualquier comando esté incorporado o externo. Entendamos el uso del "tipo". Ejecutar el tipo con "CD" proporciona la siguiente salida:
Ubuntu@srathore: ~/$ type cd
El CD es un caparazón construido
Ubuntu@srathore: ~/$
La salida del comando anterior se explica por sí mismo.
Ahora, probemos el comando "Escriba" con el comando LSPCI:
Ubuntu@srathore: ~/$ type lspci
LSPCI IS/USR/bin/LSPCI
Ubuntu@srathore: ~/$
Como la salida muestra la ruta del ejecutable, podemos concluir que este es un comando externo.
Variables de entorno
Hay pocas variables de entorno definidas para el caparazón. Hasta ahora, entendimos la variable de ruta. La ruta es una variable de entorno que proporciona la lista de ruta a buscar comandos externos. La lista completa de las variables de entorno se puede verificar con la ayuda del comando ENV. El comando env proporciona la lista completa de variables de entorno.
Algunos pocos ejemplos para las variables de entorno de Shell son:
- Ruta: la lista de rutas para comandos externos.
- Shell: el tipo de shell que actualmente está activo.
- OldPWD: el último directorio de trabajo.
- PWD: se refiere al directorio de trabajo actual.
- Usuario: el nombre de usuario para el shell activo.
- Inicio: el directorio de inicio para el usuario.
Hay muchos más. Como se discutió anteriormente, la lista completa se puede verificar con el comando env envían.
Cambiar las variables de entorno
Los valores necesarios se pueden asignar directamente a la variable, ya que Shell nos permite usar el operador de asignación. El valor actual de cualquier variable de shell se puede ver con la ayuda del comando echo. Por ejemplo, si queremos verificar el valor de la ruta. Ejecución del siguiente comando debería poder hacerlo:
Echo $ Path
Uso del operador $ antes de la variable dentro del shell imprime el valor de la variable. Esta es la oferta del comando Echo. Del mismo modo, el eco se puede usar para imprimir cualquier variable de entorno.
Si queremos actualizar la variable de ruta, queremos actualizar la ruta personalizada como /usr /cutom que queremos agregar a la ruta. Colocamos nuestros comandos Cutom en este camino. Para que el shell ejecute estos comandos, su valor debe actualizarse en la ruta. Sin actualizar la ruta si ejecutamos estos programas personalizados, recibimos el error que dice: "No hay dicho archivo o directorio". Este error dice claramente que el shell no puede localizar los comandos.
Como experimento, presentamos nuestro comando personalizado, MyLS y Myps, en el/home/srathore/personalizado. Cuando ejecutamos myls o myps desde /home /srathore, tenemos el siguiente mensaje del shell:
srathore@srathore: ~ $ myls
Comando 'myls' no encontrado, ¿quiso decir:
Comando 'Tyls' de Deb Terminology
Comando 'MMLS' de Deb Sleuthkit
Prueba: instalación de sudo apt
srathore@srathore: ~ $ myps
Comando 'Myps' no encontrado, ¿quiso decir:
Comando 'mypy' de Deb Mypy
Prueba: instalación de sudo apt
srathore@srathore: ~ $
Los mensajes anteriores muestran que estos comandos no se encuentran y el sistema operativo sugiere una sugerencia para instalar estos comandos.
Ahora, agregemos la nueva ruta personalizada a la ruta existente de la siguiente manera:
srathore@srathore: ~ $ echo $ ruta
/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: ~ $ export rath = $ path:/home/srathore/personalizado
srathore@srathore: ~ $ echo $ ruta
/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: ~ $
Nuestra ruta recién agregada se resalta en negrita. Podemos ver que la variable de entorno de ruta se actualiza con el nuevo valor.
Ahora, intentemos nuevamente ejecutar los comandos que están presentes en nuestra ruta personalizada. Al ejecutar "MYP" y "MYLS", tenemos el siguiente resultado:
srathore@srathore: ~ $ myps
Pid tty tiempo cmd
2112 pts/0 00:00:00 Bash
2783 pts/0 00:00:00 Myps
srathore@srathore: ~ $ myls
a.OUT PACK SPD_TOOL BUILD_ROOT_FS KERNEL_ARTICA PATHES STEME
CoreBoot kernel_ubuntu pcie_transfer_app STEME.C
BASH_ARM Custom LMSSensors Redfishtool Telnet_Scripts NVM_CLI
OpenSsh Snap
srathore@srathore: ~ $
Los registros anteriores muestran que ambos comandos funcionaron perfectamente. No tuvimos ningún error como observamos antes de actualizar la variable de ruta. Discutimos la variable de shell más importante, que generalmente modificamos en nuestro trabajo de desarrollo diario. Si instalamos algún paquete nuevo, esta variable se actualiza para que los comandos de la nueva herramienta puedan ubicarse fácilmente por el shell.
Conclusión
Discutimos la definición de shell. También vimos la filosofía detrás de la implementación de shell de los diferentes tipos de comandos proporcionados por Shell y las variables de entorno del shell. También hemos pasado por pocas variables de entorno. Lo más importante, discutimos sobre la variable de ruta. También hemos visto la forma de actualizar la ruta y la importancia de la variable que se demuestra por un ejemplo. Aprendimos la importancia de Shell y sus ofrendas.