/*===========================================================================* * verify_dentry * *===========================================================================*/ int verify_dentry( struct inode *parent, /* parent inode: the inode to verify */ char name[NAME_MAX+1], /* the given directory entry path component */ char path[PATH_MAX], /* buffer to store the resulting path in */ struct inode **res_ino /* pointer for addressed inode (or NULL) */ ) { /* Given a directory inode and a name, construct a path identifying that * directory entry, check whether the path to the parent is still valid, and * check whether there is an inode pointed to by the full path. Upon success, * res_ino will contain either the inode for the full path, with increased * refcount, or NULL if no such inode exists. */ int r; if ((r = verify_inode(parent, path, NULL)) != OK) return r; dprintf(("%s: verify_dentry: given path is '%s', name '%s'\n", sffs_name, path, name)); if ((r = push_path(path, name)) != OK) return r; dprintf(("%s: verify_dentry: path now '%s'\n", sffs_name, path)); *res_ino = lookup_dentry(parent, name); return OK; }
static struct dentry *snd_info_card_followlink(struct dentry *dentry, struct dentry *base, unsigned int follow) { char *s = ((struct proc_dir_entry *) dentry->d_inode->u.generic_ip)->data; return lookup_dentry(s, base, follow); }
static struct dentry * autofs_follow_link(struct dentry *dentry, struct dentry *base, unsigned int follow) { struct autofs_symlink *sl; sl = (struct autofs_symlink *)dentry->d_inode->u.generic_ip; return lookup_dentry(sl->data, base, follow); }
/*===========================================================================* * go_down * *===========================================================================*/ static int go_down( char path[PATH_MAX], /* path to add the name to */ struct inode *parent, /* inode of the current directory */ char *name, /* name of the directory entry */ struct inode **res_ino, /* place to store resulting inode */ struct sffs_attr *attr /* place to store inode attributes */ ) { /* Given a directory inode and a name, progress into a directory entry. */ struct inode *ino; int r, stale = 0; if ((r = push_path(path, name)) != OK) return r; dprintf(("%s: go_down: name '%s', path now '%s'\n", sffs_name, name, path)); ino = lookup_dentry(parent, name); dprintf(("%s: lookup_dentry('%s') returned %p\n", sffs_name, name, ino)); if (ino != NULL) r = verify_path(path, ino, attr, &stale); else r = sffs_table->t_getattr(path, attr); dprintf(("%s: path query returned %d\n", sffs_name, r)); if (r != OK) { if (ino != NULL) { put_inode(ino); ino = NULL; } if (!stale) return r; } dprintf(("%s: name '%s'\n", sffs_name, name)); if (ino == NULL) { if ((ino = get_free_inode()) == NULL) return ENFILE; dprintf(("%s: inode %p ref %d\n", sffs_name, ino, ino->i_ref)); ino->i_flags = MODE_TO_DIRFLAG(attr->a_mode); add_dentry(parent, name, ino); } *res_ino = ino; return OK; }
static struct dentry *devtree_follow_link(struct dentry *dentry, struct dentry *base, unsigned int follow) { struct inode *inode = dentry->d_inode; struct proc_dir_entry * de; char *link; de = (struct proc_dir_entry *) inode->u.generic_ip; link = (char *) de->data; return lookup_dentry(link, base, follow); }
static struct dentry *efs_follow_link(struct dentry *dentry, struct dentry *base, unsigned int follow) { char *name; struct inode *inode = dentry->d_inode; if (!(name = efs_linktarget(inode, NULL))) { dput(base); return ERR_PTR(-ELOOP); } base = lookup_dentry(name, base, follow); kfree(name); return base; }
static struct dentry *ncp_follow_link(struct dentry *dentry, struct dentry *base, unsigned int follow) { struct inode *inode=dentry->d_inode; int error, length, cnt; char *link; #ifdef DEBUG printk("ncp_follow_link(dentry=%p,base=%p,follow=%u)\n",dentry,base,follow); #endif if(!S_ISLNK(inode->i_mode)) { dput(base); return ERR_PTR(-EINVAL); } if(ncp_make_open(inode,O_RDONLY)) { dput(base); return ERR_PTR(-EIO); } for (cnt = 0; (link=(char *)kmalloc(NCP_MAX_SYMLINK_SIZE+1, GFP_NFS))==NULL; cnt++) { if (cnt > 10) { dput(base); return ERR_PTR(-EAGAIN); /* -ENOMEM? */ } schedule(); } error=ncp_read_kernel(NCP_SERVER(inode),NCP_FINFO(inode)->file_handle, 0,NCP_MAX_SYMLINK_SIZE,link,&length); if (error!=0 || length<NCP_MIN_SYMLINK_SIZE || ((__u32 *)link)[0]!=NCP_SYMLINK_MAGIC0 || ((__u32 *)link)[1]!=NCP_SYMLINK_MAGIC1) { dput(base); kfree(link); return ERR_PTR(-EIO); } link[length]=0; vol2io(NCP_SERVER(inode), link+8, 0); /* UPDATE_ATIME(inode); */ base=lookup_dentry(link+8, base, follow); kfree(link); return base; }
static struct dir_entry *path_to_dentry(struct vmm_blockdev *mdev, const char *path, struct dir_entry *pdentry) { char dirname[VFS_MAX_NAME] = { 0 }; struct dir_entry *dentry, *d_root; int i = 0, rd; int len = 0; char rpath[VFS_MAX_NAME]; len = strlen(path); if (!len) return NULL; vmm_snprintf(rpath, len, "%s", path); if (rpath[len - 1] != '/') { rpath[len] = '/'; rpath[len+1] = 0; } path = rpath; if (*path == '/') { path++; if (!*path) return pdentry; } while (*path && *path != '/') { dirname[i] = *path; path++; i++; } dentry = lookup_dentry(dirname, pdentry); if (dentry) { d_root = vmm_zalloc(dentry->dlen.lsb); rd = vmm_blockdev_read(mdev, (u8 *)d_root, (dentry->start_lba.lsb * 2048), dentry->dlen.lsb); if (rd != dentry->dlen.lsb) { vmm_free(d_root); return NULL; } dentry = path_to_dentry(mdev, path, d_root); } return dentry; }
static struct dentry *qnx4_follow_link(struct dentry *dentry, struct dentry *base, unsigned int follow) { struct inode *inode = dentry->d_inode; struct buffer_head *bh; if ( !inode ) { return ERR_PTR(-ENOENT); } if ( !( bh = qnx4_bread( inode, 0, 0 ) ) ) { dput( base ); return ERR_PTR(-EIO); } UPDATE_ATIME( inode ); base = lookup_dentry( bh->b_data, base, follow ); brelse( bh ); return base; }
void devfs_init(void) { int mode; /* Make sure there is a dev directory */ struct dentry *dentry = lookup_dentry("/dev/", 0); if (!dentry) { assert(!do_mkdir("/dev/", S_IRWXU | S_IRWXG | S_IRWXO)); } else { kref_put(&dentry->d_kref); } /* Notice we don't kref_put(). We're storing the refs globally */ dev_stdin = make_device("/dev/stdin", S_IRUSR | S_IRGRP | S_IROTH, __S_IFCHR, &dev_f_op_stdin); dev_stdout = make_device("/dev/stdout", S_IWUSR | S_IWGRP | S_IWOTH, __S_IFCHR, &dev_f_op_stdout); /* Note stderr uses the same f_op as stdout */ dev_stderr = make_device("/dev/stderr", S_IWUSR | S_IWGRP | S_IWOTH, __S_IFCHR, &dev_f_op_stdout); dev_null = make_device("/dev/null", S_IWUSR | S_IWGRP | S_IWOTH, __S_IFCHR, &dev_f_op_null); }
int osi_lookupname(char *aname, uio_seg_t seg, int followlink, struct dentry **dpp) { struct dentry *dp = NULL; int code; code = ENOENT; if (seg == AFS_UIOUSER) { dp = followlink ? namei(aname) : lnamei(aname); } else { dp = lookup_dentry(aname, NULL, followlink ? 1 : 0); } if (dp && !IS_ERR(dp)) { if (dp->d_inode) { *dpp = dp; code = 0; } else dput(dp); } return code; }
/* * Look up one component of a pathname. * N.B. After this call _both_ fhp and resfh need an fh_put */ int nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name, int len, struct svc_fh *resfh) { struct svc_export *exp; struct dentry *dparent, *dchild; int err; dprintk("nfsd: nfsd_lookup(fh %p, %s)\n", SVCFH_DENTRY(fhp), name); /* Obtain dentry and export. */ err = fh_verify(rqstp, fhp, S_IFDIR, MAY_EXEC); if (err) goto out; dparent = fhp->fh_dentry; exp = fhp->fh_export; #if 0 err = nfsd_permission(exp, dparent, MAY_EXEC); if (err) goto out; #endif err = nfserr_noent; if (fs_off_limits(dparent->d_sb)) goto out; err = nfserr_acces; if (nfsd_iscovered(dparent, exp)) goto out; /* Lookup the name, but don't follow links */ dchild = lookup_dentry(name, dget(dparent), 0); if (IS_ERR(dchild)) goto out_nfserr; /* * check if we have crossed a mount point ... */ if (dchild->d_sb != dparent->d_sb) { struct dentry *tdentry; tdentry = dchild->d_covers; if (tdentry == dchild) goto out_dput; dput(dchild); dchild = dget(tdentry); if (dchild->d_sb != dparent->d_sb) { printk("nfsd_lookup: %s/%s crossed mount point!\n", dparent->d_name.name, dchild->d_name.name); goto out_dput; } } /* * Note: we compose the file handle now, but as the * dentry may be negative, it may need to be updated. */ fh_compose(resfh, exp, dchild); err = nfserr_noent; if (dchild->d_inode) err = 0; out: return err; out_nfserr: err = nfserrno(-PTR_ERR(dchild)); goto out; out_dput: dput(dchild); err = nfserr_acces; goto out; }
int __init change_root(kdev_t new_root_dev,const char *put_old) { kdev_t old_root_dev; struct vfsmount *vfsmnt; struct dentry *old_root,*old_pwd,*dir_d = NULL; int error; old_root = current->fs->root; old_pwd = current->fs->pwd; old_root_dev = ROOT_DEV; if (!fs_may_mount(new_root_dev)) { printk(KERN_CRIT "New root is busy. Staying in initrd.\n"); return -EBUSY; } ROOT_DEV = new_root_dev; mount_root(); dput(old_root); dput(old_pwd); #if 1 shrink_dcache(); printk("change_root: old root has d_count=%d\n", old_root->d_count); #endif /* * Get the new mount directory */ dir_d = lookup_dentry(put_old, NULL, 1); if (IS_ERR(dir_d)) { error = PTR_ERR(dir_d); } else if (!dir_d->d_inode) { dput(dir_d); error = -ENOENT; } else { error = 0; } if (!error && dir_d->d_covers != dir_d) { dput(dir_d); error = -EBUSY; } if (!error && !S_ISDIR(dir_d->d_inode->i_mode)) { dput(dir_d); error = -ENOTDIR; } if (error) { int umount_error; printk(KERN_NOTICE "Trying to unmount old root ... "); umount_error = do_umount(old_root_dev,1, 0); if (!umount_error) { printk("okay\n"); /* special: the old device driver is going to be a ramdisk and the point of this call is to free its protected memory (even if dirty). */ destroy_buffers(old_root_dev); return 0; } printk(KERN_ERR "error %d\n",umount_error); return error; } remove_vfsmnt(old_root_dev); vfsmnt = add_vfsmnt(old_root->d_sb, "/dev/root.old", put_old); if (vfsmnt) { d_mount(dir_d,old_root); return 0; } printk(KERN_CRIT "Trouble: add_vfsmnt failed\n"); return -ENOMEM; }
/*===========================================================================* * do_getdents * *===========================================================================*/ int do_getdents() { /* Retrieve directory entries. */ char name[NAME_MAX+1]; struct inode *ino, *child; struct dirent *dent; struct sffs_attr attr; size_t len, off, user_off, user_left; off_t pos; int r; /* must be at least sizeof(struct dirent) + NAME_MAX */ static char buf[BLOCK_SIZE]; attr.a_mask = SFFS_ATTR_MODE; if ((ino = find_inode(m_in.REQ_INODE_NR)) == NULL) return EINVAL; if (m_in.REQ_SEEK_POS_HI != 0) return EINVAL; if (!IS_DIR(ino)) return ENOTDIR; /* We are going to need at least one free inode to store children in. */ if (!have_free_inode()) return ENFILE; /* If we don't have a directory handle yet, get one now. */ if ((r = get_handle(ino)) != OK) return r; off = 0; user_off = 0; user_left = m_in.REQ_MEM_SIZE; /* We use the seek position as file index number. The first position is for * the "." entry, the second position is for the ".." entry, and the next * position numbers each represent a file in the directory. */ for (pos = m_in.REQ_SEEK_POS_LO; ; pos++) { /* Determine which inode and name to use for this entry. * We have no idea whether the host will give us "." and/or "..", * so generate our own and skip those from the host. */ if (pos == 0) { /* Entry for ".". */ child = ino; strcpy(name, "."); get_inode(child); } else if (pos == 1) { /* Entry for "..", but only when there is a parent. */ if (ino->i_parent == NULL) continue; child = ino->i_parent; strcpy(name, ".."); get_inode(child); } else { /* Any other entry, not being "." or "..". */ r = sffs_table->t_readdir(ino->i_dir, pos - 2, name, sizeof(name), &attr); if (r != OK) { /* No more entries? Then close the handle and stop. */ if (r == ENOENT) { put_handle(ino); break; } /* FIXME: what if the error is ENAMETOOLONG? */ return r; } if (!strcmp(name, ".") || !strcmp(name, "..")) continue; if ((child = lookup_dentry(ino, name)) == NULL) { child = get_free_inode(); /* We were promised a free inode! */ assert(child != NULL); child->i_flags = MODE_TO_DIRFLAG(attr.a_mode); add_dentry(ino, name, child); } } len = DWORD_ALIGN(sizeof(struct dirent) + strlen(name)); /* Is the user buffer too small to store another record? * Note that we will be rerequesting the same dentry upon a subsequent * getdents call this way, but we really need the name length for this. */ if (user_off + off + len > user_left) { put_inode(child); /* Is the user buffer too small for even a single record? */ if (user_off == 0 && off == 0) return EINVAL; break; } /* If our own buffer cannot contain the new record, copy out first. */ if (off + len > sizeof(buf)) { r = sys_safecopyto(m_in.m_source, m_in.REQ_GRANT, user_off, (vir_bytes) buf, off, D); if (r != OK) { put_inode(child); return r; } user_off += off; user_left -= off; off = 0; } /* Fill in the actual directory entry. */ dent = (struct dirent *) &buf[off]; dent->d_ino = INODE_NR(child); dent->d_off = pos; dent->d_reclen = len; strcpy(dent->d_name, name); off += len; put_inode(child); } /* If there is anything left in our own buffer, copy that out now. */ if (off > 0) { r = sys_safecopyto(m_in.m_source, m_in.REQ_GRANT, user_off, (vir_bytes) buf, off, D); if (r != OK) return r; user_off += off; } m_out.RES_SEEK_POS_HI = 0; m_out.RES_SEEK_POS_LO = pos; m_out.RES_NBYTES = user_off; return OK; }
/* * Create a hardlink * N.B. After this call _both_ ffhp and tfhp need an fh_put */ int nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int len, struct svc_fh *tfhp) { struct dentry *ddir, *dnew, *dold; struct inode *dirp, *dest; int err; err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_CREATE); if (err) goto out; err = fh_verify(rqstp, tfhp, S_IFREG, MAY_NOP); if (err) goto out; err = nfserr_perm; if (!len) goto out; ddir = ffhp->fh_dentry; dirp = ddir->d_inode; dnew = lookup_dentry(fname, dget(ddir), 0); err = PTR_ERR(dnew); if (IS_ERR(dnew)) goto out_nfserr; /* * Lock the parent before checking for existence */ err = fh_lock_parent(ffhp, dnew); if (err) goto out_dput; err = nfserr_exist; if (dnew->d_inode) goto out_unlock; dold = tfhp->fh_dentry; dest = dold->d_inode; err = nfserr_acces; if (nfsd_iscovered(ddir, ffhp->fh_export)) goto out_unlock; /* FIXME: nxdev for NFSv3 */ if (dirp->i_dev != dest->i_dev) goto out_unlock; err = nfserr_perm; if (IS_IMMUTABLE(dest) /* || IS_APPEND(dest) */ ) goto out_unlock; if (!dirp->i_op || !dirp->i_op->link) goto out_unlock; DQUOT_INIT(dirp); err = dirp->i_op->link(dold, dirp, dnew); DQUOT_DROP(dirp); if (!err) { if (EX_ISSYNC(ffhp->fh_export)) { write_inode_now(dirp); write_inode_now(dest); } } else err = nfserrno(-err); out_unlock: fh_unlock(ffhp); out_dput: dput(dnew); out: return err; out_nfserr: err = nfserrno(-err); goto out; }
/* * Create a symlink and look up its inode * N.B. After this call _both_ fhp and resfhp need an fh_put */ int nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *fname, int flen, char *path, int plen, struct svc_fh *resfhp) { struct dentry *dentry, *dnew; struct inode *dirp; int err; err = nfserr_noent; if (!flen || !plen) goto out; err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE); if (err) goto out; dentry = fhp->fh_dentry; err = nfserr_perm; if (nfsd_iscovered(dentry, fhp->fh_export)) goto out; dirp = dentry->d_inode; if (!dirp->i_op || !dirp->i_op->symlink) goto out; dnew = lookup_dentry(fname, dget(dentry), 0); err = PTR_ERR(dnew); if (IS_ERR(dnew)) goto out_nfserr; /* * Lock the parent before checking for existence */ err = fh_lock_parent(fhp, dnew); if (err) goto out_compose; err = nfserr_exist; if (!dnew->d_inode) { DQUOT_INIT(dirp); err = dirp->i_op->symlink(dirp, dnew, path); DQUOT_DROP(dirp); if (!err) { if (EX_ISSYNC(fhp->fh_export)) write_inode_now(dirp); } else err = nfserrno(-err); } fh_unlock(fhp); /* Compose the fh so the dentry will be freed ... */ out_compose: fh_compose(resfhp, fhp->fh_export, dnew); out: return err; out_nfserr: err = nfserrno(-err); goto out; }
/* * Create a file (regular, directory, device, fifo); UNIX sockets * not yet implemented. * If the response fh has been verified, the parent directory should * already be locked. Note that the parent directory is left locked. * * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp */ int nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, char *fname, int flen, struct iattr *iap, int type, dev_t rdev, struct svc_fh *resfhp) { struct dentry *dentry, *dchild; struct inode *dirp; nfsd_dirop_t opfunc = NULL; int err; err = nfserr_perm; if (!flen) goto out; err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE); if (err) goto out; dentry = fhp->fh_dentry; dirp = dentry->d_inode; err = nfserr_notdir; if(!dirp->i_op || !dirp->i_op->lookup) goto out; /* * Check whether the response file handle has been verified yet. * If it has, the parent directory should already be locked. */ if (!resfhp->fh_dverified) { dchild = lookup_dentry(fname, dget(dentry), 0); err = PTR_ERR(dchild); if (IS_ERR(dchild)) goto out_nfserr; fh_compose(resfhp, fhp->fh_export, dchild); /* Lock the parent and check for errors ... */ err = fh_lock_parent(fhp, dchild); if (err) goto out; } else { dchild = resfhp->fh_dentry; if (!fhp->fh_locked) printk(KERN_ERR "nfsd_create: parent %s/%s not locked!\n", dentry->d_parent->d_name.name, dentry->d_name.name); } /* * Make sure the child dentry is still negative ... */ err = nfserr_exist; if (dchild->d_inode) { printk(KERN_WARNING "nfsd_create: dentry %s/%s not negative!\n", dentry->d_name.name, dchild->d_name.name); goto out; } /* * Get the dir op function pointer. */ err = nfserr_perm; switch (type) { case S_IFREG: opfunc = (nfsd_dirop_t) dirp->i_op->create; break; case S_IFDIR: opfunc = (nfsd_dirop_t) dirp->i_op->mkdir; break; case S_IFCHR: case S_IFBLK: /* The client is _NOT_ required to do security enforcement */ if(!capable(CAP_SYS_ADMIN)) { err = -EPERM; goto out; } case S_IFIFO: case S_IFSOCK: opfunc = dirp->i_op->mknod; break; } if (!opfunc) goto out; if (!(iap->ia_valid & ATTR_MODE)) iap->ia_mode = 0; /* * Call the dir op function to create the object. */ DQUOT_INIT(dirp); err = opfunc(dirp, dchild, iap->ia_mode, rdev); DQUOT_DROP(dirp); if (err < 0) goto out_nfserr; if (EX_ISSYNC(fhp->fh_export)) write_inode_now(dirp); /* * Update the file handle to get the new inode info. */ fh_update(resfhp); /* Set file attributes. Mode has already been set and * setting uid/gid works only for root. Irix appears to * send along the gid when it tries to implement setgid * directories via NFS. */ err = 0; if ((iap->ia_valid &= (ATTR_UID|ATTR_GID|ATTR_MODE)) != 0) err = nfsd_setattr(rqstp, resfhp, iap); out: return err; out_nfserr: err = nfserrno(-err); goto out; }
static char *resolv_virt(const char *pathname, int must_exist, int flags) { struct dentry *root, *origroot; struct dentry *dentry; char *newpathname = NULL; char *page = NULL; char *path = NULL; int pathlen = 0; lock_kernel(); DEB((KERN_INFO "resolve_virt pathname: '%s'\n", pathname ? pathname : "(null)")); root = lookup_dentry(OVERLAY_DIR, NULL, 1); if(IS_ERR(root)) goto out; if(!root->d_inode) { dput(root); goto out; } origroot = current->fs->root; current->fs->root = root; dentry = lookup_dentry(pathname, NULL, flags); if(!IS_ERR(dentry)) { if((!must_exist || dentry->d_inode) && path_ok(dentry)) { page = (char *) __get_free_page(GFP_USER); if(page) { path = d_path(dentry, page, PAGE_SIZE); DEB((KERN_INFO "resolve_virt path = '%s'\n", path)); pathlen = (unsigned int) page + PAGE_SIZE - (unsigned int) path; } } dput(dentry); } current->fs->root = origroot; dput(root); if(path) { int isvirtual; dentry = lookup_dentry(path, NULL, flags); if(!IS_ERR(dentry)) { if(dentry->d_inode) isvirtual = 0; else if(must_exist) isvirtual = 1; else if(strchr(path, AVFS_MAGIC_CHAR)) isvirtual = 1; else isvirtual = 0; dput(dentry); } else { isvirtual = 1; } if(!isvirtual) { newpathname = kmalloc(pathlen + 1, GFP_USER); if(newpathname) strncpy(newpathname, path, pathlen); } else { newpathname = kmalloc(OVERLAY_DIR_LEN + pathlen + 1, GFP_USER); if(newpathname) { strcpy(newpathname, OVERLAY_DIR); strncat(newpathname, path, pathlen); } } } if(page) free_page((unsigned long) page); DEB((KERN_INFO "resolve_virt newpathname: '%s'\n", newpathname ? newpathname : "(null)")); out: unlock_kernel(); return newpathname; }
/* * Unlink a file or directory * N.B. After this call fhp needs an fh_put */ int nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, char *fname, int flen) { struct dentry *dentry, *rdentry; struct inode *dirp; int err; /* N.B. We shouldn't need this test ... handled by dentry layer */ err = nfserr_acces; if (!flen || isdotent(fname, flen)) goto out; err = fh_verify(rqstp, fhp, S_IFDIR, MAY_REMOVE); if (err) goto out; dentry = fhp->fh_dentry; dirp = dentry->d_inode; rdentry = lookup_dentry(fname, dget(dentry), 0); err = PTR_ERR(rdentry); if (IS_ERR(rdentry)) goto out_nfserr; if (!rdentry->d_inode) { dput(rdentry); err = nfserr_noent; goto out; } if (type != S_IFDIR) { /* It's UNLINK */ err = fh_lock_parent(fhp, rdentry); if (err) goto out; err = vfs_unlink(dirp, rdentry); DQUOT_DROP(dirp); fh_unlock(fhp); dput(rdentry); } else { /* It's RMDIR */ /* See comments in fs/namei.c:do_rmdir */ rdentry->d_count++; nfsd_double_down(&dirp->i_sem, &rdentry->d_inode->i_sem); if (!fhp->fh_pre_mtime) fhp->fh_pre_mtime = dirp->i_mtime; fhp->fh_locked = 1; err = -ENOENT; if (check_parent(dirp, rdentry)) err = vfs_rmdir(dirp, rdentry); rdentry->d_count--; DQUOT_DROP(dirp); if (!fhp->fh_post_version) fhp->fh_post_version = dirp->i_version; fhp->fh_locked = 0; nfsd_double_up(&dirp->i_sem, &rdentry->d_inode->i_sem); dput(rdentry); } if (err) goto out_nfserr; if (EX_ISSYNC(fhp->fh_export)) write_inode_now(dirp); out: return err; out_nfserr: err = nfserrno(-err); goto out; }
/* * Rename a file * N.B. After this call _both_ ffhp and tfhp need an fh_put */ int nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, struct svc_fh *tfhp, char *tname, int tlen) { struct dentry *fdentry, *tdentry, *odentry, *ndentry; struct inode *fdir, *tdir; int err; err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_REMOVE); if (err) goto out; err = fh_verify(rqstp, tfhp, S_IFDIR, MAY_CREATE); if (err) goto out; fdentry = ffhp->fh_dentry; fdir = fdentry->d_inode; tdentry = tfhp->fh_dentry; tdir = tdentry->d_inode; /* N.B. We shouldn't need this ... dentry layer handles it */ err = nfserr_perm; if (!flen || (fname[0] == '.' && (flen == 1 || (flen == 2 && fname[1] == '.'))) || !tlen || (tname[0] == '.' && (tlen == 1 || (tlen == 2 && tname[1] == '.')))) goto out; odentry = lookup_dentry(fname, dget(fdentry), 0); err = PTR_ERR(odentry); if (IS_ERR(odentry)) goto out_nfserr; err = -ENOENT; if (!odentry->d_inode) goto out_dput_old; ndentry = lookup_dentry(tname, dget(tdentry), 0); err = PTR_ERR(ndentry); if (IS_ERR(ndentry)) goto out_dput_old; /* * Lock the parent directories. */ nfsd_double_down(&tdir->i_sem, &fdir->i_sem); err = -ENOENT; /* GAM3 check for parent changes after locking. */ if (check_parent(fdir, odentry) && check_parent(tdir, ndentry)) { err = vfs_rename(fdir, odentry, tdir, ndentry); if (!err && EX_ISSYNC(tfhp->fh_export)) { write_inode_now(fdir); write_inode_now(tdir); } } else dprintk("nfsd: Caught race in nfsd_rename"); DQUOT_DROP(fdir); DQUOT_DROP(tdir); nfsd_double_up(&tdir->i_sem, &fdir->i_sem); dput(ndentry); out_dput_old: dput(odentry); if (err) goto out_nfserr; out: return err; out_nfserr: err = nfserrno(-err); goto out; }
/*===========================================================================* * do_getdents * *===========================================================================*/ ssize_t do_getdents(ino_t ino_nr, struct fsdriver_data *data, size_t bytes, off_t *posp) { /* Retrieve directory entries. */ struct fsdriver_dentry fsdentry; char name[NAME_MAX+1]; struct inode *ino, *child; struct sffs_attr attr; off_t pos; int r; /* must be at least sizeof(struct dirent) + NAME_MAX */ static char buf[BLOCK_SIZE]; if ((ino = find_inode(ino_nr)) == NULL) return EINVAL; if (!IS_DIR(ino)) return ENOTDIR; if (*posp < 0 || *posp >= ULONG_MAX) return EINVAL; /* We are going to need at least one free inode to store children in. */ if (!have_free_inode()) return ENFILE; /* If we don't have a directory handle yet, get one now. */ if ((r = get_handle(ino)) != OK) return r; fsdriver_dentry_init(&fsdentry, data, bytes, buf, sizeof(buf)); /* We use the seek position as file index number. The first position is for * the "." entry, the second position is for the ".." entry, and the next * position numbers each represent a file in the directory. */ do { /* Determine which inode and name to use for this entry. * We have no idea whether the host will give us "." and/or "..", * so generate our own and skip those from the host. */ pos = (*posp)++; if (pos == 0) { /* Entry for ".". */ child = ino; strcpy(name, "."); get_inode(child); } else if (pos == 1) { /* Entry for "..", but only when there is a parent. */ if (ino->i_parent == NULL) continue; child = ino->i_parent; strcpy(name, ".."); get_inode(child); } else { /* Any other entry, not being "." or "..". */ attr.a_mask = SFFS_ATTR_MODE; r = sffs_table->t_readdir(ino->i_dir, pos - 2, name, sizeof(name), &attr); if (r != OK) { /* No more entries? Then close the handle and stop. */ if (r == ENOENT) { put_handle(ino); break; } /* FIXME: what if the error is ENAMETOOLONG? */ return r; } if (!strcmp(name, ".") || !strcmp(name, "..")) continue; if ((child = lookup_dentry(ino, name)) == NULL) { child = get_free_inode(); /* We were promised a free inode! */ assert(child != NULL); child->i_flags = MODE_TO_DIRFLAG(attr.a_mode); add_dentry(ino, name, child); } } r = fsdriver_dentry_add(&fsdentry, INODE_NR(child), name, strlen(name), IS_DIR(child) ? DT_DIR : DT_REG); put_inode(child); if (r < 0) return r; } while (r > 0); return fsdriver_dentry_finish(&fsdentry); }