int directorio_vacio(char *ruta){
STAT estado;
if(mi_stat(ruta, &estado) < 0){
printf("Directorio no encontrado\n");
return -1;
}
if(estado.tipo != 'd'){
printf("No es directorio\n");
return -1;
}
if(estado.bytesSize == 0) return 1;
return 0;
}
int main(int argc, char **argv) {
if (argc != 3) {
printf("\n\033[31mERROR -> Los argumentos son incorrectos.");
printf("\n\033[31m -> Faltan/sobran argumentos.\n\n");
printf("\033[m"); // Color default.
return -1;
}
bmount(argv[1]);
// Comprobamos que es un fichero.
struct STAT stat;
if (mi_stat(argv[2], &stat)<0){
return -1;
}
if (stat.tipo != 'f') {
printf("\n\033[31mERROR -> No se pudo abrir el fichero.");
printf("\n\033[31m -> El archivo indicado no es un fichero.\n");
printf("\033[m"); // Color default.
bumount();
return -1;
}
char buffer[BLOCKSIZE];
memset(buffer, 0, BLOCKSIZE);
int i = 0;
int leidos = 0;
leidos = mi_read(argv[2], buffer, i, BLOCKSIZE);
//printf("Leidos %d",leidos);
printf("\n\033[32m- Este es el contenido del fichero (%s): \n", argv[2]);
printf("\033[m"); // Color default.
printf("\n");
while (leidos > 0) {
write(1, buffer, leidos);
memset(buffer, 0, BLOCKSIZE);
i++;
leidos = mi_read(argv[2], buffer, i*BLOCKSIZE, BLOCKSIZE);
}
printf("\n\n");
bumount();
return 0;
}
void mi_ls2() {
char *buffer2;
int t_size, i = 0;
struct i_stat e;
t_size = mi_dir("/", &buffer2);
printf("Hi ha %i arxius. \n", t_size/64);
if (t_size > 0) {
for (i = 0; i < t_size; i += 64) {
mi_stat(&buffer2[i], &e);
printf("%s [%i bytes]\t \t ", &buffer2[i], e.i_size);
if (((i/64) % 4) == 3)
printf("\n");
}
}
printf("\n");
}
int main(int argc, char **argv){
unsigned int tam2,n;
unsigned char buf[blocksize];
FILE *salida;
struct STAT p_stat;
memset(buf,'\0',blocksize);
if(argc!=3){ //Comprueba el número de argumentos
printf("Número de argumentos incorrecto \n");
return -1;
}
tam2 = strlen(argv[2]);
if(argv[2][tam2-1]=='/'){ //Comprueba si es un fichero
printf("No es un fichero \n");
return -2;
}
bmount(argv[1]); //Monta el disco
mi_stat(argv[2], &p_stat); //Extrae el tamaño en bytes para recorrer los bloques
for(n=0;(n*blocksize)<p_stat.tamEnBytesLog;n++){ //Recorre los bloques y los escribe en stdout(salida estándar)
if(mi_read(argv[2], buf, (n*blocksize), blocksize)<0){
printf("Error al leer del fichero \n");
return -1;
}else{
salida=fopen("/dev/stdout", "w");
fwrite (buf,1,blocksize,salida);
fclose(salida);
}
}
printf("\n");
bumount(); //Desmonta disco
return 0;
}
int main(int argc, char **argv) {
/*argc = nº de parámetros
argv[0]="mi_rm"; nombre del main
argv[1]=disco(sistema de ficheros)
argv[2]= /ruta
*/
if (argc != 3) {
printf("ERROR: mi_rm => main: Faltan argumentos!!! El número permitido de argumentos son 3. \n");
return (EXIT_FAILURE);
} else {
if (bmount(argv[1]) == -1) {
printf("ERROR: mi_rm => main: Error al abrir (bmount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
char camino[strlen(argv[2])];
strcpy(camino, argv[2]);
struct STAT stat_inodo;
if (mi_stat(argv[2], &stat_inodo) < 0) {
printf("ERROR: mi_rm => main: Error al leer el inodo.\n");
return (EXIT_FAILURE);
}
if (strcmp(camino, "/") == 0) {
printf("No se puede borrar el directorio raíz\n");
} else if ((stat_inodo.tipo == 'd') && (stat_inodo.tamEnBytesLog != 0)) {
printf("No se puede borrar porque el directorio no está vacío.\n");
} else {
mi_unlink(camino);
}
if (bumount() == -1) {
printf("ERROR: mi_ln => main =>Error al desmontar(bumount) el sistema de ficheros.\n");
return (EXIT_FAILURE);
}
}
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
STAT estat;
unsigned char buff[TB];
memset(buff, '\0', TB);
FILE *file;
int lectures = 0;
uint p_inode_dir, p_inode, p_entrada;
p_inode_dir = p_inode = p_entrada = 0;
uint bfisic;
if (argc != 3) {
printf("[mi_cat.c] ERROR: Arguments incorrectes. Ex: mi_cat <nomFS> <cami>\n");
exit(-1);
}
sem_init();
// montam es FS
if (bmount(argv[1]) == -1) {
sem_del();
return -1;
}
// codi
if (cercarEntrada(argv[2], &p_inode_dir, &p_inode, &p_entrada, 0, 7) == -1) {
printf("[mi_cat.c] ERROR: No s'ha trobat l'entrada!\n");
sem_del();
return -1;
}
if (mi_stat(argv[2], &estat) == -1) {
sem_del();
return -1;
}
if (estat.tipus != 1) { // si no es un directori
if (estat.tamany > 0) { // si no esta buit
printf("\n");
int i = 0;
int bf = 0;
while (lectures < estat.blocs_assignats_dades) {
int ret = traduirBlocInode(p_inode, i, &bfisic, 0); // bloc físic
if (ret == -1) {
printf("[mi_cat.c] ERROR: traduirBlocInode()\n");
return -1;
}
if (bfisic > 0) {
if (mi_read(argv[2], buff, (i * TB), TB) == -1) {
printf("[mi_cat.c] ERROR: No s'ha pogut llegir!\n");
sem_del();
return -1;
}
lectures++; // quantitat de blocs llegits
write(1, buff, estat.tamany);
i++;
}
}
printf("\n\n");
} else {
printf("[mi_cat.c] INFO: Aquest fitxer esta buit.\n");
}
} else {
printf("[mi_cat.c] ERROR: No se pot fet un 'mi_cat' sobre un directori!\n");
}
// desmontam es FS
if (bumount() == -1) {
sem_del();
return -1;
}
sem_del();
return 0;
}
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 main(int argc, char **argv){
if(argc != 2){
printf("verificacion.c, 6:Error en els arguments.\n");
printf("L'ús del programa és:\n \t.");
printf("/verificacion [nom_del_dispositiu] \n");
exit(0);
}
if(bmount(argv[1]) == -1){
printf("verificacion.c, 13: Error en obrir el dispositiu: %s.\n", argv[1]);
return -1;
}
unsigned char dirSim[60];
sprintf(dirSim, "/");
struct Entrada en;
mi_read(dirSim, &en, 0, sizeof(struct Entrada));
sprintf(dirSim, "/%s", en.nombre);
struct STAT stat;
mi_stat(dirSim, &stat);
if((stat.tamBytesLogicos / (sizeof(struct Entrada))) != MAX_PROCESOS){
printf("verificacion.c, 28: Error en el nombre de processos.\n");
return -1;
}
int i = 0, j = 0;
int ninodo = en.ninodo;
struct Entrada enAux;
struct STAT statAux;
struct Registro registros[BLOCKSIZE/sizeof(struct Registro)];
unsigned char blanco[sizeof(struct Registro)];
memset(blanco, 0, sizeof(struct Registro));
int BloquesInicial = 0, BloquesFinal;
FILE *f = fopen("informe.txt", "w");
for(i = 0; i < MAX_PROCESOS; i++){
mi_read_f(ninodo, &en, i*(sizeof(struct Entrada)), sizeof(struct Entrada));
mi_read_f(en.ninodo, &enAux, 0, sizeof(struct Entrada));
mi_stat_f(enAux.ninodo, &statAux);
BloquesFinal = statAux.tamBytesLogicos / BLOCKSIZE;
if((statAux.tamBytesLogicos % BLOCKSIZE) != 0) BloquesFinal++;
struct Registro regMayor, regMenor, regPrincipio, regFinal;
regMenor.posFich = UINT_MAX;
regMayor.posFich = 0;
regPrincipio.time = time(NULL);
regFinal.time = time(NULL);
char *p_pid;
p_pid = strchr(en.nombre, '_');
int pidAux = atoi(p_pid+1);
int validados = 0;
for(BloquesInicial = 0; BloquesInicial < BloquesFinal; BloquesInicial++){
mi_read_f(enAux.ninodo, registros, BloquesInicial*BLOCKSIZE, BLOCKSIZE);
for(j = 0; j < (BLOCKSIZE / sizeof(struct Registro)); j++){
if(memcmp(®istros[j], blanco, sizeof(struct Registro)) != 0){
if(pidAux == registros[j].pid){
validados++;
if(registros[j].posFich < regMenor.posFich){
memcpy(®Menor, ®istros[j], sizeof(struct Registro));
}
if(registros[j].posFich > regMayor.posFich){
memcpy(®Mayor, ®istros[j], sizeof(struct Registro));
}
if(registros[j].time < regPrincipio.time){
memcpy(®Principio, ®istros[j], sizeof(struct Registro));
}
if(registros[j].time > regFinal.time){
memcpy(®Final, ®istros[j], sizeof(struct Registro));
}
}
}
}
}
char tiempo[60];
char cadena[500];
struct tm *tm;
sprintf(cadena, "Verificació del procés %i:\n", pidAux);
fputs(cadena, f);
printf("%s", cadena);
sprintf(cadena, "\tNombre de Validacions: %i.\n", validados);
fputs(cadena, f);
printf("%s", cadena);
sprintf(cadena, "\tInformació dels Registres:\n");
fputs(cadena, f);
printf("%s", cadena);
sprintf(cadena, "\t\tPosició menor = %i.\n", regMenor.posFich);
fputs(cadena, f);
printf("%s", cadena);
sprintf(cadena, "\t\tPosició major = %i.\n", regMayor.posFich);
fputs(cadena, f);
printf("%s", cadena);
tm = localtime(®Principio.time);
sprintf(tiempo, "%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);
sprintf(cadena, "\t\tTemps primer = %s\n", tiempo);
fputs(cadena, f);
printf("%s", cadena);
tm = localtime(®Final.time);
sprintf(tiempo, "%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);
sprintf(cadena, "\t\tTemps darrer = %s\n", tiempo);
fputs(cadena, f);
printf("%s", cadena);
}
fclose(f);
}
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;
}
