Temporalmente Cerrado


Por causas de fuerza mayor, no he podido seguir escribiendo en este blog durante hace ya algún tiempo. Espero que mis posts puedan serles utiles, ya que es este es el objetivo de esta página: El poder brindar información para quien desee fortalecer su conocimiento. Sin embargo, espero regresar a escribir más mini guías para ustedes pronto ;).

Siempre puedes contactarme por medio de:

LinkedIn: http://www.linkedin.com/profile/view?id=74846985&trk=hb_tab_pro_top

Correo: jose_alvarado89@hotmail.com

Mi otro blog: http://endecainformationdiscoverynotes.wordpress.com

root@Linux:~# shutdown -h now "Hasta pronto (: "

El comando echo.


El comando interno echo es una de las instrucciones más simples de la shell. Se encarga de repetir o desplegar en la salida estándr cualquier argumento que se le indíque(inclusive comodínes), para posteriormente saltar una línea. Ejemplos: 

usuario@Linux:~$ echo Hola Mundo!

Hola Mundo!

usuario@Linux:~$ echo /etc/sh*

/etc/shadow /etc/shadow- /etc/shells

SEQUENCIAS DE ESCAPE

El comando echo puede interpretar varias secuencias de escape. Para que estas secuencias de escape puedan ser intepretadas, deben ser encerradas entre comillas dobles o simples y el comando deberá utilizar la opción -e, ya que si no el carácter de escape es interpretado por el shell y no por el comando. Lista de sequencias de escape más relevantes: 

Ejemplos:

usuario@Linux:~$ echo -e "Campana el Sistema: \a Ding Dong!"
usuario@Linux:~$ echo -e "Borra Caracteress\b hacia atras"
usuario@Linux:~$ echo -e "Suprime \c Lo siguiente"
usuario@Linux:~$ echo -e "Retorno de carro. \r"
usuario@Linux:~$ echo -e "Este es un\t tabulador"

OPCIONES

-e: Habilita la interpretación de las sequencias de escape.

 usuario@Linux:~$ echo -e "\a \b \r \t \n \c"

-n: Evitar el brinco de línea que posee el comando por defecto.

 usuario@Linux:~$ echo -n "Evita el brinco de Linea"

-E: Explícitamente suprime la interpretación de las sequencias de escape.

 usuario@Linux:~$ echo -E "Evita el uso de \a \b \r \n, etc."

EJERCICIOS

  1. Despliege en pantalla el mensaje “Esta es una nueva linea”
  2. Haga timbrar la campana del sistema.
  3. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\b” utilizando las opciones -en?
  4. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\b” utilizando solamente la opcion -e?
  5. Imprima tres líneas en blanco en pantalla utilizando sequencias de escape.
  6. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\c” utilizando solamente la opcion -e?
  7. ¿Qué ocurre cuando se utiliza el parámetro “Mensaje de prueba\c” utilizando solamente la opcion -en?
  8. Imprima el mensaje “No se generan Lineas Nuevas” Utilizando la opcion -n.
  9. Imprima en pantalla mensaje “No \a \b \n” especificando explícitamente que no se tomarán en cuenta las sequencias de escape.

Los parámetros posicionales en un Shell Script.


Como ya se ha mencionado en entradas anteriores, las variables del shell son espacios de memoria que poseen nombre y guardan información. Ciertas variables son conocidas como variables de ambiente. Se les conoce así ya que sus valores pueden ser conocidos por los subprocesos del shell.

Las variables internas más importante del sistema son los parámetros posicionales. Estas variables guardan los valores de los argumentos que se envían a los scripts cuando son invocados.

Los parámetros posicionales son nombrados numéricamente a partir de 1 hasta N, donde N es el último argumento enviado al script. También existe el parámetro posicional 0, cuyo valor es el nombre del script invocado( o en defecto, la manera en que se invocó). Por ejemplo, suponga que posee el siguiente script de nombre prueba_posicional y lo invoca de la siguiente manera:

#! /bin/bash

# Script para probar parametros posicionales.El script desplegara los primeros tres parametros enviados por el usuario junto con el nombre del script.

echo "Nombre del script: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: ${2}"
echo "Tercer argumento: ${3}"

usuario@Linux:~$ . prueba_posicional Uno Dos Tres

De la misma forma, existen dos variables especiales las cuales contienen a todos los parámetros posicionales (excepto por el parámetro 0). Por ejemplo, suponga que posee el script prueba_posicional2 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar las variables especiales. Las variables $* y $@ desplegaran
 la lista de parametros pasados al script.

echo "Nombre del script: $0"
echo Argumentos: $*
echo Argumentos: $@

usuario@Linux:~$ . prueba_posicional2 1 a 3 b 5 c 7 e 9 f

La diferencia entre estas dos variables es poco importante y puede distinguirse cuando estas variables se encuentran entre dobles comillas la variable de IFS(Una variable de entorno que contiene una lista de caracteres para separar campos) está fijada a algún carácter visible.

$* contiene a los parámetros posicionales, comenzando por el uno. Cuando la variable $* se encuentra entre comillas dobles, todos los parámetros son tratados como una sola unidad, esto ya que cada uno de los valores de los parámetros es separado por el primer carácter de la variable especial IFS. Si la variable IFS no está establecida, los parámetros se separan con espacios. Si IFS es nulo, los parámetros se unen sin utilizar ningún tipo de separador.

$@ contiene a los parámetros posicionales, empezando por el uno. Cuando la variable $@ se encuentra entre comillas dobles cada parámetro es tratado como una unidad separada del resto. Por ejemplo, suponga que posee el siguiente script de nombre prueba_posicional3 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar las variables especiales.

# Prueba utilizando el valor por defecto de variable IFS sin comillas dobles.

echo "Prueba utilizando el valor por defecto de variable IFS sin comillas dobles."
echo "==================================================="
echo "Valor de variables IFS: $IFS"
echo "Nombre del script: $0"
echo Argumentos: $*
echo Argumentos: $@
echo

# Prueba utilizando el valor por defecto variable IFS con comillas dobles.

echo "Prueba utilizando el valor por defecto de variable IFS con comillas dobles."
echo "==================================================="
echo "Valor de variable IFS: $IFS"
echo "Nombre del script: $0"
echo "Argumentos: $*"
echo "Argumentos: $@"
echo

# Prueba utilizando variable IFS sin comillas dobles.

IFS=#

echo "Prueba utilizando variable IFS sin comillas dobles."
echo "==================================================="
echo "Nombre del script: $0"
echo "Valor de variable IFS: $IFS"
echo Argumentos: $*
echo Argumentos: $@
echo

# Prueba utilizando variable IFS con comillas dobles.

IFS=$

echo "Prueba utilizando variable IFS con comillas dobles."
echo "==================================================="
echo "Nombre del script: $0"
echo "Valor de variable IFS: $IFS"
echo "Argumentos: $*"
echo "Argumentos: $@"

usuario@Linux:~$ . prueba_posicional3 1 2 3 4 a b c d

La variable especial # guarda el número de parámetros posicionales enviados al script. Ejemplo, suponga que posee el siguiente script de nombre prueba_posicional4 y lo ejecuta de la siguiente manera:

#! /bin/bash

# Script para probar parametros posicionales

echo "Nombre del script: $0"
echo "Numero de argumentos: $#"
usuario@Linux:~$ . prueba_posicional4 1 2 3 4

 

EJERCICIOS

  1. Cree un Shell Script el cual reciba 5 parámetros y los despliegue en pantalla.
  2. Cree un Shell Script el cual reciba(incluyendo las comillas) los siguientes parámetros:  “Primer Parametro” “Segundo Parametro” “Tercer Parametro”. ¿Qué valor muestra la variable #? ¿Qué se puede inducir de este ejercicio?
  3. Cree un Shell Script el cual reciba(incluyendo las comillas) los siguientes parámetros:  “Scooby Doo” ‘Shaggy’ Vilma Fred . ¿Qué valor muestra la variable #? ¿Qué se puede inducir de este ejercicio?
  4. Cree un Shell Script que despliegue el nombre del mismo.
  5. ¿Qué pasaría si un Shell script recibe 9 parámetros y se intenta imprimir el parámetro 10?
  6. Cree un Shell Script el cual despliegue en pantalla todos los valores de los parámetros enviados utilizando las dos variables especiales mencionadas.
  7. Cree un Shell Script el cual despliegue en pantalla todos los valores de los parámetros enviados,  separados por un guión.
  8. Cree un  Shell Script el cual cree un directorio a partir del primer parámetro recibido.
  9. Cree un  Shell Script el cual despliegue el contenido de un archivo a partir del segundo parámetro recibido.
  10. Realice diferentes pruebas con el script número 3 utilizando diferentes valores para la variable de entorno IFS. ¿ Cómo se comportan las variables $@ y $*?

¿Qué son las funciones?


Se puede decir que una función es un script dentro de otro script; se utilizan para definir y guardar código por nombre en la memoria del shell, para así,  ser invocado y ejecutado posteriormente.

Las funciones mejoran la programabilidad significativamente, por 2 razones principales:

  1. Cuando se invoca una función, esta ya se encuentra definida en memoria, por lo tanto se ejecuta de una manera más rápida.
  2. Las funciones son ideales para organizar a los scripts en pedazos modulares lo que hace que el código sea más fácil de desarrollar y mantener.

Se puede definir una función utilizando dos formatos:

1. Utilizando el estilo Bourne Shell. Ejemplo:

#####################################################################
#
#   DEFINICION DE FUNCION ESTILO BOURNE SHELL
#
#   function funcion
#   {
#      COMANDO_1
#      COMANDO_2
#      .
#      .
#      .
#      COMANDO_n
#   }
#
#####################################################################
#! /bin/bash

# Funcion que muestra el numero de argumentos que se le envien.

function escribeParametros
{
	# FUNCNAME es una variable de entorno que guarda el nombre de la funcion.
	printf "Hola, estoy en la funcion ${FUNCNAME}\n"

	# Despliega el contenido del archivo /etc/hosts.
	cat /etc/hosts

	# Termina funcion.
	exit 0
}

# Empieza cuerpo principal del script.

# Llamado a funcion.
escribeParametros

# Imprime el valor de terminacion de la funcion.
echo "Valor de terminacion: $?"

2. Utilizando el estilo C Shell. Ejemplo:

#####################################################################
#
#   DEFINICION DE FUNCION ESTILO BOURNE SHELL
#
#   function funcion
#   {
#      COMANDO_1
#      COMANDO_2
#      .
#      .
#      .
#      COMANDO_n
#   }
#
#####################################################################
#! /bin/bash

muestraInformacion()
{
	# Muestra información del usuario que ejecute el script a base de variables de entorno.
	echo "Usuario: $USER"
	printf "Shell: $SHELL \n"
	printf "Directorio Inicial: $HOME \n"
	echo "Host: $HOSTNAME"

	# Termina funcion.
	exit "$?"
}

# Inicia bloque principal del script.

# Llamado a funcion
muestraInformacion

# Imprime el valor de terminacion de la funcion
echo "Valor de terminacion $?"

Cuando se declara una función, el shell guarda su nombre y definición(es decir, los comandos que contiene) en memoria. Si se desea ejecutar la función después, solo hace falta escribir el nombre de la función seguida de sus argumentos, tal como si fuera un script. Ejemplo:

usuario@Linux:~$ escribeParametros "Este es un solo parametro" 

Se pueden visualizar las funciones(tanto como su definición) que se tienen guardadas dentro de una sesión utilizando el comando declare con la opción -f. Ejemplo:

usuario@Linux:~$ declare -f 

Si se requiere obtener solamente el nombre de las funciones, se puede utilizar el comando declare -F. Ejemplo:

usuario@Linux:~$ declare -F

De igual forma, una función también puede borrarse ejecutando el comando unset utilizando la opción -f seguido del nombre de la función. Ejemplo:

usuario@Linux:~$ unset -f escribeParametros

EJERCICIOS

  1. Cree un Shell Script utilizando la sintaxis Bourne Shell el cual contenga una función en la cual se cree el directorio directorioFuncion.
  2. Cree un Shell Script utilizando la sintaxis C Shell el cual contenga una funcion que despliegue en pantalla el contenido del archivo /etc/passwd.
  3. Cree un Shell Script utilizando la sintaxis Bourne Shell  el cual obtenga el nombre y directorio para la ruta estaRutaNoExiste.
  4. Cree un Shell Script utilizando la sintaxis C Shell el cual imprima el directorio actual de trabajo del usuario.
  5. Cree un Shell Script utilizando la sintaxis Bourne Shell  el cual muestre los primeros 76 caracteres del archivo /etc/shells.
  6. Cree un Shell Script utilizando la sintaxis C Shell el cual cambie su dirección actual por el diretorio raíz.
  7. Cree un Shell Script utilizando la sintaxis C Shell el cual visualice la página del manual del comando ls.

Creador de Linux recibe el “Nobel” de Tecnología.


Los dos científicos galardonados.

El programador finlandés Linus Torvalds, creador del sistema operativo de código abierto Linux, y el médico japonés Shinya Yamanaka recibieron en Helsinki el Premio Millennium de Tecnología, el galardón más importante del mundo en este campo y considerado el “Nobel” de tecnología.

 El presidente de Finlandia, Sauli Niinistö, fue el encargado de hacer entrega del premio a Torvalds y Yamanaka, quienes se repartirán a partes iguales los 1,2 millones de euros (1,5 millones de dólares) del galardón, durante una ceremonia celebrada en la Ópera Nacional de Helsinki.

Torvalds, informático de 42 años, fue distinguido por crear el kernel (núcleo) del sistema operativo de código abierto Linux y por su trabajo en favor del software libre, según la academia.

“La labor de Linus Torvalds ha mantenido la web abierta a la búsqueda del conocimiento y para el beneficio de la humanidad, no simplemente por intereses económicos”, señaló la presidenta de la Academia Finlandesa de Tecnología, Ainomaija Haarla.

Torvalds creó Linux en 1991 cuando era estudiante de la Universidad de Helsinki y lo desarrolló con las aportaciones de miles de internautas voluntarios, hasta convertirse en el exponente más conocido del software libre.

Veinte años después, este informático finlandés sigue supervisando la evolución de Linux desde su casa de Portland (EE.UU.), para garantizar que se mantenga como un sistema operativo libre de código abierto, en contraste con el Windows de Microsoft y el iOS de Apple.

Linus Torvalds recibiendo el galardón.

“El código abierto es muy importante, es como aplicar al software el enfoque científico de construir a partir del trabajo publicado abiertamente por los demás. Y el software es demasiado importante en el mundo moderno como para que no sea desarrollado de esa forma”, declaró Torvalds.

Millones de personas utilizan ordenadores, teléfonos inteligentes y videocámaras digitales equipados con Linux, un sistema operativo que ha servido también para desarrollar el software que emplean gigantes tecnológicos como Google, Amazon y Facebook.

Torvalds compartirá este galardón con el médico japonés Shinya Yamanaka, inventor de un nuevo método para producir en el laboratorio células madre de pluripotencia inducida (iPS, por sus siglas en inglés).

La Pila de Directorios(Directory Stack).


La pila de directorios es una lista que contiene los directorios visitados recientemente. Los comandos pushd y popd implementan esta pila permitiendo que el usuario pueda moverse entre los directorios utilizados recientemente y la shell pueda recordar tales rutas.

El comando pushd añade directorios a la pila y cambia al directorio actual de trabajo por el último directorio añadido a la pila. El comando popd remueve los directorios de la cima de la pila y cambia la ruta actual por el último directorio eliminado.

El comando dirs muestra el contenido de la pila de directorios. El contenido de la pila también puede ser consultado desde la variable de entorno DIRSTACK.

EL COMANDO PUSHD

La instrucción pushd guarda al directorio especificado en la cima de la pila de directorios y lo convierte en el directorio actual de trabajo. De no especificarse algún argumento, el comando intercambiará los dos directorios que se encuentren más arriba en la pila. Ejemplo:

usuario@Linux:~$ pushd /tmp

OPCIONES

+N: Lleva al n-ésimo directorio(contando de izquierda a derecha de la lista impresa por el comando dirs, empezando por 0) a la cima de la pila. Ejemplo:

usuario@Linux:~$ pushd +0 /etc

-N: Lleva al n-ésimo directorio(contando de derecha a izquierda de la lista impresa por el comando dirs, empezando por 0) a la cima de la pila. Ejemplo:

usuario@Linux:~$ pushd -0 /lib

dir: Hace que el directorio especificado se convierta en la cima de la pila y por lo tanto se convierta en el directorio actual de trabajo. Ejemplo:

usuario@Linux:~$ pushd /bin

EL COMANDO POPD

Elimina al directorio que se encuentra en la cima de la pila y convierte al nuevo directorio del tope de la pila en el directorio actual de trabajo.

OPCIONES

+N: Elimina el n-ésimo directorio(contando de izquierda a derecha de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$: popd +1

-N: Elimina el n-ésimo directorio(contando de derecha a izquierda de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$: popd -0

EL COMANDO DIRS

La instrucción dirs, permite visualizar los directorios almacenados actualmente en la pila de directorios. Ejemplo:

usuario@Linux:$~ dirs

OPCIONES

+N: Muestra el n-ésimo directorio(contando de izquierda a derecha de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$ dirs +3

-N: Muestra el n-ésimo directorio(contando de derecha a izquierda de la lista de directorios impresa por el comando dirs), comenzando con cero. Ejemplo:

usuario@Linux:~$ dirs -1

-c: Limpia la pila de directorios. Ejemplo:

usuario@Linux:~$ dirs -c

-v: Muestra los directorios enumerados. Ejemplo:

usuario@Linux:~$ dirs -v

EJERCICIOS

  1. Agregue el directorio /tmp a su pila de directorios. ¿Qué ocurre?
  2. ¿Qué directorios se encuentran en su stack de directorios?
  3. Agregue a los directorios /bin, /lib, /usr y /etc a su pila de directorios.
  4. Muestre su pila de directorios enumerada.
  5. Ejecute al comando pushd sin argumentos. ¿Qué ocurre?
  6. Muestre su pila de directorios para corroborar al ejercicio anterior.
  7. Lleve al directorio que se encuentra más a la izquierda de su pila de directorios a la cima de la pila.
  8. Remueva el directorio que se encuentre en la cima de la pila.
  9. Muestre su pila de directorios para corroborar al ejercicio anterior.
  10. Remueve al directorio que se encuentre más a la derecha en la cima de la pila.
  11. Limpie su pila de directorios.

El comando exit.


El comando exit finaliza un script. Incluso, puede arrojar un valor de terminación, el cual estará disponible para su proceso padre.

Todo comando posee un estado de terminación(exit status). Un comando que se ejecutó satisfactoriamente arrojará un valor de 0, mientras que un comando que no se procesó de manera correcta, finalizará con un número diferente de 0.

Al igual que un comando, un script posee su propio estado de terminación, el cual será determinado por la última instrucción ejecutada por el script.

Dentro de un script, el comando exit puede arrojar un número dentro de un rango de 0 a 255. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
COMANDO_n

exit 206

De no utilizar un parámetro en el comando exit, el script arrojará el valor de terminación de la última instrucción ejecutada. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
echo "Terminando Script..."

# El programa finalizara con el estatus arojado por el comando echo

exit

Otra manera por la cual el script puede arrojar el valor de terminación de la última instrucción ejecutada es utilizando el comando exit  anteponiendo como parámetro la variable especial $? . Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
printf "Terminando Script..."

# El programa terminara con el estatus arojado por el comando printf

exit $? # Utilizacion de la variable $?

Una última forma por la cual el script puede arrojar el estado de terminación de la última sentencia ejecutada es evitando el uso del comando exit. Ejemplo:

#! /bin/bash

############################
##
## Cuerpo Del script.
##
############################

COMANDO_1
COMANDO_2
.
.
.
echo -n 'Terminando Script...'

# El programa finalizara con el valor arrojado por el último comando ejecutado.

La variable $? lee el valor de terminación del último comando ejecutado. De igual forma, cuando un script termina de ejecutarse, la variable $? guarda su valor de terminación.

EJERCICIOS

  1. Trate de revisar las páginas del manual para el comando esteComandoNoExiste. ¿Cuál es su valor de terminación?
  2. Utilice el comando pwd sobre su directorio actual. ¿Cuál es su valor de terminación?
  3. Visualice las últimas 5 líneas de /etc/hosts y /etc/archivoInexistente. ¿Cuál es su valor de terminación?
  4. Visualice el contenido del archivo /etc/hosts. ¿Cuál es su valor de terminación?
  5. Cree y ejecute un shell script cuyo valor de terminación sea 213.
  6. Cree y ejecute un shell script cuyo valor de terminación sea 0.
  7. Cree y ejecute shell script cuyo valor de terminación este basado en la instrucción ls -a /tmp. ¿Cuál es su valor de terminación?
  8. Cree y ejecute shell script cuyo valor de terminación este basado en la instrucción head archivoInexistente. ¿Cuál es su valor de terminación?

¿Qué es GNU?


El sistema operativo GNU es un sistema completo de software libre, compatible hacía el futuro con Unix. El término GNU proviene de «GNU No es Unix». Richard Stallman escribió el anuncio inicial del Proyecto GNU en septiembre de 1983. Una versión extendida, denominada el Manifesto de GNU se publicó en setiembre de 1985. Se ha traducido a diversos idiomas.

El nombre «GNU» se eligió porqué satisfacía unos cuantos requisitos. En primer lugar, era un acrónimo recursivo para «GNU No es Unix». En segundo lugar, era una palabra real. Por último, era divertido de decir (o cantar).

La palabra “libre” en “software libre” se refiere a libertad, no a precio [N. del T.: en inglés se usa la misma palabra para libre y gratuito]. Puede o no pagar un precio por obtener software de GNU. De cualquier manera, una vez que obtiene el software, tiene cuatro libertades específicas para usarlo. La libertad de ejecutar el programa como desée, la libertad de copiar el programa y darlo a sus amigos o compañeros de trabajo. La libertad de cambiar el programa como desee, teniendo acceso completo al código fuente. La libertad de distribuir una versión mejorada ayudando así a construir la comunidad (si redistribuye software de GNU, puede cobrar una tarifa por el acto físico de efectuar la copia, o bien puede regalar copias.).

El proyecto para desarrollar el sistema GNU se denomina «Proyecto GNU». El Proyecto GNU se concibió en 1983 como una forma de devolver el espíritu cooperativo que prevalecía en la comunidad computacional en sus primeros días; hacer la cooperación posible al eliminar los obstáculos impuestos por los dueños de software privativo.

En 1971, cuando Richard Stallman comenzó su carrera en el MIT, trabajó en un grupo que usaba software libre exclusivamente. Incluso compañías informáticas frecuentemente distribuían software libre. Los programadores eran libres de cooperar unos con otros, y frecuentemente lo hacían.

Cada usuario de ordenadores necesita un sistema operativo; si no existe un sistema operativo libre, entonces no puedes ni siquiera comenzar a usar una computadora sin recurrir a un software privativo. Así que el primer elemento en la agenda del software libre es un sistema operativo libre.

Para continuar leyendo este artículo visitar: GNU.org

Conceptos de las Shells.


Estas son las definiciones de los conceptos  más utilizados a la hora de hablar de los Shells de Unix y Linux:

  • POSIX : Una familia de estándares libres basados en Unix.
  • Blanco(Blank) : Un carácter espacio o tabulador
  • Comando Interno(Builtin): Un comando que es implementado internamente por la shell, en vez de por un programa ejecutable en algún lugar del sistema de ficheros.
  • Operadores de Control(Control Operator): Un token que realiza una función de control. Es una nueva linea o alguno de los siguientes símbolos: ‘||’, ‘&&’, ‘&’, ‘;’, ‘;;’, ‘|’, ‘|&’, ‘(’, o ‘)’.
  • Estado de Salida(Exit Status): El valor retornado por un comando a su llamador. Este valor está restringido a ocho bits, así que su valor máximo puede ser de 255.
  • Campo(Field): Una unidad de texto que es el resultado de una de las expansiones del shell. Tras la expansión, cuando se ejecuta un comando, los campos resultantes se pueden utilizar como nombre de comando y argumentos .
  • Nombre de Archivo(Filename): Una cadena de caracteres usada para identificar un archivo.
  • Tarea (Job):Un juego de procesos que componen una tubería, y los procesos que descienden de estos, que están todos en el mismo grupo de procesos.
  • Control de Tareas(Job Control): Un mecanismo por el cual los usuarios pueden parar (suspender) y reiniciar (reanudar) la ejecución de procesos.
  • Metacaracter(Metacharacter): Un carácter que, cuando se encuentra sin entrecomillar, separa palabras. Un metacaracter es un blanco o uno de los siguientes caracteres: ‘|’, ‘&’, ‘;’, ‘(’, ‘)’, ‘<’, o ‘>’.
  • Nombre(Name): Una palabra consistente únicamente en letras, números y caracteres de subrayado, y que comienza con una letra o un carácter de subrayado. Los nombres se usan como nombres de variables de shell y de funciones. También se le llama identificador.
  • Operador(Operator): Un operador de control o un operador de redirección. una lista de operadores de redirección. Los operadores contienen al menos un metacaracter sin entrecomillar.
  • Grupo de Procesos (Process Group): Una colección o procesos relacionados cada uno de los cuales tiene el mismo identificador de grupo de procesos.
  • Identificador de Grupo de Procesos(Process Group ID): Un identificador único que representa un grupo de procesos durante su tiempo de vida.
  • Palabra Reservada (Reserved Word): Una palabra que tiene un significado especial para la shell. La mayoría de las palabras reservadas introducen en la shell construcciones de control de flujo, como for y while.
  • Estado de Retorno (Return Status): Un sinónimo para el estado de salida.
  • Señal(Signal): Un mecanismo por el que cualquier proceso puede ser notificado por el kernel de un evento ocurrido en el sistema.
  • Comandos Internos Especiales (Special Builtins): Un comando interno de la shell que ha sido clasificado como especial por el estándar POSIX
  • Token: Una secuencia de caracteres considerados una unidad única por el shell. Puede ser bien una palabra o un operador.
  • Palabra(Word): Una secuencia de caracteres tratados como una unidad por el shell. Las palabras no pueden incluir metacaracteres sin entrecomillar.

El Linux Kernel 3.4 fue lanzado oficialmente.


Tras el lanzamiento de siete versiones candidatas a definitiva (Release Candidate), Linus Torvalds ha anunciado hace varias horas, el 20 de mayo, la disponibilidad inmediata para su descarga del Linux kernel 3.4.

Entre las nuevas funciones incorporadas en el Linux kernel 3.4 podemos mencionar muchas mejoras para el sistema de archivos Btrfs, así como soporte para la tarjeta gráfica Nvidia GeForce 600 ‘Kepler’, la RadeonHD 7xxx y la APU Trinity.

“No ocurrió nada nuevo desde la -rc7, aunque la solución a un error del vinculador en x86 es mayor de lo que me hubiera gustado en esta etapa. […] Dicho esto, tampoco el parche fue del todo espeluznante”.

“De hecho, creo que el ciclo de lanzamiento de la versión 3.4 ha sido bastante tranquilo. Claramente, siempre deseo que las RCs se calmen con más rapidez de lo que parecen hacerlo, pero creo que en general no hemos tenido ningún acontecimiento importante. Esperemos que la ventana de fusión con 3.5 sea también tranquila”, dijo Linus Torvalds en el anuncio oficial.

Principales características del Linux Kernel 3.4:

  • Herramientas de reparación y recuperación de datos para Btrfs;
  • Bloques de metadatos mayores de 4KB en Btrfs;
  • Mejoras de rendimiento para Btrfs;
  • Gestión mejorada de los errores en Btrfs;
  • Soporte anticipado para Nvidia GeForce 600 ‘Kepler';
  • Soporte para los gráficos Intel Medfield;
  • Soporte para la RadeonHD 7xxx y la APU Trinity;
  • Nueva ABI X32: Modo de 64 bits con punteros de 32 bits;
  • Driver de autoprobing para la CPU x86;
  • Ruta de arranque comprobable con el mapeador de dispositivos “verity”;
  • Soporte para un dispositivo externo de lectura como fuente de origen para un volumen LVM;
  • Rendimiento: mejor visualización del ensamblado, profiles de ramas, filtrado de los usuarios y subprocesos e informe de GTK2 en la GUI;
  • Módulo de seguridad ‘Yama’.

El Linux Kernel 3.4 también trae mejoras en muchas áreas, como correcciones para la gestión de la memoria, redes, mejoras de los sistemas de archivos EXT4, FUSE, NFS, XFS, HFSplus, CIFS y GFS2, así como mejoras de virtualización KVM y Xen.

Como de costumbre, lo de arriba son sólo algunas de las nuevas funciones del Linux kernel 3.4. Para ver la lista completa de los nuevos drivers agregados, nuevos dispositivos compatibles y otras mejoras, click aquí para ver la lista completa de cambios y la página de DriverArch del Linux Kernel 3.4.

Fuente: SoftPedia