Lab1: Observando el Comportamiento de Linux

Objetivos

Introducción

Muchas variables conforman el estado del kernel y estas pueden estar alojadas de manera estática o dinámica en un stack frame de la memoria del kernel. Dado que el kernel de Linux es un programa "C" de código abierto,  es posible inspeccionar el código fuente y encontrar algunos ejemplos relevantes de estas variables como por ejemplo xtime definido en include/linux/sched.h que mantiene la hora del sistema, la estructura task_struct definida en include/linux/sched.h que contiene la descripción completa de un proceso, o los valores nr_threads y nr_running definidos en kernel/fork.c los cuales indican cuantos procesos existen y cuantos de estos están corriendo.

El código fuente de Linux lo podemos encontrar en el directorio /usr/src/linux de la mayoría de las distribuciones, pero también existen páginas donde podemos navegar el código de varias versiones de kernel, como por ejemplo Linux Cross Reference. También existen utilidades para navegación de código local como Source Navigator que está disponible en la distribución RedHat.

Tareas

Parte A

• Tipo y modelo de CPU.
• Versión del kernel.
• Tiempo en días,horas, minutos y segundos que han transurrido desde que se inició el sistema operativo.
• Cuanto tiempo de CPU ha sido empleado para procesos de usuario, de sistema y cuando tiempo no se usó.
• Cuanta memoria tiene y cuanta está disponible.
• Cuantos pedidos de lectura/escritura a disco se han realizado.
• Cuantos cambios de contexto han sucedido.
• Cuantos procesos se crearon desde que inició el sistema.

Type: GenuineIntel
Model: Pentium Pro
Uptime: 47d 0:10:14
UserTime: 7:35:14
SysTime: 9:42:43
IdleTime: 46d  6:52:16
TotalMem: 66682880
FreeMem: 3624960
Disk: 35702711
Context: 237097560
Processes: 748877

Parte B

• Tipo y modelo de CPU.
• Versión de Kernel.
• Cantidad de tiempo transcurrido desde que se inició el sistema operativo, con el formato dd:hh:mm:ss.

Parte C

• Cantidad de tiempo de CPU utilizado para usuarios, sistema y proceso idle.
• Número de peticiones a disco realizadas.
• Cantidad de cambios de contexto.
• Tiempo cuando el sistema fue iniciado.
• Número de procesos creados desde el inicio del sistema.

Parte D

• Cantidad de memoria configurada en el hardware.
• Cantidad de memoria disponible.
• Lista de los promedios de carga (cada uno promediado en el último minuto).

Cómo atacar los problemas

Una vez encontrados los archivos de /proc donde está la información, es necesario abrirlos, leer la información y cerrarlos. Esto se puede lograr con las funciones de la biblioteca "C" fopen, fgets (o fscanf) y fclose. Un ejemplo de uso sería el siguiente.
 

#include <stdio.h> #define BUFFSIZE 256 int  main(int argc, char *argv[]) {         FILE *fd;         char buffer[BUFFSIZE+1];         fd = fopen("/proc/sys/kernel/hostname","r");         fgets(buffer, BUFFSIZE+1, fd);         printf("Hostname: %s\n",buffer);         fclose(fd); }

Para leer los argumentos de entrada e interpretarlos (proceso de parsing) hay que hacer uso de las variables int argc y char *argv[]. La primera indica cuantos argumentos se pasaron y argv es el arreglo de tamaño argc con cada uno de las cadenas de los argumentos. Notar que como el propio comando se incluye en la lista de argumentos una llamada ksamp -l 10 100 implica que al inicio del main se cumple {argc=4 & argv[]={"ksamp", "-l", "10", "100"}}. Probablemente se necesite convertir entre tipos de datos ASCII y enteros, la función atoi y las relacionadas pueden ser útiles.

Para obtener la fecha y hora que va en el encabezado del informe que brinda el programa, se pueden utilizar la funciones de la glibc (biblioteca de "C") gettimeofday y ctime,o bien leer el tiempo de inicio del sistema y sumarlo al  transcurrido para luego convertirlo a fecha.

Cuando se necesite realizar las muestra del promedio de carga de 1 minuto, puede ser útil la función sleep que duerme un proceso por un intervalo determinado de tiempo.
 

Qué se debe Entregar

• Código (funcionando bajo las especificaciones dadas  y bajo cualquier caso de test de parametros de entrada)
• Dividir en módulos de manera juiciosa.
• Estilo de código.
• Usar TAD cuando lo crean conveniente, por ejemplo no estaría mal un TAD que contenga toda la información que se quiere con métodos para leer del kernel e imprimir en un filedescriptor los datos, o uno que contenga las opciones de la línea de comandos y que acepte un método para leerlas a partir de argc y argv.
• Utilizar Makefile.
• Todo el código debe estar bajo el directorio Lab1/
• Informe del desarrollo del proyecto
• Número y nombre del laboratorio.
• Integrantes del grupo.
• Descripción de lo realizado.
• Todas las decisiones de diseño tomadas y también las descartadas junto con las razones.
• Descripción de los módulos, grafo de dependencia y razones que llevaron a tal descomposición.
• Utilizar algun formato abierto para el informe, como por ejemplo txt, html, tex.

Cómo se debe Entregar

LabxGyy.tar.gz

Todo el proyecto, es decir el código, documentación y makefile, deberán estar dentro de un directorio de la forma LabxGyy/.
El tarball deberá hacerse sobre éste directorio de la siguiente manera:

tar zcvf Lab1G02.tar.gz Lab1G02/

Tips

Para lograr un estilo de código razonable, basta con ser ordenados y leer un poco de código de personas con experiencia en programación. Aunque no existe un estilo de código, Linus Torvalds escribió un documento al respecto que se puede encontrar en varios formatos, aquí está en español y aquí en inglés.

Hemos visto que distintas versiones de kernel estructuan de manera distinta la forma de leer la cantidad de accesos a disco, tener esto en cuenta si se quiere que el programa sea portable entre diferentes versiones de kernel.

Utilicen debuggers de linea de comandos como gdb o interfaces gráficas para estos como ddd. También pueden realizar compilación condicional para hacer debugging de la siguente manera.
 
 

#define STDOUT 0 #define DEBUG . . #ifdef DEBUG fprintf(STDOUT,"DEBUG> argc: %d\n",argc); #endif . .

Tareas Adicionales

• Algunos de las datos que se muestran involucran cantidades de memoria, y el valor que se puede leer en /proc está siempre expesado en bytes. Como leer cantidades como 64MB en bytes suele ser dificultoso, muchos programas incluyen la opción -h que significa "lejible para humanos", la cual transforma las cantidades a una unidad correspondiente de manera que la cadena se mantenga acotada en tamaño.
• Este programa puede ser muy útil para monitorear la actividad de un servidor, pero resulta más practico si se le agrega una opción -d que bajo la opción -l muestra el diferencial de los valores leidos para, por ejemplo, poder medir cuantos cambios de contexto se están realizando por segundo. Este es un muy buen lugar para utilizar un TAD con los valores de muestra que acepte métodos que calculen el diferencial entre muestras.
• Utilizar getopt de POSIX.2 para parsear la línea de comandos.
• Comparar lo realizado con utilidades establecidas que realizan tareas similares, como por ejemplo procinfo.