Esempio n. 1
0
void write_inode(unsigned int inumber, const struct inode_s* inode) {
	unsigned char buffer[SECTOR_SIZE];

	PRINT_ASSERT_ERROR_MSG(inumber != BLOC_NULL, "Null inode (write_inode)");
	memcpy(buffer, inode, sizeof(struct inode_s));
	write_bloc(current_vol, inumber, buffer);
}
Esempio n. 2
0
/*initialize a new bloc with all 0 inside*/
unsigned new_bloc_zero(){
    int res;
    unsigned char buf[SECTORSIZE] = {0};
    res=new_bloc();
    write_bloc(CURRENT_VOLUME, res, buf);
    return res;
}
Esempio n. 3
0
/*
 * @brief Gestion du .blk lors de l'ajout d'un couple key/val
 *
 * Si un index de bloc existe déjà :
 *  -> écriture de offset_key dans ce bloc (avec gestion de bloc plein)
 * Sinon :
 * -> création d'un nouveau bloc et écriture de l'index de ce bloc dans le .h
 * -> écriture de offset_key dans ce bloc (avec gestion de bloc plein)
 *
 * @param kv descripteur d'accès à la base
 * @param key clé
 * @param offset_key index du couple dans le .kv
 */
int kv_put_blk(KV *kv, const kv_datum *key, len_t *offset_key)
{
    len_t val_h, offset_h;

    int offset_int = hash(key->ptr, kv);

    if(offset_int == -1)
    {
        return -1;
    }
    else
    {
        offset_h = offset_int;
    }

    int n = read_h(kv, offset_h, &val_h);

    if(n == -1) {
        return -1;
    }

    if(!n || val_h == 0) // clé pas hachée
    {
        len_t offset_new_bloc;

        if(new_bloc(kv, &offset_new_bloc) == -1) {
            return -1;
        }
        if(write_h(kv, offset_h, offset_new_bloc) == -1) {
            return -1;
        }
        if(write_bloc(kv, offset_new_bloc, offset_key) == -1) {
            return -1;
        }
    }
    else // clé déjà hachée
    {
        if(write_bloc(kv, val_h, offset_key) == -1) {
            return -1;
        }
    }

    return 42;
}
Esempio n. 4
0
File: inode.c Progetto: Levrifon/ASE
unsigned initialize_bloc(unsigned address){
	int new_bloc[NBPB];	
	int i;
	
	read_bloc(current_volume, address, (unsigned char*)new_bloc);
	for (i = 0; i < NBPB; i++){
		new_bloc[i] = 0;
	}
	write_bloc(current_volume, address, (unsigned char*)new_bloc);
	return address;
}
Esempio n. 5
0
/*
 * @brief Détermine le bon bloc
 *
 * @param kv descripteur d'accès à la base
 * @param offset_bloc index dans le .blk
 * @param offset_data index dans le .kv (à écrire)
 */
int write_bloc(KV *kv, len_t offset_bloc, len_t * offset_data)
{
    len_t offset_lu_courant, offset_courant, offset_bloc_suivant, offset_sauvegarde = offset_bloc;

    int i;
    off_t off;

    while(offset_bloc)
    {
        read_entete_bloc(kv, offset_bloc, &offset_bloc_suivant); // ce qui déplace juste apres l'en-tête du bon bloc

        for(i = 0; i < 1023; i++)
        {
            off = lseek(kv->fd2, 0, SEEK_CUR);

            if(off == -1) {
                return -1;
            }

            offset_courant = off;

            read(kv->fd2, &offset_lu_courant, 4);

            if(offset_lu_courant == 0)
            {
                write_bloc_entry(kv, offset_courant, *offset_data);
                return 42;
            }
        }

        offset_bloc = offset_bloc_suivant;
    }

    // pas de bloc suivant et plus de place dans le bloc courant

    len_t offset_new_bloc;

    if(new_bloc(kv, &offset_new_bloc)) {
        return -1;
    }

    if(write_bloc_entry(kv, offset_sauvegarde, offset_new_bloc)) {
        return -1;
    }; // lien entre les 2 blocs inverser les 2 ?

    if(write_bloc(kv, offset_new_bloc, offset_data)) {
        return -1;
    };

    return 42;
}
Esempio n. 6
0
File: bloc.c Progetto: DherJ/Master1
void free_bloc(unsigned int bloc) {
	if(bloc==0){
		printf("Impossible de libérer le bloc : bloc inexistant\n");
		return;
	}
	struct freeBloc_s freeB;
	unsigned char buffer[HDA_SECTORSIZE];
	freeB.freebloc_nb_free = 1;
	freeB.freebloc_next = current_super.super_first_free_bloc;
	current_super.super_first_free_bloc = bloc;
	current_super.super_nb_free++;
	memset(buffer, 0, HDA_SECTORSIZE);
	memcpy(buffer, &freeB, sizeof(struct freeBloc_s));
	write_bloc(current_vol, bloc, buffer);
	save_super();
}
Esempio n. 7
0
/* note that flush don't need to worry about the bloc allocation; a
   previous write operation has already done it. */ 
void
flush_ifile(file_desc_t *fd)
{
    unsigned int fbloc; /* bloc index in the file */
    unsigned int vbloc; /* bloc index in the volume */

    if (fd-> fds_dirty) {
	/* compute the number of the bloc on the volume associated to
	   the buffer */ 
	fbloc = bloc_of_pos(fd->fds_pos);
	vbloc = vbloc_of_fbloc(fd-> fds_inumber, fbloc, TRUE);

	/* write back the buffer */
	write_bloc(current_volume, vbloc, fd->fds_buf);

	/* done */
	fd-> fds_dirty = FALSE ; 
    }
}
Esempio n. 8
0
/* return the  pos in the file ; RETURN_FAILURE in case of error */
int
writec_ifile(file_desc_t *fd, char c)
{
    unsigned int ibloc;

    /* write the char in the buffer */
    fd->fds_buf[ibloc_of_pos(fd->fds_pos)] = c;

    /* first write in the bloc ? ensure the data bloc allocation */
    if (! fd->fds_dirty) {
        ibloc = vbloc_of_fbloc(fd->fds_inumber, bloc_of_pos(fd->fds_pos), TRUE);
        if (! ibloc) {
            return RETURN_FAILURE;
        }
        fd->fds_dirty = TRUE;
    }

    /* is the buffer full? */
    if (ibloc_of_pos(fd->fds_pos) == BLOC_SIZE-1) {
        /* write the buffer */
        ibloc = vbloc_of_fbloc(fd->fds_inumber, bloc_of_pos(fd->fds_pos), FALSE);
        write_bloc(current_vol, ibloc, fd->fds_buf);
        /* read the new buffer */
        ibloc = vbloc_of_fbloc(fd->fds_inumber,
                               bloc_of_pos(fd->fds_pos+1), FALSE);
        if (! ibloc)
            memset(fd->fds_buf, 0, BLOC_SIZE);
        else
            read_bloc(current_vol, ibloc, fd->fds_buf);
        fd->fds_dirty = FALSE;
    }

    /* update the file cursor and size */
    if (fd->fds_size < fd->fds_pos)
        fd->fds_size = fd->fds_pos;
    fd->fds_pos++;

    /* the position of the written char */
    return fd->fds_pos - 1;
}
Esempio n. 9
0
File: bloc.c Progetto: DherJ/Master1
void init_super(unsigned int vol)
{
	printf("Initialisation du superbloc du volume ...\n");	
	struct volume_s volume;
	struct freeBloc_s fb;
	unsigned char buffer[HDA_SECTORSIZE];
	//load_mbr();
	volume = mbr.disque[vol];
	current_super.super_magic = SUPER_MAGIC;
	current_super.super_first_free_bloc = 1;
	current_super.super_nb_free = volume.size - 1;
	//strncpy(current_super.super_name, nom, 32);
	fb.freebloc_nb_free=volume.size - 1;
	fb.freebloc_next=0;			
	save_super();
	memset(buffer, 0, HDA_SECTORSIZE);
	memcpy(buffer, &fb, sizeof(struct freeBloc_s));
	write_bloc(vol, 1, buffer);
	current_vol=vol;
	printf("Initialisation du superbloc du volume terminé\n");	
	
}
Esempio n. 10
0
File: bloc.c Progetto: DherJ/Master1
unsigned int new_bloc(){
	struct freeBloc_s *fb;
	unsigned char buffer[HDA_SECTORSIZE];
	unsigned res;
	if(current_super.super_nb_free==0)
		return 0;
	assert(current_super.super_first_free_bloc);
	read_bloc(current_vol, current_super.super_first_free_bloc, buffer);
	fb = (struct freeBloc_s*) buffer;
	res = current_super.super_first_free_bloc;
	if(fb->freebloc_nb_free > 1){
		current_super.super_nb_free --;
		fb->freebloc_nb_free--;
		write_bloc(current_vol, current_super.super_first_free_bloc, buffer);
	}
	else
	{
		current_super.super_first_free_bloc = fb->freebloc_next;
	}
	//current_super.super_first_free_bloc--;
	save_super();
	return res;
}	
Esempio n. 11
0
File: inode.c Progetto: Levrifon/ASE
// Recopié depuis le cahier, les noms sont pas forcément les bons
unsigned int vbloc_of_fbloc(unsigned int inumber, unsigned int fbloc,bool_t do_allocate){
	struct inode_s inode;
	unsigned int bloc_index = fbloc;
	read_inode(inumber, &inode);

	//direct
	if (bloc_index < NDIRECT){
		if (inode.direct[bloc_index] == 0){
			if(do_allocate){
				inode.direct[bloc_index] = initialize_bloc(new_bloc());
				write_inode(inumber,&inode);
			}else{return BLOC_NULL;}
		}
		return inode.direct[bloc_index];
	}
	bloc_index -= NDIRECT;

	//indirect simple
	if (bloc_index < NBPB){
		// if the indirect entry in the inode is not allocated yet
		if (inode.direct == 0){
			if(do_allocate){
				inode.indirect = initialize_bloc(new_bloc());;
				write_inode(inumber,&inode);
			}else{return BLOC_NULL;}
		}
		
		int indirect[NBPB];	
		read_bloc(current_volume, inode.indirect, (unsigned char *)indirect);
		
		if (indirect[bloc_index] == 0){
			if(do_allocate){
				indirect[bloc_index] = initialize_bloc(new_bloc());;
				write_bloc(current_volume, inode.indirect, (unsigned char*)indirect);
			}else{return BLOC_NULL;}
		}
		return indirect[bloc_index];
	}
	
	bloc_index -= NBPB;
	
	//indirect double
	if(bloc_index < NBPB*NBPB){
		if (inode.two_indirect == 0){
			if(do_allocate){
				inode.two_indirect = initialize_bloc(new_bloc());;
				write_inode(inumber,&inode);
			}else{return BLOC_NULL;}
		}	
		int db_indirect_index = bloc_index / NBPB;
		int indirect_index = bloc_index % NBPB; 				
		int db_indirect[NBPB];
		read_bloc(current_volume, inode.two_indirect, (unsigned char*)db_indirect);
		
		if (db_indirect[db_indirect_index] == 0){
			if(do_allocate){
				db_indirect[db_indirect_index] = initialize_bloc(new_bloc());
				write_bloc(current_volume, inode.two_indirect, (unsigned char*)db_indirect);
			}else{return BLOC_NULL;}
		}
		
		int indirect[NBPB];	
		read_bloc(current_volume, db_indirect[db_indirect_index], (unsigned char*)indirect);
		
		if (indirect[indirect_index] == 0){
			if(do_allocate){
				//printf("allocate indirect[%d]\n",indirect_index);
				indirect[indirect_index] = initialize_bloc(new_bloc());;
				write_bloc(current_volume, db_indirect[db_indirect_index], (unsigned char*)indirect);
			}else{return BLOC_NULL;}
		}
		return indirect[indirect_index]; 		
	}
	
	//fprintf(stderr,"fbloc is too big.\n\tfbloc provided: %d\n\tfbloc max size: %d",fbloc, NDIRECT+NBPB+NBPB*NBPB);
	return -1;
}
Esempio n. 12
0
File: inode.c Progetto: Levrifon/ASE
void write_inode (unsigned int inumber, const struct inode_s *inode) {
	assert(BLOC_SIZE == sizeof(struct inode_s));
	write_bloc(current_volume, inumber, (unsigned char *)inode);
}
Esempio n. 13
0
File: bloc.c Progetto: DherJ/Master1
void save_super(){
	unsigned char buffer[HDA_SECTORSIZE];
	memset(buffer, 0, HDA_SECTORSIZE);
	memcpy(buffer, &current_super, sizeof(struct superBloc_s));
	write_bloc(current_vol, 0, buffer);
}
Esempio n. 14
0
unsigned int vbloc_of_fbloc(unsigned int inumber, unsigned int fbloc, bool_t do_allocate) {
	struct inode_s inode;
	unsigned int buffer_indirect[SECTOR_SIZE];
	unsigned int buffer_indirect2[SECTOR_SIZE];

	PRINT_ASSERT_ERROR_MSG(inumber != BLOC_NULL, "Null inode (vbloc_of_fbloc)");

	read_inode(inumber, &inode);

	if(fbloc < NB_DIRECT_BLOC) { /* Direct */
		if(inode.inode_direct_bloc[fbloc] == BLOC_NULL) {
			if(do_allocate) {
				inode.inode_direct_bloc[fbloc] = new_bloc();
				write_inode(inumber, &inode);
			}
			else {
				return BLOC_NULL;
			}
		}
		return inode.inode_direct_bloc[fbloc];



	}
	else if(fbloc < NB_INDIRECT_BLOC + NB_DIRECT_BLOC) { /* Indirect 1 */

		fbloc -= NB_DIRECT_BLOC;

		unsigned int vbloc;

		/* Level 0 */
		if(inode.inode_indirect_1 == BLOC_NULL) {
			if(do_allocate) {
				inode.inode_indirect_1 = new_bloc();
				if(inode.inode_indirect_1 == BLOC_NULL) {
					return BLOC_NULL;
				}
				/* set 0 to new bloc */
				memset(buffer_indirect, 0, SECTOR_SIZE);
				write_bloc(current_vol, inode.inode_indirect_1, (unsigned char*)buffer_indirect);

				write_inode(inumber, &inode);
			}
			else {
				return BLOC_NULL;
			}
		}


		/* Level 1 */
		read_bloc(current_vol, inode.inode_indirect_1, (unsigned char*)buffer_indirect);

		vbloc = buffer_indirect[fbloc];

		if(vbloc == BLOC_NULL) {
			if(do_allocate) {
				buffer_indirect[fbloc] = new_bloc();
				if(buffer_indirect[fbloc] == BLOC_NULL) {
					return BLOC_NULL;
				}
				write_bloc(current_vol, inode.inode_indirect_1, (unsigned char*)buffer_indirect);
				vbloc = buffer_indirect[fbloc];
			}
			else {
				return BLOC_NULL;
			}
		}
		return vbloc;
	}
	else if (fbloc < NB_INDIRECT_BLOC + NB_DIRECT_BLOC + NB_INDIRECT_BLOC*NB_INDIRECT_BLOC) { /* Indirect 2 */

		unsigned int vbloc_1, vbloc_2;

		fbloc -= NB_DIRECT_BLOC+NB_INDIRECT_BLOC;

		/* Level 0 */
		if(inode.inode_indirect_2 == BLOC_NULL) {
			if(do_allocate) {
				inode.inode_indirect_2 = new_bloc();
				if(inode.inode_indirect_2 == BLOC_NULL) {
					return BLOC_NULL;
				}
				/* set 0 to new bloc */
				memset(buffer_indirect, 0, SECTOR_SIZE);
				write_bloc(current_vol, inode.inode_indirect_2, (unsigned char*)buffer_indirect);

				write_inode(inumber, &inode);
			}
			else {
				return BLOC_NULL;
			}
		}

		/* Level 1 */
		read_bloc(current_vol, inode.inode_indirect_2, (unsigned char*)buffer_indirect);

		vbloc_1 = buffer_indirect[fbloc/NB_INDIRECT_BLOC];

		if(vbloc_1 == BLOC_NULL) {
			if(do_allocate) {
				buffer_indirect[fbloc/NB_INDIRECT_BLOC] = new_bloc();
				if(buffer_indirect[fbloc/NB_INDIRECT_BLOC] == BLOC_NULL) {
					return BLOC_NULL;
				};
				/* set 0 to new bloc */
				memset(buffer_indirect2, 0, SECTOR_SIZE);
				write_bloc(current_vol, buffer_indirect[fbloc/NB_INDIRECT_BLOC], (unsigned char*)buffer_indirect2);

				write_bloc(current_vol, inode.inode_indirect_2, (unsigned char*)buffer_indirect);

				vbloc_1 = buffer_indirect[fbloc/NB_INDIRECT_BLOC];
			}
			else {
				return BLOC_NULL;
			}
		}

		/* Level 2 */
		read_bloc(current_vol, vbloc_1, (unsigned char*)buffer_indirect);

		vbloc_2 = buffer_indirect[fbloc%NB_INDIRECT_BLOC];

		if(vbloc_2 == BLOC_NULL) {
			if(do_allocate) {
				buffer_indirect[fbloc%NB_INDIRECT_BLOC] = new_bloc();
				if(buffer_indirect[fbloc%NB_INDIRECT_BLOC] == BLOC_NULL) {
					return BLOC_NULL;
				}
				write_bloc(current_vol, vbloc_1, (unsigned char*)buffer_indirect);
				vbloc_2 = buffer_indirect[fbloc%NB_INDIRECT_BLOC];
			}
			else {
				return BLOC_NULL;
			}
		}
		return vbloc_2;
	}
	else
		return BLOC_NULL;
}