int escrituras() {
//declara el directorio del proceso añadiendo su pid al nombre
char dir_proceso [60];
memset(dir_proceso, 0, strlen(dir_proceso));
sprintf(dir_proceso, "%sproceso_%d/", dir_sim, getpid());
printf("\tCreación del directorio del proceso %d\n", getpid());
//creamos el directorio de proceso
if (mi_creat(dir_proceso, 7) < 0) {
printf("ERROR: simulacion => escrituras: Error al crear el directorio %s\n", dir_proceso);
}
//declara el fichero del proceso
char nombre_f [60];
memset(nombre_f, 0, strlen(nombre_f));
sprintf(nombre_f, "%sprueba.dat", dir_proceso);
printf("\t\tCreación del fichero 'prueba.dat' en el proceso %d\n", getpid());
//creamos el fichero del proceso
if (mi_creat(nombre_f, 7) < 0) {
printf("ERROR: simulacion => escrituras: Error al crear el fichero %s\n", nombre_f);
}
struct registro reg;
//actualizar la semilla de numeros aleatorios
srand(time(NULL) + getpid());
int cubo = 256 * 256 * 256;
int cuadrado = 256 * 256;
int posMax = ((((12 + 256 + (cuadrado)+(cubo)) - 1) * BLOCKSIZE) / sizeof (struct registro));
int j;
printf("\t\t\tRealización de %d escrituras de registro en %s\n", num_escrituras, nombre_f);
for (j = 0; j < num_escrituras; j++) {
//creamos el registro de simulación
reg.fecha = time(NULL);
reg.pid = getpid(); //getpid()
reg.nEscritura = j + 1;
reg.posicion = rand() % posMax;
//Escribir el registro con mi_write
int bytes_escritos = mi_write(nombre_f, ®, reg.posicion * sizeof (struct registro), sizeof (struct registro));
if (bytes_escritos <= 0) {
printf("ERROR: simulacion => escrituras: Error al escribir el registro %d en la posición %d\n", reg.nEscritura, reg.posicion);
return -1;
}
usleep(50);
}
printf("\t\t\tFinalizadas las %d escrituras de registro en el proceso %s\n", num_escrituras, nombre_f);
return 1;
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="mi_mkdir"; nombre del main
argv[1]=disco(sistema de ficheros)
argv[2]=permisos
argv[3] = ruta
*/
if (argc != 4) {
printf("ERROR: mi_mkdir => main: Faltan argumentos!!! El número permitido de argumentos son 4. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: mi_mkdir => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
int resultado = mi_creat(argv[3], atoi(argv[2]));
if (resultado < 0) {
printf("ERROR: mi_mkdir => main: Error al crear el directorio/fichero.\n");
return resultado;
}
if (bumount() == -1) {
printf("ERROR: mi_mkdir => main =>Error al desmontar(bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
return (EXIT_SUCCESS);
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="simulacion"; nombre del main
argv[1]=disco(sistema de ficheros) se ha de llamar disco.imagen
*/
if (argc != 2) {
printf("ERROR: simulacion => main: Faltan argumentos!!! El número permitido de argumentos son 2. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: simulacion => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
//creamos el directorio de simulación
struct tm *tm;
time_t tiempo = time(NULL);
tm = localtime(&tiempo);
memset(dir_sim, 0, strlen(dir_sim));
sprintf(dir_sim, "/simul_%d%02d%02d%02d%02d%02d/",
tm -> tm_year + 1900,
tm -> tm_mon + 1,
tm -> tm_mday,
tm -> tm_hour,
tm -> tm_min,
tm -> tm_sec);
printf("Creación del directorio de simulacion %s\n", dir_sim);
//mi_creat (ruta, permisos);
if (mi_creat(dir_sim, 7) < 0) {
printf("ERROR: simulacion => main: Error al crear el directorio %s\n", dir_sim);
} else {
//Llamamos al enterrador
signal(SIGCHLD, enterrador);
//Creamos los 100 procesos de escritura
int i;
for (i = 0; i < num_procesos; i++) {
if (fork() == 0) { //quiere decir que hemos podido crear un proceso hijo
escrituras();
exit(0);
}
usleep(200);
}
printf("Se han creado %d procesos\n", i);
//Mientras no hayan acabado todos los procesos, pause();
while (acabados < num_procesos) { //Mientras queden procesos
pause();
}
//verificamos escrituras
verificacion();
if (bumount(argv[1]) == -1) {
printf("ERROR: simulacion => main: Error al cerrar (bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
}
return 0;
}
int proceso (char *directori, int n) {
char linea[MAXLONG];
char nombreFichero[MAXLONG];
struct i_stat estado;
int i;
int k = 0;
time_t temps;
struct tm t;
printf("Comença client: %i", n);
sprintf(nombreFichero, "%s/proceso-%i/prueba.dat", directori, n);
sprintf(linea,"Inicio LOG proceso %i\n", getpid());
mi_creat(nombreFichero);
mi_write(nombreFichero, &linea, k, strlen(linea));
k += strlen(linea);
for(i = 0; i < 100; i++) {
temps = time(NULL);
localtime_r(&temps, &t);
sprintf(linea,"%d:%d:%d Linea numero %i del proceso %i \n", t.tm_hour, t.tm_min, t.tm_sec, i, getpid());
printf("Escriuré: %s \n", linea);
mi_write(nombreFichero, &linea, k, strlen(linea));
k += strlen(linea);
sleep(1000000);
}
sprintf(linea,"Fin LOG proceso %i\n", getpid());
mi_write(nombreFichero, &linea, k, strlen(linea));
// k += strlen(linea);
printf("Client %i ha acabat! \n", n);
}
int main(int argc, char **argv){
if(argc!=4){
printf("Número de argumentos incorrecto \n");
return -1;
}
int tam;
bmount(argv[1]); //Monta disco
unsigned int modo = atoi(argv[3]);
tam = strlen(argv[2]);
if(argv[2][tam-1]!='/'){
if(mi_creat(argv[2], modo)<0){
printf("Error en la creación de archivo \n");
}else{
printf("Archivo creado \n");
}
}else{
printf("Debe introducir un fichero válido \n");
}
bumount(); //Desmonta disco
return 0;
}
int main (int argc, char **argv) {
char *buffer2;
int t_size, i = 0;
char linea[50];
bmount(DISK_NAME);
int k = 0;
time_t temps;
struct tm t;
mi_creat(argv[1]);
for(i = 0; i < 100; i++) {
temps = time(NULL);
localtime_r(&temps, &t);
sprintf(linea,"%d:%d:%d Linea numero %i del proceso %i \n", t.tm_hour, t.tm_min, t.tm_sec, i, getpid());
printf("Escriuré: %s \n", linea);
mi_write(argv[1], &linea, k, strlen(linea));
k += strlen(linea);
}
bumount(DISK_NAME);
return 0;
}
int main(int argc, char** argv) {
if (argc != 2) {
printf("simulación: Número de argumentos incorrecto!\n");
return -1;
}
bmount(argv[1]);
char dir_sim[60];
char nomdir[60];
char nomfich[60];
char tiempo[60];
int posMax = 500000; //posMax = (((12+256+256²+256³)-1)*BLOCKSIZE)/sizeof(struct registro);
struct tm *miTM;
struct registro miRegistro;
iniTM(miTM, tiempo);
sprintf(dir_sim, "/simul_%s/", tiempo);
if (mi_creat(dir_sim, '7') < 0) {
bumount();
return -1;
}
signal(SIGCHLD, enterrador);
int x, i;
for (x = 0; x < numProc; x++) {
switch (fork()) {
// Proceso hijo.
case 0:
sprintf(nomdir, "%sproceso_%d/", dir_sim, getpid());
if (mi_creat(nomdir, '7') < 0) {
puts("simulación: error!\n");
return -1;
} else {
sprintf(nomfich, "%sprueba.dat", nomdir);
if (mi_creat(nomfich, '7') < 0) {
return -1;
}
}
// Actualizamos semilla de números aleatorios.
srand(time(NULL) + getpid());
for (i = 0; i < numEscr; i++) {
miRegistro.fecha = time(NULL);
miRegistro.pid = getpid();
miRegistro.nEscritura = i + 1;
miRegistro.posicion = rand() % posMax;
mi_write(nomfich, &miRegistro, miRegistro.posicion * sizeof (struct registro), sizeof (struct registro));
usleep(50000);
}
printf("\nProceso %d: He acabado.\n", getpid());
exit(0);
break;
default:
NULL;
break;
}
usleep(200000);
}
while (acabados != numProc) {
pause();
}
printf("\nProcesos totales: %d\n", acabados);
verificacion(dir_sim, acabados);
bumount();
}
int proceso (int n) {
char nombre[N_LINEA];
memset(nombre, '\0', N_LINEA);
char linea[N_LINEA];
memset(linea, '\0', N_LINEA);
sprintf(nombre,"/proceso-%d.dat",n);
printf("%s\n", nombre);
if (mi_creat(nombre) < 0) {
printf("ERROR (simulacion.c): Error al ejecutar mi_creat(%s).\n", nombre);
return (-1);
}
else {
sprintf(linea, "Inicio log proceso PID %d\n", getpid());
printf("Fichero <<%s>> creado! // %d // %s ", nombre, strlen(linea), linea);
if (mi_write(nombre, linea, 0, strlen(linea)) < 0) {
char buffer[10000];
memset(buffer, '\0', 10000);
mi_dir("/", buffer);
printf("%s", buffer);
printf("ERROR (simulacion.c): Error al ejecutar mi_write(%s, &s, 0, %d).\n", nombre, linea, strlen(linea));
return (-1);
}
/* Para imprir la hora */
struct tm *p_tiempo;
time_t tiempo;
struct STAT estado;
int i;
for (i = 0; i < N_LOGS; i++) {
tiempo = time(NULL);
p_tiempo = localtime(&tiempo);
sprintf(linea, " %d:%d:%d Línea número %d\n", p_tiempo->tm_hour, p_tiempo->tm_min, p_tiempo->tm_sec, i);
if (mi_stat(nombre, &estado) < 0) {
printf("ERROR (simulacion.c): Error al ejecutar mi_stat(%s, &estado) 1.\n", nombre);
return (-1);
}
else {
if (mi_write(nombre, linea, estado.t_bytes, strlen(linea)) < 0) {
printf("ERROR (simulacion.c): Error al ejecutar mi_write(%s, linea, %d, %d) 1.\n", nombre, estado.t_bytes, strlen(linea));
return (-1);
}
}
usleep(100000); /* Cada línea debe esperar 0,1 segundos */
}
sprintf(linea, "Fin log proceso PID %d\n", getpid());
printf("%s\n", linea);
if (mi_stat(nombre, &estado) < 0) {
printf("ERROR (simulacion.c): Error al ejecutar mi_stat(%s, &estado) 2.\n", nombre);
return (-1);
}
else {
if (mi_write(nombre, linea, estado.t_bytes, strlen(linea)) < 0) {
printf("ERROR (simulacion.c): Error al ejecutar mi_write(%s, %s, %d, %d) 2.\n", nombre, linea, estado.t_bytes, strlen(linea));
return (-1);
}
}
}
return (1);
}
int verificacion() {
printf("\n--------------------Inicio verificación--------------------------\n");
struct entrada ent;
struct STAT stSim, stPrueba;
struct registro reg, menor_pos, mayor_pos, primera_esc, ultima_esc; // mas_reciente,menos_reciente ;
int pid, numEntradasSim;
mi_stat(dir_sim, &stSim); //leemos la informacion del directorio de simulacion
numEntradasSim = stSim.nlinks; //calculamos las entradas del directorio de simulacion
//directorio del proceso
char d_proc[60];
//directorio de información del proceso
char dir_info[60];
//fichero de información del proceso
char info_txt[1024];
char buffer[256];
//Creamos el fichero de información
memset(info_txt, 0, strlen(info_txt));
memset(dir_info, 0, strlen(dir_info));
sprintf(dir_info, "/informe.txt"); //sprintf(dir_info,"%s/informe.txt",dir_sim);
//mi_creat (ruta, permisos);
if (mi_creat(dir_info, 7) < 0) {
printf("ERROR: simulacion => verificación: Error al crear el directorio %s\n", dir_info);
}
//para cada entrada del directorio de simulacion
int k;
for (k = 0; k < numEntradasSim; k++) {
mi_read(dir_sim, &ent, k * sizeof (struct entrada), sizeof (struct entrada)); //lee la entrada k del directorio
memset(d_proc, 0, strlen(d_proc));
sprintf(d_proc, "%s%s/prueba.dat", dir_sim, ent.nombre);
pid = atoi(strchr(ent.nombre, '_') + 1); //extraemos el pid
printf("Verificando %s...\n", ent.nombre);
//Buscamos el primer registro
mi_stat(d_proc, &stPrueba);
int numRegPrueba = stPrueba.tamEnBytesLog / sizeof (reg); //registros que caben en prueba.dat
int indiceReg = 0;
int regValidos = 0;
int progreso = 0;
int porcentaje = 0;
//leemos todos los registros de pruebas.dat
while (indiceReg < numRegPrueba) {
mi_read(d_proc, ®, indiceReg * sizeof (struct registro), sizeof (struct registro));
if (reg.pid == pid) {
regValidos++;
if (regValidos == 1) {//como es el primero valido inicializamos todas las variables con este registro
memcpy(&primera_esc, ®, sizeof (reg));
memcpy(&ultima_esc, ®, sizeof (reg));
memcpy(&mayor_pos, ®, sizeof (reg));
memcpy(&menor_pos, ®, sizeof (reg));
} else {
//Comparar la fecha, nº escritura y posición de los registros.
if (reg.posicion < menor_pos.posicion) {
memcpy(&menor_pos, ®, sizeof (reg)); //printf("cambiado menor posicion\n");
}
if (reg.posicion > mayor_pos.posicion) {
memcpy(&mayor_pos, ®, sizeof (reg)); //printf("cambiado mayor posicion\n");
}
if (reg.nEscritura > ultima_esc.nEscritura) {
memcpy(&ultima_esc, ®, sizeof (reg)); //printf("cambiado ultima escritura\n");
}
if (reg.nEscritura < primera_esc.nEscritura) {
memcpy(&primera_esc, ®, sizeof (reg)); //printf("cambiado primera escritura\n");
}
}
}
indiceReg++;
}
printf("%s [VERIFICADO]\n", ent.nombre);
num_verificados++;
printf("Se han verificado el %d%% de los procesos\n", num_verificados);
//Finalmente pasamos a escribir en un fichero de texto (informe.txt)
info_txt[0] = 0;
sprintf(buffer, "####### INFORMACIÓN DEL PROCESO %i #######\n\n", pid); //getpid
strcat(info_txt, buffer);
sprintf(buffer,
"%i - Primera escritura:\tfecha: %s\t\t\t\tnúmero de escritura: %i\n\t\t\t\tnúmero de registro: %i\n\n\n",
primera_esc.pid, asctime(localtime(&primera_esc.fecha)), primera_esc.nEscritura, primera_esc.posicion);
strcat(info_txt, buffer);
sprintf(buffer,
"%i - Última escritura:\tfecha: %s \t\t\t\tnúmero de escritura: %i\n\t\t\t\tnúmero de registro: %i\n\n\n",
ultima_esc.pid, asctime(localtime(&ultima_esc.fecha)), ultima_esc.nEscritura, ultima_esc.posicion);
strcat(info_txt, buffer);
sprintf(buffer,
"%i - Primera posición:\tfecha: %s \t\t\t\tnúmero de escritura: %i\n\t\t\t\tnúmero de registro: %i\n\n\n",
menor_pos.pid, asctime(localtime(&menor_pos.fecha)), menor_pos.nEscritura, menor_pos.posicion);
strcat(info_txt, buffer);
sprintf(buffer,
"%i - Última posición:\tfecha: %s \t\t\t\tnúmero de escritura: %i\n\t\t\t\tnúmero de registro: %i\n\n\n",
mayor_pos.pid, asctime(localtime(&mayor_pos.fecha)), mayor_pos.nEscritura, mayor_pos.posicion);
strcat(info_txt, buffer);
mi_stat(dir_info, &stSim);
mi_write(dir_info, (const void *) info_txt, stSim.tamEnBytesLog, strlen(info_txt) + 1);
}
return 1;
}
