# Grupo 27
| Nombre | Carné |
| -------- | -------- |
| Julian Isaac Maldonado | 201806839|
| Monther Basir | 201807120|
| José Eduardo Morán | 201807455|
# Manual Técnico
## Módulo de procesos
### Librerias
```c=
// Librerias a cargar
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/sysinfo.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/sched/signal.h>
#include <linux/cred.h>
```
### Funciones
#### ProcShow
Metodo que lee todos los procesos e hijos de cada uno de ellos, mediante un archivo se escribe de forma secuencial los atributos de cada uno de ellos
```c=
static int procShow(struct seq_file *m, void *v)
{
seq_printf(m, "[ ");
for_each_process(proc)
{
#define Convert(x) ((x) << (PAGE_SHIFT - 10))
seq_printf(m, "\n{\"PadrePID\": \"-1\",\"PID\": \"%d\","+
"\"Nombre\": \"%s\", \"Estado\": \"%c\", \"CodeSize\": \"%ld\","+
"\"Usuario\": \"%d\", \"RAM\": \"%ld\"},",
proc->pid, //PID del proceso
proc->comm, //Nombre del proceso
task_state_to_char(proc), //State del proceso
Convert(getCodeSize(proc)), //Funcion para obtener codesize
proc->cred->uid.val, //Usuario que lo creo
Convert(getRam(proc))); //Funcion para obtener ram
list_for_each(list, &proc->children)
{
proc_child = list_entry(list, struct task_struct, sibling);
seq_printf(m, "\n{\"PadrePID\": \"%d\",\"PID\": \"%d\","+
"\"Nombre\": \"%s\", \"Estado\": \"%c\","+
"\"CodeSize\": \"%ld\",\"Usuario\": \"%d\","+
"\"RAM\": \"%ld\"},",
proc->pid, //PID del padre del proceso
proc_child->pid, //PID del proceso
proc_child->comm, //Nombre del proceso
task_state_to_char(proc_child), //State del proceso
Convert(getCodeSize(proc_child)), //Funcion para obtener codesize
proc->cred->uid.val,//Usuario que lo creo
Convert(getRam(proc_child))); //Funcion para obtener ram
}
#undef K
}
seq_printf(m, "]\n");
return 0;
}
```
#### getCodeSize
Mediante esta funcion se hace llamada a la funcion get_mm_rss la cual retorna el codesize de cada proceso.
```c=
static long int getCodeSize(struct task_struct *task)
{
if (!task->mm)
return 0;
return get_mm_rss(task->mm);
}
```
#### getRam
Mediante esta funcion se obtienen el atributo exec_vm que es el valor de consumo de ram por proceso, posteriormente se hace un casteo
```c
static long int getRam(struct task_struct *task)
{
if (!task->mm)
return 0;
return (((task->mm->exec_vm)<<(PAGE_SHIFT))>>10)/4;
}
```
## Módulo de Memoria Ram
> Provee datos escenciales de memoria ram en tiempo de ejecución.
Este modulo es capaz de ser montado y desmontado por medio de un archivo Makefile, el cual tambien permite la compilacion y limpieza del modulo. Los datos mostrados son:
* Memoria ram libre en mb
* Memoria ram total en mb
El codigo se encuentra estructurado por las siguientes librerias:
```c=
// Librerias a cargar
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
// Libreria para obtener datos de memoria ram
#include <linux/mm.h>
```
```c
// Por medio del siguiente metodo se pasa por referencia una variable de tipo syinfo,
// en la cual se almacenaran todos los datos recopilados de la memoria ram
si_meminfo(&memstruct);
// Dato que el memstruct no retorna los valores en bytes, se realiza una multiplicacion
// para hacer la conversión
total = memstruct.totalram * 4;
freer = memstruct.freeram * 4;
// Se escribe en el archivo secuencial m (Por conveniencia en este caso se escribe en
// formato json ya que seran los datos enviados a la API).
seq_printf(m, "{\"Total\":\"%lu\", \"Libre\":\"%lu\",", total, freer);
```
## Funciones compartidas
#### procOpen
Hace la llamada al metodo que ejecutara todas las tareas establecidas para el modulo cuando se encuentre insertado.
```c=
static int procOpen(struct inode *inode, struct file *file)
```
#### test_init
Esta llamada carga la función que se ejecutará en el init
```c=
static int __init test_init(void)
```
En el caso de el modulo de memoria ram se imprime un mensaje al ser montado mediante el siguiente codigo
```c=
struct proc_dir_entry *entry;
entry = proc_create("mem_grupo27", 0777, NULL, &my_fops);
if (!entry)
{
return -1;
}
else
{
printk(KERN_INFO "Hola mundo, somos el grupo 27 y "+
"este es el monitor de memoria\n");
}
return 0;
```
#### test_exit
Esta llamada carga la función que se ejecutará en el exit
```c=
static void __exit test_exit(void)
```
En el caso de el modulo de memoria ram se imprime un mensaje al ser demostado de la siguiente manera
```c=
remove_proc_entry("mem_grupo27", NULL);
printk(KERN_INFO "“Sayonara mundo, somos el grupo 27 y "+
"este fue el monitor de memoria\n");
```
### Estructuras
Mediante esta estructura se establecen las tareas que se ejecutaran.
```c=
static struct file_operations my_fops
```
## Manual de usuario
### Requisitos
Verificar si los headers se encuentran instalados
```sh
$ apt search linux-headers-$(uname -r)
```
En caso no se encuentren instalados, se deben instalar a travez del siguiente comando:
```sh
$ sudo apt install linux-headers-$(uname -r)
```
Instalar make y gcc para la compilación
```sh
# Instala make
$ sudo apt install make
# Instala gcc
$ sudo apt install gcc
```
# Manual de usuario
## Modulos de Kernel
### Requisitos
Verificar si los headers se encuentran instalados
```sh
$ apt search linux-headers-$(uname -r)
```
En caso no se encuentren instalados, se deben instalar a travez del siguiente comando:
```sh
$ sudo apt install linux-headers-$(uname -r)
```
Instalar make y gcc para la compilación
```sh
# Instala make
$ sudo apt install make
# Instala gcc
$ sudo apt install gcc
```
### Montaje
Para el montaje es necesario correr los siguientes comandos, el modulo se insertara en la carpeta /proc
```sh
$ make test
# Revisión de montaje correcto
$ ls /proc/procmodule
# Lectura de datos
$ cat /proc/procmodule
```
### Desmontaje
Remueve el modulo del kernel
```sh
make remove
```
### Compilación
Compila el .c y genera todos los archivos necesarios para su ejecución.
```sh
make all
```
### Limpieza
Remueve todos los archivos de compilaciones anteriores
```sh
make clean
```
## Pagina Web
Esta pagina web provee un dashboard en el cual se puede observar diferentes atributos y graficas.
http://arqui2-proyecto1.s3-website.us-east-2.amazonaws.com/
### Resumen Ram
Muestra total, consumida y porcentaje utilizado
### Tiempo real
Muestra graficas de ram consumida en tiempo real y porcentaje de memoria.
### Tabla de Procesos
Muestra todos los atributos recolectados en el modulo de procesos, ademas en este se puede seleccionar un proceso que puede matar posteriormente
### Resumen de procesos
Muestra un resumen de los procesos por estado, en el cual se muestra la cantidad de cada uno
### Matar Proceso
Al presionar matar proceso, envia una solicitud con el proceso previamente seleccionado
Sign in with Wallet
Connect another wallet