Esempio n. 1
0
// Superbloc
void init_super(uint vol, char *nom) {
    // read_bloc_n(vol, 0, (uchar *) &superbloc, sizeof(struct superbloc_s));
    load_super(vol);
    if(superbloc.magic == MAGIC_SUPERBLOC){
        printf("Wait, superbloc already initialized :)\n");
        exit(EXIT_FAILURE);
    }
    
    else {
        superbloc.magic = MAGIC_SUPERBLOC;
        strcpy(superbloc.nom, nom);
        superbloc.first_free_bloc = 1;
        superbloc.root = 0;
        superbloc.nb_free = mbr.vol[vol].nb_bloc-1;
        int i = 0;
        for(i = 1; i<mbr.vol[vol].nb_bloc; i++) {
            struct free_bloc_s fb;
            if(i == mbr.vol[vol].nb_bloc-1)
                fb.next_free_bloc = 0;
            else fb.next_free_bloc = i+1;
                
            write_bloc_n(vol, i, (uchar *) &fb, sizeof(struct free_bloc_s));
        }
        save_super();
    }
}
Esempio n. 2
0
void
umount()
{
    /* save current volume super bloc */
    save_super();

    /* bye */
}
Esempio n. 3
0
int main(int argc, char **argv) {
    
    uint volume;
    init_hard();
    
    
    if(argc < 2){
        printf("exe: ./create_bloc volume\n");
        printf("On which volume: ");
        scanf("%d", &volume);
    } else {
        volume = atoi(argv[1]);
    }
    
    assert(volume < MAX_VOL);
    
    if(load_mbr() == 1){
        printf("Okay, partition ready to be use\n");
    } else {
        printf("Partition not initialized.. Now it is !");
    }
    
    info_on_volume_to_display(volume);
    
    if(load_super(volume) == 1){
        printf("Okay, superbloc of volume n°%d loaded\n", volume);
    } else {
        printf("Superbloc not initialized.. :(\n");
    }
    
    while (superbloc.nb_free != 0) {
        printf("New bloc: %d\n", new_bloc());
    }
    
    printf("There is no more freebloc available... :(\n");
    
    
    while (mbr.vol[volume].nb_bloc-1 != superbloc.nb_free) {
        printf("free_bloc(%d)\n", (mbr.vol[volume].nb_bloc-1) - superbloc.nb_free);
        free_bloc((mbr.vol[volume].nb_bloc-1) - superbloc.nb_free);
    }
    
    save_super();
    save_mbr();
    
    printf("All blocs are now available and free. :)\n");
    
    info_on_volume_to_display(volume);
    
    return 0;
}
Esempio n. 4
0
File: vol.c Progetto: dtbinh/m1s1
/*    ^
*    / \
*   / | \
*  /  |  \
* /___°___\
*
*
* Attention, il n'y a pas de verification, on peut free deux fois le même block, augmentant la taille libre et modifiant notre liste chaîné.
*/
void free_block(int vol, unsigned int block){
  struct free_block_s fb;
  fb.next = super_block.first_free;

  write_n_block(vol, block, sizeof(struct free_block_s), (unsigned char*)&fb);

  super_block.first_free = block;
  
  super_block.free_size++;

  save_super(vol);



}
Esempio n. 5
0
File: vol.c Progetto: dtbinh/m1s1
unsigned int new_block(int vol){
  int retValue = super_block.first_free;
  struct free_block_s fb;

  if ( super_block.free_size == 0 ){
    return BLOCK_NULL;
  }

  read_n_block(vol, retValue, sizeof(struct free_block_s), (unsigned char*)&fb);
  super_block.first_free = fb.next;

  super_block.free_size--;
  save_super(vol);
  return retValue; 
}
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
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. 8
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. 9
0
File: mknfs.c Progetto: Levrifon/ASE
int main(){
	int vol;
	int nom;
	int nbblocs;
	int i;
	unsigned int test_serial = 0xDEADBEEF;
        init_drive();
	read_mbr();
	dump_vols();

	printf("Saisir le numero du volume:\n");
	scanf("%i", &vol);
	while (mbr.mbr_vol[vol].vol_nblocs == 0){
		printf("Veuillez saisir un  numero de volume valide:\n");
		scanf("%i", &vol);
	}
	printf("Saisir le nom:\n");
	scanf("%i", &nom);
	init_super(vol, nom, test_serial);

	printf("Saisir le nombre de blocs:\n");
	scanf("%i", &nbblocs);

	for (i=0; i<nbblocs; i++){
		new_bloc();
	}

	save_super();
	if (nbblocs > mbr.mbr_vol[vol].vol_nblocs-1){
		nbblocs = mbr.mbr_vol[vol].vol_nblocs-1;
	}
	printf("Superbloc rempli de %d blocs !\n", nbblocs);
	printf("Taux d'occupation : %f/100\n", used_percents(vol));

	return 0;
}
Esempio n. 10
0
File: mkvol.c Progetto: dtbinh/m1s1
int main(int argc, char** argv){
  int v, first_cylinder, first_sector, n_block;
  unsigned int i;


  /* init hardware */
  if(init_hardware("hardware.ini") == 0) {
    fprintf(stderr, "Error in hardware initialization\n");
    exit(EXIT_FAILURE);
  }

  /* Interreupt handlers */
  for(i=0; i<16; i++) {
    IRQVECTOR[i] = empty_it;
  }

  /* Allows all IT */
  _mask(1);


  if ( argc < 5 ){
    printf("Usage : mkvol vol_name first_cylinder first_sector nb_block [-tother, -tannexe]\n");
    return EXIT_FAILURE;
  }

  first_cylinder = atoi(argv[2]);
  first_sector = atoi(argv[3]);
  n_block = atoi(argv[4]);

  if ( atoi(argv[2])==0 && atoi(argv[3])==0 ){
    printf("Cannot create volume at Master Boot Record position.\n");
    return EXIT_FAILURE;
  }


   printf("Loading Master Boot Record...\n");
  load_mbr();

  if ( mbr.n_vol >= MAX_VOL ){
    printf("Hard drive already has 8 volumes, please delete at least one volume before creating new one.\n");
    return EXIT_FAILURE;
  }

  first_cylinder = atoi(argv[2]);

  check_before_create(atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));

  v = mbr.n_vol;
  mbr.vol[v].first_cylinder = first_cylinder;
  mbr.vol[v].first_sector = first_sector;
  mbr.vol[v].n_block = n_block;

  printf("Creating volume %d...\n", v);
  mbr.vol[v].type = BASE;
  if ( argc == 5 ){
    if ( strcmp(argv[4], "-tother") == 0){
      mbr.vol[v].type = OTHER;
    }
    if ( strcmp(argv[4], "-tannexe") == 0){
      mbr.vol[v].type = ANNEXE;
    }
  }


  srand((unsigned)time(NULL));
  init_super(v, argv[1], rand(), n_block);


  mbr.n_vol++;
  save_mbr();
  save_super(v);

  printf("Volume %d created.\n", v);
  return EXIT_SUCCESS;
}