---
# System prepended metadata

title: Grupo 27

---

# 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
![Resume](https://media.discordapp.net/attachments/743633380578689046/885365971819298826/unknown.png?width=1441&height=315)

### Tiempo real
Muestra graficas de ram consumida en tiempo real y porcentaje de memoria.
![TiempoReal](https://media.discordapp.net/attachments/743633380578689046/885366037468577802/unknown.png?width=1380&height=678)

### 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
![Procesos](https://media.discordapp.net/attachments/743633380578689046/885366152572837939/unknown.png?width=1109&height=678)


### Resumen de procesos 
Muestra un resumen de los procesos por estado, en el cual se muestra la cantidad de cada uno
![RProcesos](https://media.discordapp.net/attachments/743633380578689046/885366267517734932/unknown.png)

### Matar Proceso
Al presionar matar proceso, envia una solicitud con el proceso previamente seleccionado
![Matar Proceso](https://media.discordapp.net/attachments/743633380578689046/885366297599283230/unknown.png)

