Lines Matching refs:nd
632 static bool nd_alloc_stack(struct nameidata *nd)
637 nd->flags & LOOKUP_RCU ? GFP_ATOMIC : GFP_KERNEL);
640 memcpy(p, nd->internal, sizeof(nd->internal));
641 nd->stack = p;
664 static void drop_links(struct nameidata *nd)
666 int i = nd->depth;
668 struct saved *last = nd->stack + i;
674 static void leave_rcu(struct nameidata *nd)
676 nd->flags &= ~LOOKUP_RCU;
677 nd->seq = nd->next_seq = 0;
681 static void terminate_walk(struct nameidata *nd)
683 drop_links(nd);
684 if (!(nd->flags & LOOKUP_RCU)) {
686 path_put(&nd->path);
687 for (i = 0; i < nd->depth; i++)
688 path_put(&nd->stack[i].link);
689 if (nd->state & ND_ROOT_GRABBED) {
690 path_put(&nd->root);
691 nd->state &= ~ND_ROOT_GRABBED;
694 leave_rcu(nd);
696 nd->depth = 0;
697 nd->path.mnt = NULL;
698 nd->path.dentry = NULL;
718 static inline bool legitimize_path(struct nameidata *nd,
721 return __legitimize_path(path, seq, nd->m_seq);
724 static bool legitimize_links(struct nameidata *nd)
727 if (unlikely(nd->flags & LOOKUP_CACHED)) {
728 drop_links(nd);
729 nd->depth = 0;
732 for (i = 0; i < nd->depth; i++) {
733 struct saved *last = nd->stack + i;
734 if (unlikely(!legitimize_path(nd, &last->link, last->seq))) {
735 drop_links(nd);
736 nd->depth = i + 1;
743 static bool legitimize_root(struct nameidata *nd)
745 /* Nothing to do if nd->root is zero or is managed by the VFS user. */
746 if (!nd->root.mnt || (nd->state & ND_ROOT_PRESET))
748 nd->state |= ND_ROOT_GRABBED;
749 return legitimize_path(nd, &nd->root, nd->root_seq);
765 * @nd: nameidata pathwalk data
768 * try_to_unlazy attempts to legitimize the current nd->path and nd->root
774 static bool try_to_unlazy(struct nameidata *nd)
776 struct dentry *parent = nd->path.dentry;
778 BUG_ON(!(nd->flags & LOOKUP_RCU));
780 if (unlikely(!legitimize_links(nd)))
782 if (unlikely(!legitimize_path(nd, &nd->path, nd->seq)))
784 if (unlikely(!legitimize_root(nd)))
786 leave_rcu(nd);
787 BUG_ON(nd->inode != parent->d_inode);
791 nd->path.mnt = NULL;
792 nd->path.dentry = NULL;
794 leave_rcu(nd);
800 * @nd: nameidata pathwalk data
806 * nd->path and nd->root for ref-walk mode. Must be called from rcu-walk context.
810 static bool try_to_unlazy_next(struct nameidata *nd, struct dentry *dentry)
813 BUG_ON(!(nd->flags & LOOKUP_RCU));
815 if (unlikely(!legitimize_links(nd)))
817 res = __legitimize_mnt(nd->path.mnt, nd->m_seq);
823 if (unlikely(!lockref_get_not_dead(&nd->path.dentry->d_lockref)))
835 if (read_seqcount_retry(&dentry->d_seq, nd->next_seq))
841 if (unlikely(!legitimize_root(nd)))
843 leave_rcu(nd);
847 nd->path.mnt = NULL;
849 nd->path.dentry = NULL;
851 leave_rcu(nd);
854 leave_rcu(nd);
869 * @nd: pointer nameidata
871 * If we had been in RCU mode, drop out of it and legitimize nd->path.
875 * need to drop nd->path.
877 static int complete_walk(struct nameidata *nd)
879 struct dentry *dentry = nd->path.dentry;
882 if (nd->flags & LOOKUP_RCU) {
884 * We don't want to zero nd->root for scoped-lookups or
885 * externally-managed nd->root.
887 if (!(nd->state & ND_ROOT_PRESET))
888 if (!(nd->flags & LOOKUP_IS_SCOPED))
889 nd->root.mnt = NULL;
890 nd->flags &= ~LOOKUP_CACHED;
891 if (!try_to_unlazy(nd))
895 if (unlikely(nd->flags & LOOKUP_IS_SCOPED)) {
912 if (!path_is_under(&nd->path, &nd->root))
916 if (likely(!(nd->state & ND_JUMPED)))
922 status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);
932 static int set_root(struct nameidata *nd)
941 if (WARN_ON(nd->flags & LOOKUP_IS_SCOPED))
944 if (nd->flags & LOOKUP_RCU) {
949 nd->root = fs->root;
950 nd->root_seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
953 get_fs_root(fs, &nd->root);
954 nd->state |= ND_ROOT_GRABBED;
959 static int nd_jump_root(struct nameidata *nd)
961 if (unlikely(nd->flags & LOOKUP_BENEATH))
963 if (unlikely(nd->flags & LOOKUP_NO_XDEV)) {
965 if (nd->path.mnt != NULL && nd->path.mnt != nd->root.mnt)
968 if (!nd->root.mnt) {
969 int error = set_root(nd);
973 if (nd->flags & LOOKUP_RCU) {
975 nd->path = nd->root;
976 d = nd->path.dentry;
977 nd->inode = d->d_inode;
978 nd->seq = nd->root_seq;
979 if (read_seqcount_retry(&d->d_seq, nd->seq))
982 path_put(&nd->path);
983 nd->path = nd->root;
984 path_get(&nd->path);
985 nd->inode = nd->path.dentry->d_inode;
987 nd->state |= ND_JUMPED;
998 struct nameidata *nd = current->nameidata;
1000 if (unlikely(nd->flags & LOOKUP_NO_MAGICLINKS))
1004 if (unlikely(nd->flags & LOOKUP_NO_XDEV)) {
1005 if (nd->path.mnt != path->mnt)
1009 if (unlikely(nd->flags & LOOKUP_IS_SCOPED))
1012 path_put(&nd->path);
1013 nd->path = *path;
1014 nd->inode = nd->path.dentry->d_inode;
1015 nd->state |= ND_JUMPED;
1023 static inline void put_link(struct nameidata *nd)
1025 struct saved *last = nd->stack + --nd->depth;
1027 if (!(nd->flags & LOOKUP_RCU))
1088 * @nd: nameidata pathwalk data
1102 static inline int may_follow_link(struct nameidata *nd, const struct inode *inode)
1110 idmap = mnt_idmap(nd->path.mnt);
1117 if ((nd->dir_mode & (S_ISVTX|S_IWOTH)) != (S_ISVTX|S_IWOTH))
1121 if (vfsuid_valid(nd->dir_vfsuid) && vfsuid_eq(nd->dir_vfsuid, vfsuid))
1124 if (nd->flags & LOOKUP_RCU)
1127 audit_inode(nd->name, nd->stack[0].link.dentry, 0);
1216 * @nd: nameidata pathwalk data
1239 struct nameidata *nd, struct inode *const inode)
1241 umode_t dir_mode = nd->dir_mode;
1242 vfsuid_t dir_vfsuid = nd->dir_vfsuid;
1484 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path)
1492 if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1512 nd->state |= ND_JUMPED;
1513 nd->next_seq = read_seqcount_begin(&dentry->d_seq);
1517 if (read_seqretry(&mount_lock, nd->m_seq))
1521 if (read_seqretry(&mount_lock, nd->m_seq))
1528 static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,
1534 path->mnt = nd->path.mnt;
1536 if (nd->flags & LOOKUP_RCU) {
1537 unsigned int seq = nd->next_seq;
1538 if (likely(__follow_mount_rcu(nd, path)))
1540 // *path and nd->next_seq might've been clobbered
1541 path->mnt = nd->path.mnt;
1543 nd->next_seq = seq;
1544 if (!try_to_unlazy_next(nd, dentry))
1547 ret = traverse_mounts(path, &jumped, &nd->total_link_count, nd->flags);
1549 if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1552 nd->state |= ND_JUMPED;
1556 if (path->mnt != nd->path.mnt)
1618 static struct dentry *lookup_fast(struct nameidata *nd)
1620 struct dentry *dentry, *parent = nd->path.dentry;
1628 if (nd->flags & LOOKUP_RCU) {
1629 dentry = __d_lookup_rcu(parent, &nd->last, &nd->next_seq);
1631 if (!try_to_unlazy(nd))
1640 if (read_seqcount_retry(&parent->d_seq, nd->seq))
1643 status = d_revalidate(dentry, nd->flags);
1646 if (!try_to_unlazy_next(nd, dentry))
1650 status = d_revalidate(dentry, nd->flags);
1652 dentry = __d_lookup(parent, &nd->last);
1655 status = d_revalidate(dentry, nd->flags);
1717 struct nameidata *nd)
1719 if (nd->flags & LOOKUP_RCU) {
1720 int err = inode_permission(idmap, nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
1721 if (err != -ECHILD || !try_to_unlazy(nd))
1724 return inode_permission(idmap, nd->inode, MAY_EXEC);
1727 static int reserve_stack(struct nameidata *nd, struct path *link)
1729 if (unlikely(nd->total_link_count++ >= MAXSYMLINKS))
1732 if (likely(nd->depth != EMBEDDED_LEVELS))
1734 if (likely(nd->stack != nd->internal))
1736 if (likely(nd_alloc_stack(nd)))
1739 if (nd->flags & LOOKUP_RCU) {
1742 bool grabbed_link = legitimize_path(nd, link, nd->next_seq);
1744 if (!try_to_unlazy(nd) || !grabbed_link)
1747 if (nd_alloc_stack(nd))
1755 static const char *pick_link(struct nameidata *nd, struct path *link,
1760 int error = reserve_stack(nd, link);
1763 if (!(nd->flags & LOOKUP_RCU))
1767 last = nd->stack + nd->depth++;
1770 last->seq = nd->next_seq;
1773 error = may_follow_link(nd, inode);
1778 if (unlikely(nd->flags & LOOKUP_NO_SYMLINKS) ||
1782 if (!(nd->flags & LOOKUP_RCU)) {
1786 if (!try_to_unlazy(nd))
1792 nd->flags & LOOKUP_RCU);
1801 if (nd->flags & LOOKUP_RCU) {
1803 if (res == ERR_PTR(-ECHILD) && try_to_unlazy(nd))
1814 error = nd_jump_root(nd);
1823 put_link(nd);
1833 * NOTE: dentry must be what nd->next_seq had been sampled from.
1835 static const char *step_into(struct nameidata *nd, int flags,
1840 int err = handle_mounts(nd, dentry, &path);
1846 ((flags & WALK_TRAILING) && !(nd->flags & LOOKUP_FOLLOW)) ||
1849 if (nd->flags & LOOKUP_RCU) {
1850 if (read_seqcount_retry(&path.dentry->d_seq, nd->next_seq))
1855 dput(nd->path.dentry);
1856 if (nd->path.mnt != path.mnt)
1857 mntput(nd->path.mnt);
1859 nd->path = path;
1860 nd->inode = inode;
1861 nd->seq = nd->next_seq;
1864 if (nd->flags & LOOKUP_RCU) {
1866 if (read_seqcount_retry(&path.dentry->d_seq, nd->next_seq))
1869 if (path.mnt == nd->path.mnt)
1872 return pick_link(nd, &path, inode, flags);
1875 static struct dentry *follow_dotdot_rcu(struct nameidata *nd)
1879 if (path_equal(&nd->path, &nd->root))
1881 if (unlikely(nd->path.dentry == nd->path.mnt->mnt_root)) {
1884 if (!choose_mountpoint_rcu(real_mount(nd->path.mnt),
1885 &nd->root, &path, &seq))
1887 if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1889 nd->path = path;
1890 nd->inode = path.dentry->d_inode;
1891 nd->seq = seq;
1893 if (read_seqretry(&mount_lock, nd->m_seq))
1897 old = nd->path.dentry;
1899 nd->next_seq = read_seqcount_begin(&parent->d_seq);
1901 if (read_seqcount_retry(&old->d_seq, nd->seq))
1903 if (unlikely(!path_connected(nd->path.mnt, parent)))
1907 if (read_seqretry(&mount_lock, nd->m_seq))
1909 if (unlikely(nd->flags & LOOKUP_BENEATH))
1911 nd->next_seq = nd->seq;
1912 return nd->path.dentry;
1915 static struct dentry *follow_dotdot(struct nameidata *nd)
1919 if (path_equal(&nd->path, &nd->root))
1921 if (unlikely(nd->path.dentry == nd->path.mnt->mnt_root)) {
1924 if (!choose_mountpoint(real_mount(nd->path.mnt),
1925 &nd->root, &path))
1927 path_put(&nd->path);
1928 nd->path = path;
1929 nd->inode = path.dentry->d_inode;
1930 if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1934 parent = dget_parent(nd->path.dentry);
1935 if (unlikely(!path_connected(nd->path.mnt, parent))) {
1942 if (unlikely(nd->flags & LOOKUP_BENEATH))
1944 return dget(nd->path.dentry);
1947 static const char *handle_dots(struct nameidata *nd, int type)
1953 if (!nd->root.mnt) {
1954 error = ERR_PTR(set_root(nd));
1958 if (nd->flags & LOOKUP_RCU)
1959 parent = follow_dotdot_rcu(nd);
1961 parent = follow_dotdot(nd);
1964 error = step_into(nd, WALK_NOFOLLOW, parent);
1968 if (unlikely(nd->flags & LOOKUP_IS_SCOPED)) {
1972 * above nd->root (and so userspace should retry or use
1976 if (__read_seqcount_retry(&mount_lock.seqcount, nd->m_seq))
1978 if (__read_seqcount_retry(&rename_lock.seqcount, nd->r_seq))
1985 static const char *walk_component(struct nameidata *nd, int flags)
1993 if (unlikely(nd->last_type != LAST_NORM)) {
1994 if (!(flags & WALK_MORE) && nd->depth)
1995 put_link(nd);
1996 return handle_dots(nd, nd->last_type);
1998 dentry = lookup_fast(nd);
2002 dentry = lookup_slow(&nd->last, nd->path.dentry, nd->flags);
2006 if (!(flags & WALK_MORE) && nd->depth)
2007 put_link(nd);
2008 return step_into(nd, flags, dentry);
2244 * Returns 0 and nd will have valid dentry and mnt on success.
2247 static int link_path_walk(const char *name, struct nameidata *nd)
2249 int depth = 0; // depth <= nd->depth
2252 nd->last_type = LAST_ROOT;
2253 nd->flags |= LOOKUP_PARENT;
2259 nd->dir_mode = 0; // short-circuit the 'hardening' idiocy
2270 idmap = mnt_idmap(nd->path.mnt);
2271 err = may_lookup(idmap, nd);
2275 hash_len = hash_name(nd->path.dentry, name);
2282 nd->state |= ND_JUMPED;
2289 struct dentry *parent = nd->path.dentry;
2290 nd->state &= ~ND_JUMPED;
2301 nd->last.hash_len = hash_len;
2302 nd->last.name = name;
2303 nd->last_type = type;
2319 nd->dir_vfsuid = i_uid_into_vfsuid(idmap, nd->inode);
2320 nd->dir_mode = nd->inode->i_mode;
2321 nd->flags &= ~LOOKUP_PARENT;
2325 name = nd->stack[--depth].name;
2326 link = walk_component(nd, 0);
2329 link = walk_component(nd, WALK_MORE);
2335 nd->stack[depth++].name = name;
2339 if (unlikely(!d_can_lookup(nd->path.dentry))) {
2340 if (nd->flags & LOOKUP_RCU) {
2341 if (!try_to_unlazy(nd))
2350 static const char *path_init(struct nameidata *nd, unsigned flags)
2353 const char *s = nd->name->name;
2364 nd->seq = nd->next_seq = 0;
2366 nd->flags = flags;
2367 nd->state |= ND_JUMPED;
2369 nd->m_seq = __read_seqcount_begin(&mount_lock.seqcount);
2370 nd->r_seq = __read_seqcount_begin(&rename_lock.seqcount);
2373 if (nd->state & ND_ROOT_PRESET) {
2374 struct dentry *root = nd->root.dentry;
2378 nd->path = nd->root;
2379 nd->inode = inode;
2381 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
2382 nd->root_seq = nd->seq;
2384 path_get(&nd->path);
2389 nd->root.mnt = NULL;
2391 /* Absolute pathname -- fetch the root (LOOKUP_IN_ROOT uses nd->dfd). */
2393 error = nd_jump_root(nd);
2400 if (nd->dfd == AT_FDCWD) {
2407 nd->path = fs->pwd;
2408 nd->inode = nd->path.dentry->d_inode;
2409 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
2412 get_fs_pwd(current->fs, &nd->path);
2413 nd->inode = nd->path.dentry->d_inode;
2417 struct fd f = fdget_raw(nd->dfd);
2430 nd->path = f.file->f_path;
2432 nd->inode = nd->path.dentry->d_inode;
2433 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
2435 path_get(&nd->path);
2436 nd->inode = nd->path.dentry->d_inode;
2443 nd->root = nd->path;
2445 nd->root_seq = nd->seq;
2447 path_get(&nd->root);
2448 nd->state |= ND_ROOT_GRABBED;
2454 static inline const char *lookup_last(struct nameidata *nd)
2456 if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
2457 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2459 return walk_component(nd, WALK_TRAILING);
2462 static int handle_lookup_down(struct nameidata *nd)
2464 if (!(nd->flags & LOOKUP_RCU))
2465 dget(nd->path.dentry);
2466 nd->next_seq = nd->seq;
2467 return PTR_ERR(step_into(nd, WALK_NOFOLLOW, nd->path.dentry));
2470 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
2471 static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path)
2473 const char *s = path_init(nd, flags);
2477 err = handle_lookup_down(nd);
2482 while (!(err = link_path_walk(s, nd)) &&
2483 (s = lookup_last(nd)) != NULL)
2485 if (!err && unlikely(nd->flags & LOOKUP_MOUNTPOINT)) {
2486 err = handle_lookup_down(nd);
2487 nd->state &= ~ND_JUMPED; // no d_weak_revalidate(), please...
2490 err = complete_walk(nd);
2492 if (!err && nd->flags & LOOKUP_DIRECTORY)
2493 if (!d_can_lookup(nd->path.dentry))
2496 *path = nd->path;
2497 nd->path.mnt = NULL;
2498 nd->path.dentry = NULL;
2500 terminate_walk(nd);
2508 struct nameidata nd;
2511 set_nameidata(&nd, dfd, name, root);
2512 retval = path_lookupat(&nd, flags | LOOKUP_RCU, path);
2514 retval = path_lookupat(&nd, flags, path);
2516 retval = path_lookupat(&nd, flags | LOOKUP_REVAL, path);
2525 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
2526 static int path_parentat(struct nameidata *nd, unsigned flags,
2529 const char *s = path_init(nd, flags);
2530 int err = link_path_walk(s, nd);
2532 err = complete_walk(nd);
2534 *parent = nd->path;
2535 nd->path.mnt = NULL;
2536 nd->path.dentry = NULL;
2538 terminate_walk(nd);
2549 struct nameidata nd;
2553 set_nameidata(&nd, dfd, name, root);
2554 retval = path_parentat(&nd, flags | LOOKUP_RCU, parent);
2556 retval = path_parentat(&nd, flags, parent);
2558 retval = path_parentat(&nd, flags | LOOKUP_REVAL, parent);
2560 *last = nd.last;
2561 *type = nd.last_type;
3340 static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,
3345 struct inode *dir = nd->path.dentry->d_inode;
3348 if (nd->flags & LOOKUP_DIRECTORY)
3352 file->f_path.mnt = nd->path.mnt;
3395 static struct dentry *lookup_open(struct nameidata *nd, struct file *file,
3400 struct dentry *dir = nd->path.dentry;
3412 dentry = d_lookup(dir, &nd->last);
3415 dentry = d_alloc_parallel(dir, &nd->last, &wq);
3422 error = d_revalidate(dentry, nd->flags);
3447 idmap = mnt_idmap(nd->path.mnt);
3453 create_error = may_o_create(idmap, &nd->path,
3461 dentry = atomic_open(nd, dentry, file, open_flag, mode);
3469 nd->flags);
3506 static const char *open_last_lookups(struct nameidata *nd,
3509 struct dentry *dir = nd->path.dentry;
3515 nd->flags |= op->intent;
3517 if (nd->last_type != LAST_NORM) {
3518 if (nd->depth)
3519 put_link(nd);
3520 return handle_dots(nd, nd->last_type);
3524 if (nd->last.name[nd->last.len])
3525 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
3527 dentry = lookup_fast(nd);
3533 BUG_ON(nd->flags & LOOKUP_RCU);
3536 if (nd->flags & LOOKUP_RCU) {
3537 if (!try_to_unlazy(nd))
3540 audit_inode(nd->name, dir, AUDIT_INODE_PARENT);
3542 if (unlikely(nd->last.name[nd->last.len]))
3547 got_write = !mnt_want_write(nd->path.mnt);
3558 dentry = lookup_open(nd, file, op, got_write);
3567 mnt_drop_write(nd->path.mnt);
3573 dput(nd->path.dentry);
3574 nd->path.dentry = dentry;
3579 if (nd->depth)
3580 put_link(nd);
3581 res = step_into(nd, WALK_TRAILING, dentry);
3583 nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
3590 static int do_open(struct nameidata *nd,
3600 error = complete_walk(nd);
3605 audit_inode(nd->name, nd->path.dentry, 0);
3606 idmap = mnt_idmap(nd->path.mnt);
3610 if (d_is_dir(nd->path.dentry))
3612 error = may_create_in_sticky(idmap, nd,
3613 d_backing_inode(nd->path.dentry));
3617 if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry))
3626 } else if (d_is_reg(nd->path.dentry) && open_flag & O_TRUNC) {
3627 error = mnt_want_write(nd->path.mnt);
3632 error = may_open(idmap, &nd->path, acc_mode, open_flag);
3634 error = vfs_open(&nd->path, file);
3644 mnt_drop_write(nd->path.mnt);
3736 static int do_tmpfile(struct nameidata *nd, unsigned flags,
3741 int error = path_lookupat(nd, flags | LOOKUP_DIRECTORY, &path);
3751 audit_inode(nd->name, file->f_path.dentry, 0);
3759 static int do_o_path(struct nameidata *nd, unsigned flags, struct file *file)
3762 int error = path_lookupat(nd, flags, &path);
3764 audit_inode(nd->name, path.dentry, 0);
3771 static struct file *path_openat(struct nameidata *nd,
3782 error = do_tmpfile(nd, flags, op, file);
3784 error = do_o_path(nd, flags, file);
3786 const char *s = path_init(nd, flags);
3787 while (!(error = link_path_walk(s, nd)) &&
3788 (s = open_last_lookups(nd, file, op)) != NULL)
3791 error = do_open(nd, file, op);
3792 terminate_walk(nd);
3813 struct nameidata nd;
3817 set_nameidata(&nd, dfd, pathname, NULL);
3818 filp = path_openat(&nd, op, flags | LOOKUP_RCU);
3820 filp = path_openat(&nd, op, flags);
3822 filp = path_openat(&nd, op, flags | LOOKUP_REVAL);
3830 struct nameidata nd;
3842 set_nameidata(&nd, -1, filename, root);
3843 file = path_openat(&nd, op, flags | LOOKUP_RCU);
3845 file = path_openat(&nd, op, flags);
3847 file = path_openat(&nd, op, flags | LOOKUP_REVAL);