Lines Matching defs:dir
1348 * dir->d_inode->i_mutex must be held
1350 static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
1357 dentry = d_lookup(dir, name);
1375 dentry = d_alloc(dir, name);
1388 * dir->d_inode->i_mutex must be held
1390 static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
1396 if (unlikely(IS_DEADDIR(dir))) {
1401 old = dir->i_op->lookup(dir, dentry, flags);
2307 struct dentry *dir = nd->path.dentry;
2327 mutex_lock(&dir->d_inode->i_mutex);
2328 dentry = d_lookup(dir, &nd->last);
2335 dentry = d_alloc(dir, &nd->last);
2338 mutex_unlock(&dir->d_inode->i_mutex);
2341 dentry = lookup_real(dir->d_inode, dentry, nd->flags);
2344 mutex_unlock(&dir->d_inode->i_mutex);
2348 mutex_unlock(&dir->d_inode->i_mutex);
2455 int __check_sticky(struct inode *dir, struct inode *inode)
2461 if (uid_eq(dir->i_uid, fsuid))
2468 * Check whether we can remove a link victim from directory dir, check
2470 * 1. We can't do it if dir is read-only (done in permission())
2471 * 2. We should have write and exec permissions on dir
2472 * 3. We can't remove anything from append-only dir
2473 * 4. We can't do anything with immutable dir (done in permission())
2474 * 5. If the sticky bit on dir is set we should either
2475 * a. be owner of dir, or
2486 static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
2495 BUG_ON(victim->d_parent->d_inode != dir);
2496 audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
2498 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
2501 if (IS_APPEND(dir))
2504 if (check_sticky(dir, inode) || IS_APPEND(inode) ||
2514 if (IS_DEADDIR(dir))
2522 * dir.
2525 * 2. We can't do it if dir is read-only (done in permission())
2526 * 3. We should have write and exec permissions on dir
2527 * 4. We can't do it if dir is immutable (done in permission())
2529 static inline int may_create(struct inode *dir, struct dentry *child)
2531 audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
2534 if (IS_DEADDIR(dir))
2536 return inode_permission(dir, MAY_WRITE | MAY_EXEC);
2583 int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2586 int error = may_create(dir, dentry);
2590 if (!dir->i_op->create)
2594 error = security_inode_create(dir, dentry, mode);
2597 error = dir->i_op->create(dir, dentry, mode, want_excl);
2599 fsnotify_create(dir, dentry);
2685 static int may_o_create(struct path *dir, struct dentry *dentry, umode_t mode)
2687 int error = security_path_mknod(dir, dentry, mode, 0);
2691 error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
2695 return security_inode_create(dir->dentry->d_inode, dentry, mode);
2717 struct inode *dir = nd->path.dentry->d_inode;
2729 if (unlikely(IS_DEADDIR(dir))) {
2735 if ((open_flag & O_CREAT) && !IS_POSIXACL(dir))
2785 error = dir->i_op->atomic_open(dir, dentry, file, open_flag, mode,
2803 fsnotify_create(dir, dentry);
2826 fsnotify_create(dir, dentry);
2839 dentry = lookup_real(dir, dentry, nd->flags);
2876 struct dentry *dir = nd->path.dentry;
2877 struct inode *dir_inode = dir->d_inode;
2883 dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup);
2907 if (!IS_POSIXACL(dir->d_inode))
2924 error = vfs_create(dir->d_inode, dentry, mode,
2946 struct dentry *dir = nd->path.dentry;
2980 BUG_ON(nd->inode != dir->d_inode);
2992 audit_inode(name, dir, LOOKUP_PARENT);
3010 mutex_lock(&dir->d_inode->i_mutex);
3012 mutex_unlock(&dir->d_inode->i_mutex);
3166 BUG_ON(save_parent.dentry != dir);
3169 nd->inode = dir->d_inode;
3187 struct inode *dir;
3200 dir = dentry->d_inode;
3201 if (!dir->i_op->tmpfile) {
3214 error = dir->i_op->tmpfile(dir, nd->path.dentry, op->mode);
3453 int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
3455 int error = may_create(dir, dentry);
3463 if (!dir->i_op->mknod)
3470 error = security_inode_mknod(dir, dentry, mode, dev);
3474 error = dir->i_op->mknod(dir, dentry, mode, dev);
3476 fsnotify_create(dir, dentry);
3545 int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
3547 int error = may_create(dir, dentry);
3548 unsigned max_links = dir->i_sb->s_max_links;
3553 if (!dir->i_op->mkdir)
3557 error = security_inode_mkdir(dir, dentry, mode);
3561 if (max_links && dir->i_nlink >= max_links)
3564 error = dir->i_op->mkdir(dir, dentry, mode);
3566 fsnotify_mkdir(dir, dentry);
3626 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
3628 int error = may_delete(dir, dentry, 1);
3633 if (!dir->i_op->rmdir)
3643 error = security_inode_rmdir(dir, dentry);
3648 error = dir->i_op->rmdir(dir, dentry);
3729 * @dir: parent directory
3733 * The caller must hold dir->i_mutex.
3739 * dir->i_mutex before doing so.
3745 int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)
3748 int error = may_delete(dir, dentry, 0);
3753 if (!dir->i_op->unlink)
3760 error = security_inode_unlink(dir, dentry);
3765 error = dir->i_op->unlink(dir, dentry);
3878 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
3880 int error = may_create(dir, dentry);
3885 if (!dir->i_op->symlink)
3888 error = security_inode_symlink(dir, dentry, oldname);
3892 error = dir->i_op->symlink(dir, dentry, oldname);
3894 fsnotify_create(dir, dentry);
3938 * @dir: new parent
3942 * The caller must hold dir->i_mutex
3954 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)
3957 unsigned max_links = dir->i_sb->s_max_links;
3963 error = may_create(dir, new_dentry);
3967 if (dir->i_sb != inode->i_sb)
3975 if (!dir->i_op->link)
3980 error = security_inode_link(old_dentry, dir, new_dentry);
3993 error = dir->i_op->link(old_dentry, dir, new_dentry);
4003 fsnotify_link(dir, inode, new_dentry);
4425 int vfs_whiteout(struct inode *dir, struct dentry *dentry)
4427 int error = may_create(dir, dentry);
4431 if (!dir->i_op->mknod)
4434 return dir->i_op->mknod(dir, dentry,