void do_mkdir() { struct inode cur_dir,new_dir; char dirname[256]; struct dir_ent ent; scanf("%s",dirname); if(strcmp(dirname,".")==0 || strcmp(dirname,"..")==0) { printf("Error directory name.\n"); return ; } get_inode(pwd,&cur_dir); /*分配一个inode给新的目录*/ new_dir.i_num=alloc_inode(); new_dir.i_start_sect=alloc_data(); /*分配一个数据扇区*/ new_dir.i_nr_sects=1; new_dir.i_pnum=pwd; new_dir.i_mode=2; new_dir.i_size=0; //给新目录增加默认目录项 ent.i_num=pwd; strcpy(ent.name,".."); add_entry(&new_dir,&ent); ent.i_num=new_dir.i_num; strcpy(ent.name,"."); add_entry(&new_dir,&ent); ent.i_num=new_dir.i_num; strcpy(ent.name,dirname); add_entry(&cur_dir,&ent); //写入inode数组中 write_inode(pwd,&cur_dir); write_inode(new_dir.i_num,&new_dir); }
static int __logfs_create(struct inode *dir, struct dentry *dentry, struct inode *inode, const char *dest, long destlen) { struct logfs_super *super = logfs_super(dir->i_sb); struct logfs_inode *li = logfs_inode(inode); struct logfs_transaction *ta; int ret; ta = kzalloc(sizeof(*ta), GFP_KERNEL); if (!ta) { inode->i_nlink--; iput(inode); return -ENOMEM; } ta->state = CREATE_1; ta->ino = inode->i_ino; mutex_lock(&super->s_dirop_mutex); logfs_add_transaction(inode, ta); if (dest) { /* symlink */ ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL); if (!ret) ret = write_inode(inode); } else { /* creat/mkdir/mknod */ ret = write_inode(inode); } if (ret) { abort_transaction(inode, ta); li->li_flags |= LOGFS_IF_STILLBORN; /* FIXME: truncate symlink */ inode->i_nlink--; iput(inode); goto out; } ta->state = CREATE_2; logfs_add_transaction(dir, ta); ret = logfs_write_dir(dir, dentry, inode); /* sync directory */ if (!ret) ret = write_inode(dir); if (ret) { logfs_del_transaction(dir, ta); ta->state = CREATE_2; logfs_add_transaction(inode, ta); logfs_remove_inode(inode); iput(inode); goto out; } d_instantiate(dentry, inode); out: mutex_unlock(&super->s_dirop_mutex); return ret; }
int main(int argc, char **argv) { int devfd; // get the device from argv if(argc != 2) { fprintf(stderr, "need to pass in a device\n"); exit(1); } // open device devfd = open_device(argv[1], O_WRONLY); // find if there is enough space -- seek blocks * block size verify_device_space(devfd); // write the superblock write_superblock(devfd); // setup the inodes for / write_inode(devfd, 3, 1); // setup the inode for lost+found write_inode(devfd, 2, 2); // skip into file section // write directories for / ., .. struct rdfs_dirent *p = calloc(3, sizeof(struct rdfs_dirent)); struct rdfs_dirent *dirent = p; p->d_inode = 1; strcpy(p->d_name, "."); p++; p->d_inode = 1; strcpy(p->d_name, ".."); p++; p->d_inode = 2; strcpy(p->d_name, "lost+found"); write_directory(devfd, dirent, 3, 0); free(dirent); // write directories for lost+found ., .. p = calloc(2, sizeof(struct rdfs_dirent)); dirent = p; p->d_inode = 2; strcpy(p->d_name, "."); p++; p->d_inode = 1; strcpy(p->d_name, ".."); write_directory(devfd, dirent, 2, 1); free(dirent); return 0; }
/* 将外部文件写入到镜像中 */ void do_write() { struct stat st; struct inode cur_dir,new_file; struct dir_ent ent; char buf[SECTOR_SIZE+10]; int i; FILE *fin; char filename[16]; scanf("%s",filename); if(stat(filename,&st)<0) { printf("No such file.\n"); return ; } fin=fopen(filename,"rb"); get_inode(pwd,&cur_dir); new_file.i_num=alloc_inode(); new_file.i_pnum=pwd; new_file.i_size=st.st_size; new_file.i_mode=1; //标示为文件 ent.i_num=new_file.i_num; strcpy(ent.name,filename); add_entry(&cur_dir,&ent); u32 last_sector=0,cur_sector; u32 need=st.st_size/(SECTOR_SIZE-sizeof(u32))+1; new_file.i_nr_sects=need; //根据文件大小,逐个分配扇区来写入数据,并采用单链表方式连接各个扇区 for(i=0;i<need;i++) { cur_sector=alloc_data(); if(last_sector==0) { new_file.i_start_sect=cur_sector; }else{ //上一个扇区到这个扇区的指针 fseek(fimg,last_sector*SECTOR_SIZE+SECTOR_SIZE-sizeof(u32),SEEK_SET); fwrite(&cur_sector,sizeof(u32),1,fimg); } int nread=fread(buf,sizeof(char),SECTOR_SIZE-sizeof(u32),fin); if(nread<0) { printf("Read file %s error.\n",filename ); return ; } fseek(fimg,cur_sector*SECTOR_SIZE,SEEK_SET); fwrite(buf,sizeof(char),nread,fimg); last_sector=cur_sector; } fseek(fimg,last_sector*SECTOR_SIZE+SECTOR_SIZE-sizeof(u32),SEEK_SET); u32 tmp=0; fwrite(&tmp,sizeof(u32),1,fimg); write_inode(new_file.i_num,&new_file); write_inode(cur_dir.i_num,&cur_dir); }
long delete_file(ext2_filsys fs, ext2_ino_t inode) { struct ext2_inode inode_buf; long retval; if ((retval = read_inode(fs, inode, &inode_buf))) { fprintf(stderr, "%s\n", error_message(retval)); return(retval); } inode_buf.i_dtime = time(NULL); if ((retval = write_inode(fs, inode, &inode_buf))) { fprintf(stderr, "%s\n", error_message(retval)); return(retval); } if ((retval = ext2fs_block_iterate(fs, inode, 0, NULL, release_blocks_proc, NULL))) { fprintf(stderr, "%s\n", error_message(retval)); return(retval); } ext2fs_inode_alloc_stats(fs, inode, -1); return(0); }
/* * Cross-directory rename, target does not exist. Just a little nasty. * Create a new dentry in the target dir, then remove the old dentry, * all the while taking care to remember our operation in the journal. */ static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { struct logfs_super *super = logfs_super(old_dir->i_sb); struct logfs_disk_dentry dd; struct logfs_transaction *ta; loff_t pos; int err; /* 1. locate source dd */ err = logfs_get_dd(old_dir, old_dentry, &dd, &pos); if (err) return err; ta = kzalloc(sizeof(*ta), GFP_KERNEL); if (!ta) return -ENOMEM; ta->state = CROSS_RENAME_1; ta->dir = old_dir->i_ino; ta->pos = pos; /* 2. write target dd */ mutex_lock(&super->s_dirop_mutex); logfs_add_transaction(new_dir, ta); err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode); if (!err) err = write_inode(new_dir); if (err) { super->s_rename_dir = 0; super->s_rename_pos = 0; abort_transaction(new_dir, ta); goto out; } /* 3. remove source dd */ ta->state = CROSS_RENAME_2; logfs_add_transaction(old_dir, ta); err = logfs_delete_dd(old_dir, pos); if (!err) err = write_inode(old_dir); LOGFS_BUG_ON(err, old_dir->i_sb); out: mutex_unlock(&super->s_dirop_mutex); return err; }
static int logfs_remove_inode(struct inode *inode) { int ret; inode->i_nlink--; ret = write_inode(inode); LOGFS_BUG_ON(ret, inode->i_sb); return ret; }
/** Crea l'enllaç de una entrada de directori del src_path a l'inode espeificic * per la altre entrada de directori link_path. Actualitza la quatitat * d'enllaços d'entrades en el directori de l'inode. Té control de * concurrència. * @src_path: ruta del fitxer a enllaçar * @link_path: ruta de l'enllaç * @return: 0 si correctament. * -1 en cas d'error. */ int emofs_link(const char *src_path, const char *link_path) { int p_dir_src_inode = 0; int p_src_inode = 0; int p_dir_dst_inode = 0; int p_dst_inode = 0; int p_entry = 0; emofs_inode inode; emofs_dir_entry dir_entry; char link_name[MAX_FILENAME_LEN]; char partial_link_path[MAX_PATH_LEN]; if (!mutex){ emofs_sem_get(&mutex); } emofs_sem_wait(mutex); emofs_get_partial_path(link_path, partial_link_path, link_name); /* Comprovam i obtenim informació del primer path */ p_dir_src_inode = 0; if (emofs_find_entry(src_path, \ &p_dir_src_inode, &p_src_inode, &p_entry) == -1) { puts("EmoFS_Link: El fitxer o directori font no existeix"); emofs_sem_signal(mutex); return -1; } /* Comprovam que no estiqui ja creat el fitxer */ p_dir_dst_inode = 0; if (emofs_find_entry(link_path, \ &p_dir_dst_inode, &p_dst_inode, &p_entry) == 0) { puts("EmoFS_Link: El fitxer ja existeix"); emofs_sem_signal(mutex); return -1; } /* Incrementam el numero d'enllaços de l'inode font */ read_inode(p_src_inode, &inode); inode.link_count++; write_inode(p_src_inode, &inode); /* Cream l'entrada de directori de l'enllaç */ dir_entry.inode = p_src_inode; strcpy(dir_entry.name, link_name); /* Anam a escriure l'entrada de directori al direcotri desti */ read_inode(p_dir_dst_inode, &inode); /* Per saber el tamany de fitxer */ if (write_file(p_dir_dst_inode, &dir_entry, \ inode.size, sizeof(emofs_dir_entry)) == -1) { puts("EmoFS_Link: Error d'escriptura"); emofs_sem_signal(mutex); return -1; } emofs_sem_signal(mutex); return 0; }
static int msfs_ftruncate(const char * path, off_t off, struct fuse_file_info * fi) { printf("msfs_ftruncate(%s)\n", path); reset_error(); inode_t inode = read_inode((addr_t)fi->fh); if(msfs_error != 0) return msfs_error; if(!check_access(&inode, O_TRUNC)) return -EPERM; inode.attributes.st_size = (addr_t) off; write_inode(&inode); return msfs_error; }
int main ( int argc, char * argv [] ) { struct gfs_super *super; struct conf conf; int super_len, i; prase_cmdLine(&conf, argv, argc); init_conf(&conf); super_len = init_super(&conf, &super); write_inode(&conf, 0, super, super_len, S_IFREG | 0777); write_inode(&conf, 1, NULL, 0, S_IFDIR | 0777); for( i = 0;i < conf.nblocks; i++) write_inode(&conf, i+2, NULL, 0, 0); printf("Created fs in file %s.\n%ld blocks with bs %d.\nTotal size %ld bytes.\n", conf.fname, conf.nblocks, conf.block_size, conf.nblocks*conf.block_size); return 0; }
int Server_UnLink(int inum,char *name) { int inode_num,i; int dir_inum=inum; int last_slash=-1; struct inode curr_inode; char dir_path[MAXPATHNAMELEN]; if(inum<1||inum>max_inode_num||name==NULL) return ERROR; inode_num=LookUp(name,inum,0); if((inode_num==ERROR)||(inode_num==0)) { printf("\nERROR: Path Not Found!"); return ERROR; } GetInode(inode_num,&curr_inode); if(curr_inode.type==INODE_DIRECTORY) { printf("\nERROR: Cannot Unlink a Directory!"); return ERROR; } for(i=0;i<strlen(name);i++) if(name[i]=='/') last_slash=i; if(last_slash==-1) dir_inum=inum; else if (last_slash==0) dir_inum=ROOTINODE; else { strncpy(dir_path,name,last_slash); dir_path[last_slash]='\0'; dir_inum=LookUp(dir_path,inum,0); } if(curr_inode.nlink>1) { curr_inode.nlink=curr_inode.nlink-1; } /*Else Delete the file inode and all the blocks allocated to it*/ else { truncate_file(&curr_inode); curr_inode.type=INODE_FREE; Add_free_inode(inode_num); } Delete_from_dir(dir_inum,inode_num); write_inode(inode_num,&curr_inode); return 0; }
void sync_inodes(kdev_t dev) { register struct inode *inode = first_inode; do { if (dev && inode->i_dev != dev) continue; wait_on_inode(inode); if (inode->i_dirt) write_inode(inode); } while ((inode = inode->i_prev) != first_inode); }
/* alloue et initialise un bloc et range l'inoeud dedans retourne l'inode correspondant*/ unsigned int create_inode(enum file_type_e type) { int i,inumber; struct inode_s inode; inode.type = type; inode.ind_size = 0; /* inode size */ for(i = 0 ; i < NDIRECT; i++) { inode.direct[i] = 0; } inumber = new_bloc(); if(inumber == 0) { return 0;} /* volume plein */ write_inode(inumber,&inode); /*on alloue le bloc pour y ranger l'inoeud */ return inumber; }
void close_ifile(file_desc_t *fd) { struct inode_s inode; /* if the buffer is dirty, flush the file */ flush_ifile(fd); /* update the inode information (size) */ read_inode(fd->fds_inumber, &inode); inode.ind_size = fd->fds_size; write_inode(fd->fds_inumber, &inode); }
int do_write(int fd, char * buf, int n) { //_Cli(); int inode_number = search_for_fd(fd); //search fd in inode; if (inode_number == -1) { return -1; } iNode * inode = fs_get_inode(inode_number); return write_inode(inode, buf, n); //_Sti(); //return 1; }
unsigned int create_inode(enum file_type_e type) { int i,inumber; struct inode_s inode; inode.type = type; inode.ind_size = 0; inode.taille = 0; for(i = 0 ; i < n ; i++) { inode.inode_direct[i] = 0; } inumber = new_bloc(); if(inumber == 0) { return 0;} /* volume plein */ write_inode(inumber,&inode); return inumber; }
void sync_inodes(kdev_t dev) { register struct inode *inode; register char *pi; inode = first_inode; for (pi = 0; ((int) pi) < nr_inodes * 2; pi++, inode = inode->i_next) { if (dev && inode->i_dev != dev) continue; wait_on_inode(inode); if (inode->i_dirt) write_inode(inode); } }
struct inode *get_empty_inode(void) { static ino_t ino = 0; register struct inode *inode, *best; int i; repeat: inode = first_inode; best = 0; for (inode = inode_block, i = 0; i < nr_inodes; inode++, i++) { if (!inode->i_count && !inode->i_lock && !inode->i_dirt) { best = inode; break; } } if (!best) { printk("VFS: No free inodes - contact somebody other than Linus\n"); list_inode_status(); sleep_on(&inode_wait); goto repeat; } /* Here we are doing the same checks again. There cannot be a significant * * race condition here - no time has passed */ #if 0 if (inode->i_lock) { wait_on_inode(inode); goto repeat; } if (inode->i_dirt) { write_inode(inode); goto repeat; } if (inode->i_count) goto repeat; #endif clear_inode(inode); inode->i_count = inode->i_nlink = 1; #ifdef BLOAT_FS inode->i_version = ++event; #endif inode->i_sem = 0; inode->i_ino = ++ino; inode->i_dev = 0; nr_free_inodes--; if (nr_free_inodes < 0) { printk("VFS: get_empty_inode: bad free inode count.\n"); nr_free_inodes = 0; } return inode; }
static int logfs_unlink(struct inode *dir, struct dentry *dentry) { struct logfs_super *super = logfs_super(dir->i_sb); struct inode *inode = dentry->d_inode; struct logfs_transaction *ta; struct page *page; pgoff_t index; int ret; ta = kzalloc(sizeof(*ta), GFP_KERNEL); if (!ta) return -ENOMEM; ta->state = UNLINK_1; ta->ino = inode->i_ino; inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; page = logfs_get_dd_page(dir, dentry); if (!page) { kfree(ta); return -ENOENT; } if (IS_ERR(page)) { kfree(ta); return PTR_ERR(page); } index = page->index; page_cache_release(page); mutex_lock(&super->s_dirop_mutex); logfs_add_transaction(dir, ta); ret = logfs_delete(dir, index, NULL); if (!ret) ret = write_inode(dir); if (ret) { abort_transaction(dir, ta); printk(KERN_ERR"LOGFS: unable to delete inode\n"); goto out; } ta->state = UNLINK_2; logfs_add_transaction(inode, ta); ret = logfs_remove_inode(inode); out: mutex_unlock(&super->s_dirop_mutex); return ret; }
/** Borra l'entrada de directori especificada y en cas de que sigui l'últim * enllaç existent borra el propi fitxer/directori. Té control de concurrència. * @path: ruta del fitxer/directori * @return: 0 si correctament * -1 en cas d'error. */ int emofs_unlink(const char *path) { int p_inode = 0; int p_dir_inode = 0; int p_entry = 0; emofs_inode inode; emofs_dir_entry *last_dir_entry; if(!mutex){ emofs_sem_get(&mutex); } emofs_sem_wait(mutex); if (emofs_find_entry(path, &p_dir_inode, &p_inode, &p_entry) == -1) { puts("EmoFS_UnLink: El fitxer o directori font no existeix"); emofs_sem_signal(mutex); return -1; } read_inode(p_dir_inode, &inode); /* Borram entrada de directori */ if (inode.size > sizeof(emofs_dir_entry)) { /* Hi ha més entrades posam l'última al lloc de la que volem * borrar. */ read_file(p_dir_inode, (void *)&last_dir_entry, \ inode.size-sizeof(emofs_dir_entry), \ sizeof(emofs_dir_entry)); write_file(p_dir_inode, last_dir_entry, \ p_entry*sizeof(emofs_dir_entry), \ sizeof(emofs_dir_entry)); } free(last_dir_entry); /* Truncam per l'ultima entrada, si sols hi ha la que volem borrar be * sino llevam l'ultima que ara estara copiada al lloc de la que voliem * borrar. */ truncate_file(p_dir_inode, inode.size-sizeof(emofs_dir_entry)); read_inode(p_inode, &inode); if (inode.link_count == 0) { /* Hem de alliberar blocs de dades i inode */ truncate_file(p_inode, 0); free_inode(p_inode); } else { inode.link_count--; write_inode(p_inode, &inode); } emofs_sem_signal(mutex); return 0; }
int main(int argc, char *argv[]) { int fd; ssize_t ret; char welcomefile_body[] = "Love is God. God is Love. Anbe Murugan.\n"; struct simplefs_inode welcome = { .mode = S_IFREG, .inode_no = WELCOMEFILE_INODE_NUMBER, .data_block_number = WELCOMEFILE_DATABLOCK_NUMBER, .file_size = sizeof(welcomefile_body), }; struct simplefs_dir_record record = { .filename = "vanakkam", .inode_no = WELCOMEFILE_INODE_NUMBER, }; if (argc != 2) { printf("Usage: mkfs-simplefs <device>\n"); return -1; } fd = open(argv[1], O_RDWR); if (fd == -1) { perror("Error opening the device"); return -1; } ret = 1; do { if (write_superblock(fd)) break; if (write_inode_store(fd)) break; if (write_inode(fd, &welcome)) break; if (write_dirent(fd, &record)) break; if (write_block(fd, welcomefile_body, welcome.file_size)) break; ret = 0; } while (0); close(fd); return ret; }
unsigned int create_inode(enum file_type_e type) { struct inode_s inode; int i; /*memset(&inode, 0, sizeof(struct inode_s)); */ inode.type = type; inode.size = 0; inode.blocs_double_indirect = 0; inode.blocs_indirect = 0; for (i=0; i<NB_DIRECTS; i++){ inode.blocs_directs[i] = 0; } unsigned int inumber = new_bloc(); write_inode(inumber, &inode); return inumber; }
void iput(register struct inode *inode) { if (inode) { wait_on_inode(inode); if (!inode->i_count) { printk("VFS: iput: trying to free free inode\n"); printk("VFS: device %s, inode %lu, mode=0%07o\n", kdevname(inode->i_rdev), inode->i_ino, inode->i_mode); return; } #ifdef NOT_YET if (inode->i_pipe) wake_up_interruptible(&PIPE_WAIT(*inode)); #endif repeat: if (inode->i_count > 1) { inode->i_count--; return; } wake_up(&inode_wait); #ifdef NOT_YET if (inode->i_pipe) { /* Free up any memory allocated to the pipe */ } #endif if (inode->i_sb) { struct super_operations *sop = inode->i_sb->s_op; if (sop && sop->put_inode) { sop->put_inode(inode); if (!inode->i_nlink) return; } } if (inode->i_dirt) { write_inode(inode); /* we can sleep - so do again */ wait_on_inode(inode); goto repeat; } inode->i_count--; nr_free_inodes++; } return; }
unsigned int create_inode(enum file_type_e type) { struct inode_s inode; unsigned int inumber; memset(&inode, 0, sizeof(struct inode_s)); inode.inode_type = type; inumber = new_bloc(); if(inumber == BLOC_NULL) { fprintf(stderr, "Impossible to create new inode. no space remain\n"); return BLOC_NULL; } write_inode(inumber, &inode); return inumber; }
void push_free_inode(inode* free_inode) { void* superblock = malloc(SD_SECTORSIZE); //gets superblock safe_read(0, superblock); int free_inode_num = *((int*)superblock); free(superblock); // advance free inode list int free_list_buf = free_inode->next_inode_num; write_to_offset(0, 0, (void*)&free_list_buf, sizeof(int)); free_inode->next_inode_num = free_inode_num; write_inode(free_inode_num, (void*)free_inode); free(free_inode); }
static struct inode *get_empty_inode(void) { static ino_t ino = 0; register struct inode *inode; do { inode = first_inode->i_next; do { if (!inode->i_count && !inode->i_dirt && !inode->i_lock) { goto found_empty_inode; } } while ((inode = inode->i_next) != first_inode->i_next); printk("VFS: No free inodes\n"); list_inode_status(); sleep_on(&inode_wait); } while (1); found_empty_inode: /* Here we are doing the same checks again. There cannot be a significant * * race condition here - no time has passed */ #if 0 if (inode->i_lock) { wait_on_inode(inode); goto repeat; } if (inode->i_dirt) { write_inode(inode); goto repeat; } if (inode->i_count) goto repeat; #endif clear_inode(inode); inode->i_count = inode->i_nlink = 1; inode->i_uid = current->euid; #ifdef BLOAT_FS inode->i_version = ++event; #endif inode->i_ino = ++ino; nr_free_inodes--; if (nr_free_inodes < 0) { printk("VFS: get_empty_inode: bad free inode count.\n"); nr_free_inodes = 0; } return inode; }
/** Trunca un fitxer a partir del byte n. * Si n_bytes = 0 alliberam tots els blocs. * @inode: el nombre d'inode. * @n_byte: el byte final del fitxer. * @return: 0 si exit. */ int truncate_file(int inode, int n_byte) { int how_many, block, f_offset, l_size; int n_block, n_bytes, n_inode; int i; emofs_inode tmp_inode; int blocks_to_truncate; read_inode(inode, &tmp_inode); if (tmp_inode.size <= n_byte) { /* Si fitxer es mes petit o del tamany a truncar * no s'ha de fer res. */ return 0; } blocks_to_truncate = (tmp_inode.size-n_byte)/BLOCK_SIZE; for(i = INDIRECT_POINTER_COUNT-1; i >= 0; i--) { if(tmp_inode.indirect_pointer[i] != NULL_POINTER) { truncate_assist(tmp_inode.indirect_pointer[i], i, \ &tmp_inode, &blocks_to_truncate); if (blocks_to_truncate > 0) { free_block(tmp_inode.indirect_pointer[i]); tmp_inode.indirect_pointer[i] = NULL_POINTER; tmp_inode.block_count--; blocks_to_truncate--; } } } for(i = DIRECT_POINTER_COUNT-1; i >= 0; i--) { /* El blocks_to_truncate > 0 no esta a la condicio * del bucle per donar suport als fitxers esparsos. */ if (blocks_to_truncate > 0 && \ tmp_inode.direct_pointer[i] != NULL_POINTER) { free_block(tmp_inode.direct_pointer[i]); tmp_inode.direct_pointer[i] = NULL_POINTER; tmp_inode.block_count--; blocks_to_truncate--; } } tmp_inode.size = n_byte; write_inode(inode, &tmp_inode); return 0; }
static int logfs_replace_inode(struct inode *dir, struct dentry *dentry, struct logfs_disk_dentry *dd, struct inode *inode) { loff_t pos; int err; err = logfs_get_dd(dir, dentry, dd, &pos); if (err) return err; dd->ino = cpu_to_be64(inode->i_ino); dd->type = logfs_type(inode); err = write_dir(dir, dd, pos); if (err) return err; log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos, dd->name, be64_to_cpu(dd->ino)); return write_inode(dir); }
int ext2_truncate(inode_t *inode, off_t off) { __u32 size = off; ext2_fs_instance_t *instance = (ext2_fs_instance_t*)inode->i_instance; struct ext2_inode *einode = read_inode(instance, inode->i_ino); if (einode) { __u32 n_blk; if (size > 0) { n_blk = (size - 1) / (1024 << instance->superblock.s_log_block_size) + 1; } else { n_blk = 1; } __u32 addr = get_data_block (instance,einode, n_blk);; if (addr) { while (addr) { if (off <= 0) { free_block(instance, addr / (1024 << instance->superblock.s_log_block_size)); } else { off -= 1024 << instance->superblock.s_log_block_size; } n_blk++; addr = get_data_block (instance,einode, n_blk); } } else { while (off > 0) { set_block_inode_data(instance, einode, n_blk, alloc_block(instance)); n_blk++; off -= 1024 << instance->superblock.s_log_block_size; } } einode->i_size = size; write_inode(instance, inode->i_ino, einode); ext2inode_2_inode(inode, inode->i_instance, inode->i_ino, einode); return 0; } return -ENOENT; }
int ext2_truncate(inode_t *inode, off_t off) { uint32_t size = off; ext2_fs_instance_t *instance = (ext2_fs_instance_t*)inode->i_instance; struct ext2_inode *einode = read_inode(instance, inode->i_ino); if (einode) { // TODO vérifier le bon fonctionnement. int n_blk; if (size > 0) { n_blk = (size - 1) / (1024 << instance->superblock.s_log_block_size) + 1; } else { n_blk = 1; } int addr = addr_inode_data2(instance, einode, n_blk); if (addr) { // 1er cas : off est plus petit que la taille du fichier. while (addr) { if (off <= 0) { free_block(instance, addr / (1024 << instance->superblock.s_log_block_size)); } else { off -= 1024 << instance->superblock.s_log_block_size; } n_blk++; addr = addr_inode_data2(instance, einode, n_blk); } } else { // 2er cas : off est plus grand. while (off > 0) { set_block_inode_data(instance, einode, n_blk, alloc_block(instance)); n_blk++; off -= 1024 << instance->superblock.s_log_block_size; } } einode->i_size = size; write_inode(instance, inode->i_ino, einode); ext2inode_2_inode(inode, inode->i_instance, inode->i_ino, einode); return 0; } return -ENOENT; }