/* * routine to check that the specified directory is empty (for rmdir) */ static int empty_dir(struct inode * inode) { struct super_block * sb; unsigned long pos, block, offset; /* pos = block * block_size + offset */ struct buffer_head * bh; struct sysv_dir_entry * de; if (!inode) return 1; block = 0; bh = NULL; pos = offset = 2*SYSV_DIRSIZE; if (inode->i_size % SYSV_DIRSIZE) goto bad_dir; if (inode->i_size < pos) goto bad_dir; bh = sysv_file_bread(inode, 0, 0); if (!bh) goto bad_dir; de = (struct sysv_dir_entry *) (bh->b_data + 0*SYSV_DIRSIZE); if (!de->inode || strcmp(de->name,".")) goto bad_dir; de = (struct sysv_dir_entry *) (bh->b_data + 1*SYSV_DIRSIZE); if (!de->inode || strcmp(de->name,"..")) goto bad_dir; sb = inode->i_sb; while (pos < inode->i_size) { if (!bh) { bh = sysv_file_bread(inode, block, 0); if (!bh) { /* offset = 0; */ block++; pos += sb->sv_block_size; continue; } } de = (struct sysv_dir_entry *) (bh->b_data + offset); pos += SYSV_DIRSIZE; offset += SYSV_DIRSIZE; if (de->inode) { brelse(bh); return 0; } if (offset < sb->sv_block_size) continue; brelse(bh); bh = NULL; offset = 0; block++; } brelse(bh); return 1; bad_dir: brelse(bh); printk("Bad directory on device %s\n", kdevname(inode->i_dev)); return 1; }
static int sysv_readlink(struct inode * inode, char * buffer, int buflen) { struct buffer_head * bh; char * bh_data; int i; char c; if (!S_ISLNK(inode->i_mode)) { iput(inode); return -EINVAL; } if (buflen > inode->i_sb->sv_block_size_1) buflen = inode->i_sb->sv_block_size_1; bh = sysv_file_bread(inode, 0, 0); iput(inode); if (!bh) return 0; bh_data = bh->b_data; i = 0; while (i<buflen && (c = bh_data[i])) { i++; put_fs_byte(c,buffer++); } brelse(bh); return i; }
int sysv_symlink(struct inode * dir, struct dentry * dentry, const char * symname) { struct sysv_dir_entry * de; struct inode * inode; struct buffer_head * name_block; char * name_block_data; struct super_block * sb; int i; char c; struct buffer_head * bh; if (!(inode = sysv_new_inode(dir))) return -ENOSPC; inode->i_mode = S_IFLNK | 0777; inode->i_op = &sysv_symlink_inode_operations; name_block = sysv_file_bread(inode, 0, 1); if (!name_block) { inode->i_nlink--; mark_inode_dirty(inode); iput(inode); return -ENOSPC; } sb = inode->i_sb; name_block_data = name_block->b_data; i = 0; while (i < sb->sv_block_size_1 && (c = *(symname++))) name_block_data[i++] = c; name_block_data[i] = 0; mark_buffer_dirty(name_block, 1); brelse(name_block); inode->i_size = i; mark_inode_dirty(inode); bh = sysv_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de); if (bh) { inode->i_nlink--; mark_inode_dirty(inode); iput(inode); brelse(bh); return -EEXIST; } i = sysv_add_entry(dir, dentry->d_name.name, dentry->d_name.len, &bh, &de); if (i) { inode->i_nlink--; mark_inode_dirty(inode); iput(inode); return i; } de->inode = inode->i_ino; mark_buffer_dirty(bh, 1); brelse(bh); d_instantiate(dentry, inode); return 0; }
int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode) { int error; struct inode * inode; struct buffer_head * bh, *dir_block; struct sysv_dir_entry * de; if (!dir) return -EINVAL; bh = sysv_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de); if (bh) { brelse(bh); return -EEXIST; } if (dir->i_nlink >= dir->i_sb->sv_link_max) return -EMLINK; inode = sysv_new_inode(dir); if (!inode) return -ENOSPC; inode->i_op = &sysv_dir_inode_operations; inode->i_size = 2 * SYSV_DIRSIZE; dir_block = sysv_file_bread(inode,0,1); if (!dir_block) { inode->i_nlink--; mark_inode_dirty(inode); iput(inode); return -ENOSPC; } de = (struct sysv_dir_entry *) (dir_block->b_data + 0*SYSV_DIRSIZE); de->inode = inode->i_ino; strcpy(de->name,"."); /* rest of de->name is zero, see sysv_new_block */ de = (struct sysv_dir_entry *) (dir_block->b_data + 1*SYSV_DIRSIZE); de->inode = dir->i_ino; strcpy(de->name,".."); /* rest of de->name is zero, see sysv_new_block */ inode->i_nlink = 2; mark_buffer_dirty(dir_block, 1); brelse(dir_block); inode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask); if (dir->i_mode & S_ISGID) inode->i_mode |= S_ISGID; mark_inode_dirty(inode); error = sysv_add_entry(dir, dentry->d_name.name, dentry->d_name.len, &bh, &de); if (error) { inode->i_nlink=0; iput(inode); return error; } de->inode = inode->i_ino; mark_buffer_dirty(bh, 1); dir->i_nlink++; mark_inode_dirty(dir); brelse(bh); d_instantiate(dentry, inode); return 0; }
/* * sysv_find_entry() * * finds an entry in the specified directory with the wanted name. It * returns the cache buffer in which the entry was found, and the entry * itself (as a parameter - res_dir). It does NOT read the inode of the * entry - you'll have to do that yourself if you want to. */ static struct buffer_head * sysv_find_entry(struct inode * dir, const char * name, int namelen, struct sysv_dir_entry ** res_dir) { struct super_block * sb; unsigned long pos, block, offset; /* pos = block * block_size + offset */ struct buffer_head * bh; *res_dir = NULL; if (!dir) return NULL; sb = dir->i_sb; if (namelen > SYSV_NAMELEN) { if (sb->sv_truncate) namelen = SYSV_NAMELEN; else return NULL; } bh = NULL; pos = block = offset = 0; while (pos < dir->i_size) { if (!bh) { bh = sysv_file_bread(dir, block, 0); if (!bh) { /* offset = 0; */ block++; pos += sb->sv_block_size; continue; } } if (sysv_match(namelen, name, *res_dir = (struct sysv_dir_entry *) (bh->b_data + offset) )) return bh; pos += SYSV_DIRSIZE; offset += SYSV_DIRSIZE; if (offset < sb->sv_block_size) continue; brelse(bh); bh = NULL; offset = 0; block++; } brelse(bh); *res_dir = NULL; return NULL; }
static int sysv_follow_link(struct inode * dir, struct inode * inode, int flag, int mode, struct inode ** res_inode) { int error; struct buffer_head * bh; *res_inode = NULL; if (!dir) { dir = current->fs->root; dir->i_count++; } if (!inode) { iput(dir); return -ENOENT; } if (!S_ISLNK(inode->i_mode)) { iput(dir); *res_inode = inode; return 0; } if (current->link_count > 5) { iput(inode); iput(dir); return -ELOOP; } if (!(bh = sysv_file_bread(inode, 0, 0))) { /* is reading 1 block enough ?? */ iput(inode); iput(dir); return -EIO; } iput(inode); current->link_count++; error = open_namei(bh->b_data,flag,mode,res_inode,dir); current->link_count--; brelse(bh); return error; }
/* * Anybody can rename anything with this: the permission checks are left to the * higher-level routines. */ static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry) { struct inode * old_inode, * new_inode; struct buffer_head * old_bh, * new_bh, * dir_bh; struct sysv_dir_entry * old_de, * new_de; int retval; old_inode = old_dentry->d_inode; new_inode = new_dentry->d_inode; new_bh = dir_bh = NULL; old_bh = sysv_find_entry(old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de); retval = -ENOENT; if (!old_bh || old_de->inode != old_inode->i_ino) goto end_rename; retval = -EPERM; new_bh = sysv_find_entry(new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de); if (new_bh) { if (!new_inode) { brelse(new_bh); new_bh = NULL; } } if (S_ISDIR(old_inode->i_mode)) { if (new_inode) { retval = -ENOTEMPTY; if (!empty_dir(new_inode)) goto end_rename; } retval = -EIO; dir_bh = sysv_file_bread(old_inode, 0, 0); if (!dir_bh) goto end_rename; if (PARENT_INO(dir_bh->b_data) != old_dir->i_ino) goto end_rename; retval = -EMLINK; if (!new_inode && new_dir != old_dir && new_dir->i_nlink >= new_dir->i_sb->sv_link_max) goto end_rename; } if (!new_bh) { retval = sysv_add_entry(new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_bh, &new_de); if (retval) goto end_rename; } new_de->inode = old_inode->i_ino; old_de->inode = 0; old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME; mark_inode_dirty(old_dir); new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME; mark_inode_dirty(new_dir); if (new_inode) { new_inode->i_nlink--; new_inode->i_ctime = CURRENT_TIME; mark_inode_dirty(new_inode); } mark_buffer_dirty(old_bh); mark_buffer_dirty(new_bh); if (dir_bh) { PARENT_INO(dir_bh->b_data) = new_dir->i_ino; mark_buffer_dirty(dir_bh); old_dir->i_nlink--; mark_inode_dirty(old_dir); if (new_inode) { new_inode->i_nlink--; mark_inode_dirty(new_inode); } else { new_dir->i_nlink++; mark_inode_dirty(new_dir); } } retval = 0; end_rename: brelse(dir_bh); brelse(old_bh); brelse(new_bh); return retval; }
/* * sysv_add_entry() * * adds a file entry to the specified directory, returning a possible * error value if it fails. * * NOTE!! The inode part of 'de' is left at 0 - which means you * may not sleep between calling this and putting something into * the entry, as someone else might have used it while you slept. */ static int sysv_add_entry(struct inode * dir, const char * name, int namelen, struct buffer_head ** res_buf, struct sysv_dir_entry ** res_dir) { struct super_block * sb; int i; unsigned long pos, block, offset; /* pos = block * block_size + offset */ struct buffer_head * bh; struct sysv_dir_entry * de; *res_buf = NULL; *res_dir = NULL; sb = dir->i_sb; if (namelen > SYSV_NAMELEN) { if (sb->sv_truncate) namelen = SYSV_NAMELEN; else return -ENAMETOOLONG; } if (!namelen) return -ENOENT; bh = NULL; pos = block = offset = 0; while (1) { if (!bh) { bh = sysv_file_bread(dir, block, 1); if (!bh) return -ENOSPC; } de = (struct sysv_dir_entry *) (bh->b_data + offset); pos += SYSV_DIRSIZE; offset += SYSV_DIRSIZE; if (pos > dir->i_size) { de->inode = 0; dir->i_size = pos; mark_inode_dirty(dir); } if (de->inode) { if (namecompare(namelen, SYSV_NAMELEN, name, de->name)) { brelse(bh); return -EEXIST; } } else { dir->i_mtime = dir->i_ctime = CURRENT_TIME; mark_inode_dirty(dir); for (i = 0; i < SYSV_NAMELEN ; i++) de->name[i] = (i < namelen) ? name[i] : 0; mark_buffer_dirty(bh); *res_dir = de; break; } if (offset < sb->sv_block_size) continue; brelse(bh); bh = NULL; offset = 0; block++; } *res_buf = bh; return 0; }
/* * rename uses retrying to avoid race-conditions: at least they should be minimal. * it tries to allocate all the blocks, then sanity-checks, and if the sanity- * checks fail, it tries to restart itself again. Very practical - no changes * are done until we know everything works ok.. and then all the changes can be * done in one fell swoop when we have claimed all the buffers needed. * * Anybody can rename anything with this: the permission checks are left to the * higher-level routines. */ static int do_sysv_rename(struct inode * old_dir, struct dentry * old_dentry, struct inode * new_dir, struct dentry * new_dentry) { struct inode * old_inode, * new_inode; struct buffer_head * old_bh, * new_bh, * dir_bh; struct sysv_dir_entry * old_de, * new_de; int retval; goto start_up; try_again: brelse(old_bh); brelse(new_bh); brelse(dir_bh); current->counter = 0; schedule(); start_up: old_inode = new_inode = NULL; old_bh = new_bh = dir_bh = NULL; old_bh = sysv_find_entry(old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de); retval = -ENOENT; if (!old_bh) goto end_rename; old_inode = old_dentry->d_inode; /* don't cross mnt-points */ retval = -EPERM; new_inode = new_dentry->d_inode; new_bh = sysv_find_entry(new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_de); if (new_bh) { if (!new_inode) { brelse(new_bh); new_bh = NULL; } } if (new_inode == old_inode) { retval = 0; goto end_rename; } if (S_ISDIR(old_inode->i_mode)) { retval = -EINVAL; if (is_subdir(new_dentry, old_dentry)) goto end_rename; if (new_inode) { if (new_dentry->d_count > 1) shrink_dcache_parent(new_dentry); retval = -EBUSY; if (new_dentry->d_count > 1) goto end_rename; retval = -ENOTEMPTY; if (!empty_dir(new_inode)) goto end_rename; } retval = -EIO; dir_bh = sysv_file_bread(old_inode, 0, 0); if (!dir_bh) goto end_rename; if (PARENT_INO(dir_bh->b_data) != old_dir->i_ino) goto end_rename; retval = -EMLINK; if (!new_inode && new_dir->i_nlink >= new_dir->i_sb->sv_link_max) goto end_rename; } if (!new_bh) { retval = sysv_add_entry(new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_bh, &new_de); if (retval) goto end_rename; } /* sanity checking before doing the rename - avoid races */ if (new_inode && (new_de->inode != new_inode->i_ino)) goto try_again; if (new_de->inode && !new_inode) goto try_again; if (old_de->inode != old_inode->i_ino) goto try_again; /* ok, that's it */ old_de->inode = 0; new_de->inode = old_inode->i_ino; old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME; mark_inode_dirty(old_dir); new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME; mark_inode_dirty(new_dir); if (new_inode) { new_inode->i_nlink--; new_inode->i_ctime = CURRENT_TIME; mark_inode_dirty(new_inode); } mark_buffer_dirty(old_bh, 1); mark_buffer_dirty(new_bh, 1); if (dir_bh) { PARENT_INO(dir_bh->b_data) = new_dir->i_ino; mark_buffer_dirty(dir_bh, 1); old_dir->i_nlink--; mark_inode_dirty(old_dir); if (new_inode) { new_inode->i_nlink--; mark_inode_dirty(new_inode); } else { new_dir->i_nlink++; mark_inode_dirty(new_dir); } } d_move(old_dentry, new_dentry); retval = 0; end_rename: brelse(dir_bh); brelse(old_bh); brelse(new_bh); return retval; }