static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { struct super_block *sb = old_dir->i_sb; unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME]; int err, is_hid; lock_super(sb); err = msdos_format_name(old_dentry->d_name.name, old_dentry->d_name.len, old_msdos_name, &MSDOS_SB(old_dir->i_sb)->options); if (err) goto out; err = msdos_format_name(new_dentry->d_name.name, new_dentry->d_name.len, new_msdos_name, &MSDOS_SB(new_dir->i_sb)->options); if (err) goto out; is_hid = (new_dentry->d_name.name[0] == '.') && (new_msdos_name[0] != '.'); err = do_msdos_rename(old_dir, old_msdos_name, old_dentry, new_dir, new_msdos_name, new_dentry, is_hid); out: unlock_super(sb); if (!err) err = fat_flush_inodes(sb, old_dir, new_dir); return err; }
/***** Rename, a wrapper for rename_same_dir & rename_diff_dir */ int msdos_rename(struct inode *old_dir,struct dentry *old_dentry, struct inode *new_dir,struct dentry *new_dentry) { struct super_block *sb = old_dir->i_sb; struct buffer_head *old_bh; struct msdos_dir_entry *old_de; int old_ino, error; int is_hid,old_hid; /* if new file and old file are hidden */ char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME]; error = msdos_format_name(old_dentry->d_name.name, old_dentry->d_name.len,old_msdos_name, &MSDOS_SB(old_dir->i_sb)->options); if (error < 0) goto rename_done; error = msdos_format_name(new_dentry->d_name.name, new_dentry->d_name.len,new_msdos_name, &MSDOS_SB(new_dir->i_sb)->options); if (error < 0) goto rename_done; is_hid = (new_dentry->d_name.name[0]=='.') && (new_msdos_name[0]!='.'); old_hid = (old_dentry->d_name.name[0]=='.') && (old_msdos_name[0]!='.'); error = fat_scan(old_dir, old_msdos_name, &old_bh, &old_de, &old_ino); if (error < 0) goto rename_done; error = do_msdos_rename(old_dir, old_msdos_name, old_dentry, new_dir, new_msdos_name, new_dentry, old_bh, old_de, (ino_t)old_ino, is_hid); fat_brelse(sb, old_bh); rename_done: return error; }
int msdos_rename(struct inode *old_dir,const char *old_name,int old_len, struct inode *new_dir,const char *new_name,int new_len) { char old_msdos_name[MSDOS_NAME],new_msdos_name[MSDOS_NAME]; struct buffer_head *old_bh; struct msdos_dir_entry *old_de; int old_ino,error; if ((error = msdos_format_name(MSDOS_SB(old_dir->i_sb)->name_check, old_name,old_len,old_msdos_name)) < 0) goto rename_done; if ((error = msdos_format_name(MSDOS_SB(new_dir->i_sb)->name_check, new_name,new_len,new_msdos_name)) < 0) goto rename_done; if ((error = msdos_scan(old_dir,old_msdos_name,&old_bh,&old_de, &old_ino)) < 0) goto rename_done; lock_creation(); if (old_dir == new_dir) error = rename_same_dir(old_dir,old_msdos_name,new_dir, new_msdos_name,old_bh,old_de,old_ino); else error = rename_diff_dir(old_dir,old_msdos_name,new_dir, new_msdos_name,old_bh,old_de,old_ino); unlock_creation(); brelse(old_bh); rename_done: iput(old_dir); iput(new_dir); return error; }
/***** Rename, a wrapper for rename_same_dir & rename_diff_dir */ static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry, unsigned int flags) { struct super_block *sb = old_dir->i_sb; unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME]; int err, is_hid; if (flags & ~RENAME_NOREPLACE) return -EINVAL; mutex_lock(&MSDOS_SB(sb)->s_lock); err = msdos_format_name(old_dentry->d_name.name, old_dentry->d_name.len, old_msdos_name, &MSDOS_SB(old_dir->i_sb)->options); if (err) goto out; err = msdos_format_name(new_dentry->d_name.name, new_dentry->d_name.len, new_msdos_name, &MSDOS_SB(new_dir->i_sb)->options); if (err) goto out; is_hid = (new_dentry->d_name.name[0] == '.') && (new_msdos_name[0] != '.'); err = do_msdos_rename(old_dir, old_msdos_name, old_dentry, new_dir, new_msdos_name, new_dentry, is_hid); out: mutex_unlock(&MSDOS_SB(sb)->s_lock); if (!err) err = fat_flush_inodes(sb, old_dir, new_dir); return err; }
int msdos_create(struct inode *dir,const char *name,int len,int mode, struct inode **result) { struct buffer_head *bh; struct msdos_dir_entry *de; char msdos_name[MSDOS_NAME]; int ino,res; if (!dir) return -ENOENT; if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len, msdos_name)) < 0) { iput(dir); return res; } lock_creation(); if (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) { unlock_creation(); brelse(bh); iput(dir); return -EEXIST; } res = msdos_create_entry(dir,msdos_name,S_ISDIR(mode),result); unlock_creation(); iput(dir); return res; }
/***** Locates a directory entry. Uses unformatted name. */ static int msdos_find(struct inode *dir, const unsigned char *name, int len, struct buffer_head **bh, struct msdos_dir_entry **de, loff_t *i_pos) { unsigned char msdos_name[MSDOS_NAME]; char dotsOK; int res; dotsOK = MSDOS_SB(dir->i_sb)->options.dotsOK; res = msdos_format_name(name, len, msdos_name, &MSDOS_SB(dir->i_sb)->options); if (res < 0) return -ENOENT; res = fat_scan(dir, msdos_name, bh, de, i_pos); if (!res && dotsOK) { if (name[0] == '.') { if (!((*de)->attr & ATTR_HIDDEN)) res = -ENOENT; } else { if ((*de)->attr & ATTR_HIDDEN) res = -ENOENT; } } return res; }
static int msdos_find(struct inode *dir, const unsigned char *name, int len, struct fat_slot_info *sinfo) { struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb); unsigned char msdos_name[MSDOS_NAME]; int err; err = msdos_format_name(name, len, msdos_name, &sbi->options); if (err) return -ENOENT; err = fat_scan(dir, msdos_name, sinfo); if (!err && sbi->options.dotsOK) { if (name[0] == '.') { if (!(sinfo->de->attr & ATTR_HIDDEN)) err = -ENOENT; } else { if (sinfo->de->attr & ATTR_HIDDEN) err = -ENOENT; } if (err) brelse(sinfo->bh); } return err; }
/***** Create a file */ int msdos_create(struct inode *dir,struct dentry *dentry,int mode) { struct super_block *sb = dir->i_sb; struct buffer_head *bh; struct msdos_dir_entry *de; struct inode *inode; int res,is_hid; loff_t ino; char msdos_name[MSDOS_NAME]; res = msdos_format_name(dentry->d_name.name,dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (res < 0) return res; is_hid = (dentry->d_name.name[0]=='.') && (msdos_name[0]!='.'); /* Have to do it due to foo vs. .foo conflicts */ if (fat_scan(dir,msdos_name,&bh,&de,&ino) >= 0) { fat_brelse(sb, bh); return -EINVAL; } inode = NULL; res = msdos_add_entry(dir, msdos_name, &bh, &de, &ino, 0, is_hid); if (res) return res; inode = fat_build_inode(dir->i_sb, de, ino, &res); fat_brelse(sb, bh); if (!inode) return res; inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); d_instantiate(dentry, inode); return 0; }
/***** Make a directory */ static int msdos_mkdir(struct inode *dir, struct dentry *dentry, int mode) { struct super_block *sb = dir->i_sb; struct fat_slot_info sinfo; struct inode *inode; unsigned char msdos_name[MSDOS_NAME]; struct timespec ts; int err, is_hid, cluster; lock_kernel(); err = msdos_format_name(dentry->d_name.name, dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (err) goto out; is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.'); /* foo vs .foo situation */ if (!fat_scan(dir, msdos_name, &sinfo)) { brelse(sinfo.bh); err = -EINVAL; goto out; } ts = CURRENT_TIME_SEC; cluster = fat_alloc_new_dir(dir, &ts); if (cluster < 0) { err = cluster; goto out; } err = msdos_add_entry(dir, msdos_name, 1, is_hid, cluster, &ts, &sinfo); if (err) goto out_free; inc_nlink(dir); inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos); brelse(sinfo.bh); if (IS_ERR(inode)) { err = PTR_ERR(inode); /* the directory was completed, just return a error */ goto out; } inode->i_nlink = 2; inode->i_mtime = inode->i_atime = inode->i_ctime = ts; /* timestamp is already written, so mark_inode_dirty() is unneeded. */ d_instantiate(dentry, inode); unlock_kernel(); fat_flush_inodes(sb, dir, inode); return 0; out_free: fat_free_clusters(dir, cluster); out: unlock_kernel(); return err; }
static int msdos_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) { struct super_block *sb = dir->i_sb; struct fat_slot_info sinfo; struct inode *inode; unsigned char msdos_name[MSDOS_NAME]; struct timespec ts; int err, is_hid, cluster; lock_super(sb); err = msdos_format_name(dentry->d_name.name, dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (err) goto out; is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.'); /* */ if (!fat_scan(dir, msdos_name, &sinfo)) { brelse(sinfo.bh); err = -EINVAL; goto out; } ts = CURRENT_TIME_SEC; cluster = fat_alloc_new_dir(dir, &ts); if (cluster < 0) { err = cluster; goto out; } err = msdos_add_entry(dir, msdos_name, 1, is_hid, cluster, &ts, &sinfo); if (err) goto out_free; inc_nlink(dir); inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos); brelse(sinfo.bh); if (IS_ERR(inode)) { err = PTR_ERR(inode); /* */ goto out; } set_nlink(inode, 2); inode->i_mtime = inode->i_atime = inode->i_ctime = ts; /* */ d_instantiate(dentry, inode); unlock_super(sb); fat_flush_inodes(sb, dir, inode); return 0; out_free: fat_free_clusters(dir, cluster); out: unlock_super(sb); return err; }
static int msdos_find(struct inode *dir,const char *name,int len, struct buffer_head **bh,struct msdos_dir_entry **de,int *ino) { char msdos_name[MSDOS_NAME]; int res; if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len, msdos_name)) < 0) return res; return msdos_scan(dir,msdos_name,bh,de,ino); }
/* * Compute the hash for the msdos name corresponding to the dentry. * Note: if the name is invalid, we leave the hash code unchanged so * that the existing dentry can be used. The msdos fs routines will * return ENOENT or EINVAL as appropriate. */ static int msdos_hash(struct dentry *dentry, struct qstr *qstr) { struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options; unsigned char msdos_name[MSDOS_NAME]; int error; error = msdos_format_name(qstr->name, qstr->len, msdos_name, options); if (!error) qstr->hash = full_name_hash(msdos_name, MSDOS_NAME); return 0; }
int msdos_mkdir(struct inode *dir,const char *name,int len,int mode) { struct buffer_head *bh; struct msdos_dir_entry *de; struct inode *inode,*dot; char msdos_name[MSDOS_NAME]; int ino,res; if ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len, msdos_name)) < 0) { iput(dir); return res; } lock_creation(); if (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) { unlock_creation(); brelse(bh); iput(dir); return -EEXIST; } if ((res = msdos_create_entry(dir,msdos_name,1,&inode)) < 0) { unlock_creation(); iput(dir); return res; } dir->i_nlink++; inode->i_nlink = 2; /* no need to mark them dirty */ MSDOS_I(inode)->i_busy = 1; /* prevent lookups */ if ((res = msdos_add_cluster(inode)) < 0) goto mkdir_error; if ((res = msdos_create_entry(inode,MSDOS_DOT,1,&dot)) < 0) goto mkdir_error; dot->i_size = inode->i_size; /* doesn't grow in the 2nd create_entry */ MSDOS_I(dot)->i_start = MSDOS_I(inode)->i_start; dot->i_nlink = inode->i_nlink; dot->i_dirt = 1; iput(dot); if ((res = msdos_create_entry(inode,MSDOS_DOTDOT,1,&dot)) < 0) goto mkdir_error; unlock_creation(); dot->i_size = dir->i_size; MSDOS_I(dot)->i_start = MSDOS_I(dir)->i_start; dot->i_nlink = dir->i_nlink; dot->i_dirt = 1; MSDOS_I(inode)->i_busy = 0; iput(dot); iput(inode); iput(dir); return 0; mkdir_error: iput(inode); if (msdos_rmdir(dir,name,len) < 0) panic("rmdir in mkdir failed"); unlock_creation(); return res; }
/* * Compare two msdos names. If either of the names are invalid, * we fall back to doing the standard name comparison. */ static int msdos_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b) { struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options; unsigned char a_msdos_name[MSDOS_NAME], b_msdos_name[MSDOS_NAME]; int error; error = msdos_format_name(a->name, a->len, a_msdos_name, options); if (error) goto old_compare; error = msdos_format_name(b->name, b->len, b_msdos_name, options); if (error) goto old_compare; error = memcmp(a_msdos_name, b_msdos_name, MSDOS_NAME); out: return error; old_compare: error = 1; if (a->len == b->len) error = memcmp(a->name, b->name, a->len); goto out; }
/***** Rename, a wrapper for rename_same_dir & rename_diff_dir */ static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { struct buffer_head *old_bh; struct msdos_dir_entry *old_de; loff_t old_i_pos; int error, is_hid, old_hid; /* if new file and old file are hidden */ unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME]; lock_kernel(); error = msdos_format_name(old_dentry->d_name.name, old_dentry->d_name.len, old_msdos_name, &MSDOS_SB(old_dir->i_sb)->options); if (error < 0) goto rename_done; error = msdos_format_name(new_dentry->d_name.name, new_dentry->d_name.len, new_msdos_name, &MSDOS_SB(new_dir->i_sb)->options); if (error < 0) goto rename_done; is_hid = (new_dentry->d_name.name[0] == '.') && (new_msdos_name[0] != '.'); old_hid = (old_dentry->d_name.name[0] == '.') && (old_msdos_name[0] != '.'); error = fat_scan(old_dir, old_msdos_name, &old_bh, &old_de, &old_i_pos); if (error < 0) goto rename_done; error = do_msdos_rename(old_dir, old_msdos_name, old_dentry, new_dir, new_msdos_name, new_dentry, old_bh, old_de, old_i_pos, is_hid); brelse(old_bh); rename_done: unlock_kernel(); return error; }
/* * Compare two msdos names. If either of the names are invalid, * we fall back to doing the standard name comparison. */ static int msdos_cmp(const struct dentry *dentry, unsigned int len, const char *str, const struct qstr *name) { struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options; unsigned char a_msdos_name[MSDOS_NAME], b_msdos_name[MSDOS_NAME]; int error; error = msdos_format_name(name->name, name->len, a_msdos_name, options); if (error) goto old_compare; error = msdos_format_name(str, len, b_msdos_name, options); if (error) goto old_compare; error = memcmp(a_msdos_name, b_msdos_name, MSDOS_NAME); out: return error; old_compare: error = 1; if (name->len == len) error = memcmp(name->name, str, len); goto out; }
/***** Create a file */ static int msdos_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl) { struct super_block *sb = dir->i_sb; struct inode *inode = NULL; struct fat_slot_info sinfo; struct timespec ts; unsigned char msdos_name[MSDOS_NAME]; int err, is_hid; mutex_lock(&MSDOS_SB(sb)->s_lock); err = msdos_format_name(dentry->d_name.name, dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (err) goto out; is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.'); /* Have to do it due to foo vs. .foo conflicts */ if (!fat_scan(dir, msdos_name, &sinfo)) { brelse(sinfo.bh); err = -EINVAL; goto out; } ts = CURRENT_TIME_SEC; err = msdos_add_entry(dir, msdos_name, 0, is_hid, 0, &ts, &sinfo); if (err) goto out; inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos); brelse(sinfo.bh); if (IS_ERR(inode)) { err = PTR_ERR(inode); goto out; } inode->i_mtime = inode->i_atime = inode->i_ctime = ts; /* timestamp is already written, so mark_inode_dirty() is unneeded. */ d_instantiate(dentry, inode); out: mutex_unlock(&MSDOS_SB(sb)->s_lock); if (!err) err = fat_flush_inodes(sb, dir, inode); return err; }
static int msdos_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd) { struct super_block *sb = dir->i_sb; struct inode *inode = NULL; struct fat_slot_info sinfo; struct timespec ts; unsigned char msdos_name[MSDOS_NAME]; int err, is_hid; lock_super(sb); err = msdos_format_name(dentry->d_name.name, dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (err) goto out; is_hid = (dentry->d_name.name[0] == '.') && (msdos_name[0] != '.'); /* */ if (!fat_scan(dir, msdos_name, &sinfo)) { brelse(sinfo.bh); err = -EINVAL; goto out; } ts = CURRENT_TIME_SEC; err = msdos_add_entry(dir, msdos_name, 0, is_hid, 0, &ts, &sinfo); if (err) goto out; inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos); brelse(sinfo.bh); if (IS_ERR(inode)) { err = PTR_ERR(inode); goto out; } inode->i_mtime = inode->i_atime = inode->i_ctime = ts; /* */ d_instantiate(dentry, inode); out: unlock_super(sb); if (!err) err = fat_flush_inodes(sb, dir, inode); return err; }
/***** Make a directory */ int msdos_mkdir(struct inode *dir,struct dentry *dentry,int mode) { struct super_block *sb = dir->i_sb; struct buffer_head *bh; struct msdos_dir_entry *de; struct inode *inode; int res,is_hid; unsigned char msdos_name[MSDOS_NAME]; loff_t i_pos; lock_kernel(); res = msdos_format_name(dentry->d_name.name,dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (res < 0) { unlock_kernel(); return res; } is_hid = (dentry->d_name.name[0]=='.') && (msdos_name[0]!='.'); /* foo vs .foo situation */ if (fat_scan(dir, msdos_name, &bh, &de, &i_pos) >= 0) goto out_exist; res = msdos_add_entry(dir, msdos_name, &bh, &de, &i_pos, 1, is_hid); if (res) goto out_unlock; inode = fat_build_inode(dir->i_sb, de, i_pos, &res); if (!inode) { brelse(bh); goto out_unlock; } res = 0; dir->i_nlink++; inode->i_nlink = 2; /* no need to mark them dirty */ res = fat_new_dir(inode, dir, 0); if (res) goto mkdir_error; brelse(bh); d_instantiate(dentry, inode); res = 0; out_unlock: unlock_kernel(); return res; mkdir_error: inode->i_nlink = 0; inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; dir->i_nlink--; mark_inode_dirty(inode); mark_inode_dirty(dir); de->name[0] = DELETED_FLAG; mark_buffer_dirty(bh); brelse(bh); fat_detach(inode); iput(inode); goto out_unlock; out_exist: brelse(bh); res = -EINVAL; goto out_unlock; }
/***** Make a directory */ int msdos_mkdir(struct inode *dir,struct dentry *dentry,int mode) { struct super_block *sb = dir->i_sb; struct buffer_head *bh; struct msdos_dir_entry *de; struct inode *inode; int res,is_hid; char msdos_name[MSDOS_NAME]; loff_t ino; res = msdos_format_name(dentry->d_name.name,dentry->d_name.len, msdos_name, &MSDOS_SB(sb)->options); if (res < 0) return res; is_hid = (dentry->d_name.name[0]=='.') && (msdos_name[0]!='.'); /* foo vs .foo situation */ if (fat_scan(dir,msdos_name,&bh,&de,&ino) >= 0) goto out_exist; res = msdos_add_entry(dir, msdos_name, &bh, &de, &ino, 1, is_hid); if (res) goto out_unlock; inode = fat_build_inode(dir->i_sb, de, ino, &res); if (!inode) { fat_brelse(sb, bh); goto out_unlock; } res = 0; dir->i_nlink++; inode->i_nlink = 2; /* no need to mark them dirty */ res = fat_new_dir(inode, dir, 0); if (res) goto mkdir_error; fat_brelse(sb, bh); d_instantiate(dentry, inode); res = 0; out_unlock: return res; mkdir_error: printk(KERN_WARNING "msdos_mkdir: error=%d, attempting cleanup\n", res); inode->i_nlink = 0; inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; dir->i_nlink--; mark_inode_dirty(inode); mark_inode_dirty(dir); de->name[0] = DELETED_FLAG; fat_mark_buffer_dirty(sb, bh); fat_brelse(sb, bh); fat_detach(inode); iput(inode); goto out_unlock; out_exist: fat_brelse(sb, bh); res = -EINVAL; goto out_unlock; }