/* rename */
static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
const char *old_name = old_dentry->d_name.name;
const char *new_name = new_dentry->d_name.name;
int old_length = old_dentry->d_name.len;
int new_length = new_dentry->d_name.len;
int link_adjust = 0;
int error;
lock_kernel();
coda_vfs_stat.rename++;
error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
coda_i2f(new_dir), old_length, new_length,
(const char *) old_name, (const char *)new_name);
if ( !error ) {
if ( new_dentry->d_inode ) {
if ( S_ISDIR(new_dentry->d_inode->i_mode) )
link_adjust = 1;
coda_dir_changed(old_dir, -link_adjust);
coda_dir_changed(new_dir, link_adjust);
coda_flag_inode(new_dentry->d_inode, C_VATTR);
} else {
coda_flag_inode(old_dir, C_VATTR);
coda_flag_inode(new_dir, C_VATTR);
}
}
unlock_kernel();
return error;
}
int coda_rmdir(struct inode *dir, struct dentry *de)
{
const char *name = de->d_name.name;
int len = de->d_name.len;
int error;
lock_kernel();
coda_vfs_stat.rmdir++;
if (!d_unhashed(de)) {
unlock_kernel();
return -EBUSY;
}
error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
if ( error ) {
unlock_kernel();
return error;
}
coda_dir_changed(dir, -1);
drop_nlink(de->d_inode);
d_delete(de);
unlock_kernel();
return 0;
}
/* try to make de an entry in dir_inodde linked to source_de */
static int coda_link(struct dentry *source_de, struct inode *dir_inode,
struct dentry *de)
{
struct inode *inode = source_de->d_inode;
const char * name = de->d_name.name;
int len = de->d_name.len;
int error;
lock_kernel();
coda_vfs_stat.link++;
if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) {
unlock_kernel();
return -EPERM;
}
error = venus_link(dir_inode->i_sb, coda_i2f(inode),
coda_i2f(dir_inode), (const char *)name, len);
if (error) {
d_drop(de);
goto out;
}
coda_dir_changed(dir_inode, 0);
atomic_inc(&inode->i_count);
d_instantiate(de, inode);
inc_nlink(inode);
out:
unlock_kernel();
return(error);
}
static int coda_symlink(struct inode *dir_inode, struct dentry *de,
const char *symname)
{
const char *name = de->d_name.name;
int len = de->d_name.len;
int symlen;
int error=0;
coda_vfs_stat.symlink++;
if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
return -EPERM;
symlen = strlen(symname);
if ( symlen > CODA_MAXPATHLEN )
return -ENAMETOOLONG;
CDEBUG(D_INODE, "symname: %s, length: %d\n", symname, symlen);
/*
* This entry is now negative. Since we do not create
* an inode for the entry we have to drop it.
*/
d_drop(de);
error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
symname, symlen);
/* mtime is no good anymore */
if ( !error )
coda_dir_changed(dir_inode, 0);
CDEBUG(D_INODE, "in symlink result %d\n",error);
return error;
}
/* try to make de an entry in dir_inodde linked to source_de */
static int coda_link(struct dentry *source_de, struct inode *dir_inode,
struct dentry *de)
{
struct inode *inode = source_de->d_inode;
const char * name = de->d_name.name;
int len = de->d_name.len;
int error;
coda_vfs_stat.link++;
if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
return -EPERM;
CDEBUG(D_INODE, "old: fid: %s\n", coda_i2s(inode));
CDEBUG(D_INODE, "directory: %s\n", coda_i2s(dir_inode));
error = venus_link(dir_inode->i_sb, coda_i2f(inode),
coda_i2f(dir_inode), (const char *)name, len);
if (error) {
d_drop(de);
goto out;
}
coda_dir_changed(dir_inode, 0);
atomic_inc(&inode->i_count);
d_instantiate(de, inode);
inode->i_nlink++;
out:
CDEBUG(D_INODE, "link result %d\n",error);
return(error);
}
/* rename */
static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
const char *old_name = old_dentry->d_name.name;
const char *new_name = new_dentry->d_name.name;
int old_length = old_dentry->d_name.len;
int new_length = new_dentry->d_name.len;
int link_adjust = 0;
int error;
coda_vfs_stat.rename++;
CDEBUG(D_INODE, "old: %s, (%d length), new: %s"
"(%d length). old:d_count: %d, new:d_count: %d\n",
old_name, old_length, new_name, new_length,
atomic_read(&old_dentry->d_count), atomic_read(&new_dentry->d_count));
error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
coda_i2f(new_dir), old_length, new_length,
(const char *) old_name, (const char *)new_name);
if ( !error ) {
if ( new_dentry->d_inode ) {
if ( S_ISDIR(new_dentry->d_inode->i_mode) )
link_adjust = 1;
coda_dir_changed(old_dir, -link_adjust);
coda_dir_changed(new_dir, link_adjust);
coda_flag_inode(new_dentry->d_inode, C_VATTR);
} else {
coda_flag_inode(old_dir, C_VATTR);
coda_flag_inode(new_dir, C_VATTR);
}
}
CDEBUG(D_INODE, "result %d\n", error);
return error;
}
static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
{
struct inode *inode;
struct coda_vattr attrs;
const char *name = de->d_name.name;
int len = de->d_name.len;
int error;
struct ViceFid newfid;
coda_vfs_stat.mkdir++;
if (coda_isroot(dir) && coda_iscontrol(name, len))
return -EPERM;
CDEBUG(D_INODE, "mkdir %s (len %d) in %s, mode %o.\n",
name, len, coda_i2s(dir), mode);
attrs.va_mode = mode;
error = venus_mkdir(dir->i_sb, coda_i2f(dir),
name, len, &newfid, &attrs);
if ( error ) {
CDEBUG(D_INODE, "mkdir error: %s result %d\n",
coda_f2s(&newfid), error);
d_drop(de);
return error;
}
CDEBUG(D_INODE, "mkdir: new dir has fid %s.\n",
coda_f2s(&newfid));
inode = coda_iget(dir->i_sb, &newfid, &attrs);
if ( IS_ERR(inode) ) {
d_drop(de);
return PTR_ERR(inode);
}
/* invalidate the directory cnode's attributes */
coda_dir_changed(dir, 1);
d_instantiate(de, inode);
return 0;
}
static int coda_mknod(struct inode *dir, struct dentry *de, int mode, int rdev)
{
int error=0;
const char *name=de->d_name.name;
int length=de->d_name.len;
struct inode *inode;
struct ViceFid newfid;
struct coda_vattr attrs;
if ( coda_hasmknod == 0 )
return -EIO;
coda_vfs_stat.create++;
CDEBUG(D_INODE, "name: %s, length %d, mode %o, rdev %x\n",
name, length, mode, rdev);
if (coda_isroot(dir) && coda_iscontrol(name, length))
return -EPERM;
error = venus_create(dir->i_sb, coda_i2f(dir), name, length,
0, mode, rdev, &newfid, &attrs);
if ( error ) {
CDEBUG(D_INODE, "mknod: %s, result %d\n",
coda_f2s(&newfid), error);
d_drop(de);
return error;
}
inode = coda_iget(dir->i_sb, &newfid, &attrs);
if ( IS_ERR(inode) ) {
d_drop(de);
return PTR_ERR(inode);
}
/* invalidate the directory cnode's attributes */
coda_dir_changed(dir, 0);
d_instantiate(de, inode);
return 0;
}
/* destruction routines: unlink, rmdir */
int coda_unlink(struct inode *dir, struct dentry *de)
{
int error;
const char *name = de->d_name.name;
int len = de->d_name.len;
lock_kernel();
coda_vfs_stat.unlink++;
error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);
if ( error ) {
unlock_kernel();
return error;
}
coda_dir_changed(dir, 0);
drop_nlink(de->d_inode);
unlock_kernel();
return 0;
}
static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
{
struct inode *inode;
struct coda_vattr attrs;
const char *name = de->d_name.name;
int len = de->d_name.len;
int error;
struct CodaFid newfid;
lock_kernel();
coda_vfs_stat.mkdir++;
if (coda_isroot(dir) && coda_iscontrol(name, len)) {
unlock_kernel();
return -EPERM;
}
attrs.va_mode = mode;
error = venus_mkdir(dir->i_sb, coda_i2f(dir),
name, len, &newfid, &attrs);
if ( error ) {
unlock_kernel();
d_drop(de);
return error;
}
inode = coda_iget(dir->i_sb, &newfid, &attrs);
if ( IS_ERR(inode) ) {
unlock_kernel();
d_drop(de);
return PTR_ERR(inode);
}
/* invalidate the directory cnode's attributes */
coda_dir_changed(dir, 1);
unlock_kernel();
d_instantiate(de, inode);
return 0;
}
/* creation routines: create, mknod, mkdir, link, symlink */
static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd)
{
int error=0;
const char *name=de->d_name.name;
int length=de->d_name.len;
struct inode *inode;
struct CodaFid newfid;
struct coda_vattr attrs;
lock_kernel();
coda_vfs_stat.create++;
if (coda_isroot(dir) && coda_iscontrol(name, length)) {
unlock_kernel();
return -EPERM;
}
error = venus_create(dir->i_sb, coda_i2f(dir), name, length,
0, mode, &newfid, &attrs);
if ( error ) {
unlock_kernel();
d_drop(de);
return error;
}
inode = coda_iget(dir->i_sb, &newfid, &attrs);
if ( IS_ERR(inode) ) {
unlock_kernel();
d_drop(de);
return PTR_ERR(inode);
}
/* invalidate the directory cnode's attributes */
coda_dir_changed(dir, 0);
unlock_kernel();
d_instantiate(de, inode);
return 0;
}
/* destruction routines: unlink, rmdir */
int coda_unlink(struct inode *dir, struct dentry *de)
{
int error;
const char *name = de->d_name.name;
int len = de->d_name.len;
coda_vfs_stat.unlink++;
CDEBUG(D_INODE, " %s in %s, dirino %ld\n", name ,
coda_i2s(dir), dir->i_ino);
error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);
if ( error ) {
CDEBUG(D_INODE, "upc returned error %d\n", error);
return error;
}
coda_dir_changed(dir, 0);
de->d_inode->i_nlink--;
return 0;
}
int coda_rmdir(struct inode *dir, struct dentry *de)
{
const char *name = de->d_name.name;
int len = de->d_name.len;
int error;
coda_vfs_stat.rmdir++;
if (!d_unhashed(de))
return -EBUSY;
error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
if ( error ) {
CDEBUG(D_INODE, "upc returned error %d\n", error);
return error;
}
coda_dir_changed(dir, -1);
de->d_inode->i_nlink--;
d_delete(de);
return 0;
}
