sanitized pathwalk machinery (v2)
Subsystems (3)
Al Viro
maintainerRFC PATCH v4 20/69 merging pick_link() with get_link(), part 2
In reply to Al ViroFrom: Al Viro <[email protected]>
Fold trailing_symlink() into lookup_last() and do_last(), change the calling conventions of those two. Rules change:
success, we are done => NULL instead of 0
error => ERR_PTR(-E...) instead of -E...
got a symlink to follow => return the path to be followed instead of 1
The loops calling those (in path_lookupat() and path_openat()) adjusted.
A subtle change of control flow here: originally a pure-jump trailing symlink ("/" or procfs one) would've passed through the upper level loop once more, with "" for path to traverse. That would've brought us back to the lookup_last/do_last entry and we would've hit LAST_BIND case (LAST_BIND left from get_link() called by trailing_symlink()) and pretty much skip to the point right after where we'd left the sucker back when we picked that trailing symlink.
Now we don't bother with that extra pass through the upper level loop - if get_link() says "I've just done a pure jump, nothing else to do", we just treat that as non-symlink case.
Boilerplate added on that step will go away shortly - it'll migrate into walk_component() and then to step_into(), collapsing into the change of calling conventions for those.
--- fs/namei.c | 68 ++++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 40 insertions(+), 28 deletions(-)
fs/namei.c +40 -28
@@ -2333,21 +2333,26 @@ static const char *path_init(struct nameidata *nd, unsigned flags)return s; } -static const char *trailing_symlink (struct nameidata *nd) -{ -const char *s =get_link (nd); - nd->flags |=LOOKUP_PARENT ; - nd->stack[0 ].name =NULL ; -return s ? s :"" ; -} - -static inline int lookup_last (struct nameidata *nd) +static inline const char *lookup_last (struct nameidata *nd) { +int err;if (nd->last_type ==LAST_NORM && nd->last.name[nd->last.len]) nd->flags |=LOOKUP_FOLLOW |LOOKUP_DIRECTORY ; nd->flags &= ~LOOKUP_PARENT ; -return walk_component (nd,0 ); + err =walk_component (nd,0 ); +if (unlikely (err)) { +const char *s; +if (err <0 ) +return PTR_ERR (err); + s =get_link (nd); +if (s) { + nd->flags |=LOOKUP_PARENT ; + nd->stack[0 ].name =NULL ; +return s; + } + } +return NULL ; }static int handle_lookup_down (struct nameidata *nd)
@@ -2370,10 +2375,9 @@ static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path s =ERR_PTR (err); } -while (!(err =link_path_walk (s, nd)) - && ((err =lookup_last (nd)) >0 )) { - s =trailing_symlink (nd); - } +while (!(err =link_path_walk (s, nd)) && + (s =lookup_last (nd)) !=NULL ) + ;if (!err) err =complete_walk (nd);
@@ -3183,7 +3187,7 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file,/* * Handle the last step of open() */ -static int do_last (struct nameidata *nd, +static const char *do_last (struct nameidata *nd,struct file *file,const struct open_flags *op) {struct dentry *dir = nd->path.dentry;
@@ -3206,7 +3210,7 @@ static int do_last(struct nameidata *nd,put_link (nd); error =handle_dots (nd, nd->last_type);if (unlikely (error)) -return error; +return ERR_PTR (error); goto finish_open; }
@@ -3216,7 +3220,7 @@ static int do_last(struct nameidata *nd,/* we _can_ be in RCU mode here */ dentry =lookup_fast (nd, &inode, &seq);if (IS_ERR (dentry)) -return PTR_ERR (dentry); +return ERR_CAST (dentry);if (likely (dentry)) goto finish_lookup;
@@ -3231,12 +3235,12 @@ static int do_last(struct nameidata *nd,*/ error =complete_walk (nd);if (error) -return error; +return ERR_PTR (error);audit_inode (nd->name, dir,AUDIT_INODE_PARENT );/* trailing slashes? */ if (unlikely (nd->last.name[nd->last.len])) -return -EISDIR ; +return ERR_PTR (-EISDIR ); }if (open_flag & (O_CREAT |O_TRUNC |O_WRONLY |O_RDWR )) {
@@ -3298,18 +3302,28 @@ static int do_last(struct nameidata *nd,if (nd->depth)put_link (nd); error =step_into (nd,0 , dentry, inode, seq); -if (unlikely (error)) -return error; +if (unlikely (error)) { +const char *s; +if (error <0 ) +return ERR_PTR (error); + s =get_link (nd); +if (s) { + nd->flags |=LOOKUP_PARENT ; + nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); + nd->stack[0 ].name =NULL ; +return s; + } + }if (unlikely ((open_flag & (O_EXCL |O_CREAT )) == (O_EXCL |O_CREAT ))) {audit_inode (nd->name, nd->path.dentry,0 ); -return -EEXIST ; +return ERR_PTR (-EEXIST ); } finish_open:/* Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... */ error =complete_walk (nd);if (error) -return error; +return ERR_PTR (error);audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) { error = -EISDIR ;
@@ -3351,7 +3365,7 @@ static int do_last(struct nameidata *nd, }if (got_write)mnt_drop_write (nd->path.mnt); -return error; +return ERR_PTR (error); }struct dentry *vfs_tmpfile (struct dentry *dentry,umode_t mode,int open_flag)
@@ -3454,10 +3468,8 @@ static struct file *path_openat(struct nameidata *nd, }else {const char *s =path_init (nd, flags);while (!(error =link_path_walk (s, nd)) && - (error =do_last (nd, file, op)) >0 ) { - nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); - s =trailing_symlink (nd); - } + (s =do_last (nd, file, op)) !=NULL ) + ;terminate_walk (nd); }if (likely (!error)) {
Signature · 1 line
2.11.0
Re: [RFC][PATCH v4 20/69] merging pick_link() with get_link(), part 2
Hmm..
fs/namei.c static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path · line 2377
Quoted 4 lines · Al Viro
fs/namei.c +3
-0@@ -2370,10 +2375,9 @@ static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path +while (!(err =link_path_walk (s, nd)) && + (s =lookup_last (nd)) !=NULL ) + ;
There's two copies of that loop (the other being in path_openat()). Is there a reason why it's written that odd way?
Why is the loop body empty, when the *natural* way to write that would seem to be
while (!(err = link_path_walk(s, nd))) {
s = lookup_last(nd));
if (!s)
break;
}which may be a few lines longer, but a lot more legible.
I don't think you should use assignments in tests, unless strictly required. Yes, that "err = ..." part almost has to be written that way, but the "s = ..." part doesn't seem to have any reason for being in the conditional.
And I'm only reading the patches, so once again: maybe I'm messing up by mis-reading something. And maybe you have some reason for that pattern.
Linus
Al Viro
maintainerRFC PATCH v4 21/69 merging pick_link() with get_link(), part 3
In reply to Al ViroFrom: Al Viro <[email protected]>
After a pure jump ("/" or procfs-style symlink) we don't need to hold the link anymore. link_path_walk() dropped it if such case had been detected, lookup_last/do_last() (i.e. old trailing_symlink()) left it on the stack - it ended up calling terminate_walk() shortly anyway, which would've purged the entire stack.
Do it in get_link() itself instead. Simpler logics that way...
--- fs/namei.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
fs/namei.c +9 -9
@@ -1154,7 +1154,9 @@ const char *get_link(struct nameidata *nd) }else { res =get (dentry, inode, &last->done); } -if (IS_ERR_OR_NULL (res)) +if (!res) + goto all_done; +if (IS_ERR (res))return res; }if (*res =='/' ) {
@@ -1164,9 +1166,11 @@ const char *get_link(struct nameidata *nd)while (unlikely (*++res =='/' )) ; } -if (!*res) - res =NULL ; -return res; +if (*res) +return res; +all_done:// pure jump +put_link (nd); +return NULL ; }/*
@@ -2211,11 +2215,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)if (IS_ERR (s))return PTR_ERR (s); - err =0 ; -if (unlikely (!s)) { -/* jumped */ -put_link (nd); - }else { +if (likely (s)) { nd->stack[nd->depth -1 ].name = name; name = s;continue ;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 22/69 merging pick_link() with get_link(), part 4
In reply to Al ViroFrom: Al Viro <[email protected]>
Move the call of get_link() into walk_component(). Change the calling conventions for walk_component() to returning the link body to follow (if any).
--- fs/namei.c | 59 ++++++++++++++++++++++++++--------------------------------- 1 file changed, 26 insertions(+), 33 deletions(-)
fs/namei.c +26 -33
@@ -1866,7 +1866,7 @@ static int step_into(struct nameidata *nd, int flags,return pick_link (nd, &path, inode, seq); } -static int walk_component (struct nameidata *nd,int flags) +static const char *walk_component (struct nameidata *nd,int flags) {struct dentry *dentry;struct inode *inode;
@@ -1881,19 +1881,24 @@ static int walk_component(struct nameidata *nd, int flags)if (!(flags &WALK_MORE ) && nd->depth)put_link (nd); err =handle_dots (nd, nd->last_type); -return err; +return ERR_PTR (err); } dentry =lookup_fast (nd, &inode, &seq);if (IS_ERR (dentry)) -return PTR_ERR (dentry); +return ERR_CAST (dentry);if (unlikely (!dentry)) { dentry =lookup_slow (&nd->last, nd->path.dentry, nd->flags);if (IS_ERR (dentry)) -return PTR_ERR (dentry); +return ERR_CAST (dentry); }if (!(flags &WALK_MORE ) && nd->depth)put_link (nd); -return step_into (nd, flags, dentry, inode, seq); + err =step_into (nd, flags, dentry, inode, seq); +if (!err) +return NULL ; +if (err >0 ) +return get_link (nd); +return ERR_PTR (err); }/*
@@ -2145,6 +2150,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)/* At this point we know we have a real path component. */ for (;;) { +const char *link;u64 hash_len;int type;
@@ -2202,24 +2208,18 @@ static int link_path_walk(const char *name, struct nameidata *nd)if (!name)return 0 ;/* last component of nested symlink */ - err =walk_component (nd,WALK_FOLLOW ); + link =walk_component (nd,WALK_FOLLOW ); }else {/* not the last component */ - err =walk_component (nd,WALK_FOLLOW |WALK_MORE ); + link =walk_component (nd,WALK_FOLLOW |WALK_MORE ); } -if (err <0 ) -return err; - -if (err) { -const char *s =get_link (nd); - -if (IS_ERR (s)) -return PTR_ERR (s); -if (likely (s)) { - nd->stack[nd->depth -1 ].name = name; - name = s; -continue ; - } +if (unlikely (link)) { +if (IS_ERR (link)) +return PTR_ERR (link); +/* a symlink to follow */ + nd->stack[nd->depth -1 ].name = name; + name = link; +continue ; }if (unlikely (!d_can_lookup (nd->path.dentry))) {if (nd->flags &LOOKUP_RCU ) {
@@ -2335,24 +2335,17 @@ static const char *path_init(struct nameidata *nd, unsigned flags)static inline const char *lookup_last (struct nameidata *nd) { -int err; +const char *link;if (nd->last_type ==LAST_NORM && nd->last.name[nd->last.len]) nd->flags |=LOOKUP_FOLLOW |LOOKUP_DIRECTORY ; nd->flags &= ~LOOKUP_PARENT ; - err =walk_component (nd,0 ); -if (unlikely (err)) { -const char *s; -if (err <0 ) -return PTR_ERR (err); - s =get_link (nd); -if (s) { - nd->flags |=LOOKUP_PARENT ; - nd->stack[0 ].name =NULL ; -return s; - } + link =walk_component (nd,0 ); +if (link) { + nd->flags |=LOOKUP_PARENT ; + nd->stack[0 ].name =NULL ; } -return NULL ; +return link; }static int handle_lookup_down (struct nameidata *nd)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 23/69 merging pick_link() with get_link(), part 5
In reply to Al ViroFrom: Al Viro <[email protected]>
move get_link() call into step_into().
--- fs/namei.c | 43 ++++++++++++++++++------------------------- 1 file changed, 18 insertions(+), 25 deletions(-)
fs/namei.c +18 -25
@@ -1841,14 +1841,14 @@ enum {WALK_FOLLOW = 1, WALK_MORE = 2, WALK_NOFOLLOW = 4};* so we keep a cache of "no, this doesn't need follow_link" * for the common case. */ -static int step_into (struct nameidata *nd,int flags, +static const char *step_into (struct nameidata *nd,int flags,struct dentry *dentry,struct inode *inode,unsigned seq) {struct path path;int err =handle_mounts (nd, dentry, &path, &inode, &seq);if (err <0 ) -return err; +return ERR_PTR (err);if (likely (!d_is_symlink (path.dentry)) || !(flags &WALK_FOLLOW || nd->flags &LOOKUP_FOLLOW ) || flags &WALK_NOFOLLOW ) {
@@ -1856,14 +1856,17 @@ static int step_into(struct nameidata *nd, int flags,path_to_nameidata (&path, nd); nd->inode = inode; nd->seq = seq; -return 0 ; +return NULL ; }/* make sure that d_is_symlink above matches inode */ if (nd->flags &LOOKUP_RCU ) {if (read_seqcount_retry (&path.dentry->d_seq, seq)) -return -ECHILD ; +return ERR_PTR (-ECHILD ); } -return pick_link (nd, &path, inode, seq); + err =pick_link (nd, &path, inode, seq); +if (err >0 ) +return get_link (nd); +return ERR_PTR (err); }static const char *walk_component (struct nameidata *nd,int flags)
@@ -1893,12 +1896,7 @@ static const char *walk_component(struct nameidata *nd, int flags) }if (!(flags &WALK_MORE ) && nd->depth)put_link (nd); - err =step_into (nd, flags, dentry, inode, seq); -if (!err) -return NULL ; -if (err >0 ) -return get_link (nd); -return ERR_PTR (err); +return step_into (nd, flags, dentry, inode, seq); }/*
@@ -2352,8 +2350,8 @@ static int handle_lookup_down(struct nameidata *nd) {if (!(nd->flags &LOOKUP_RCU ))dget (nd->path.dentry); -return step_into (nd,WALK_NOFOLLOW , - nd->path.dentry, nd->inode, nd->seq); +return PTR_ERR (step_into (nd,WALK_NOFOLLOW , + nd->path.dentry, nd->inode, nd->seq)); }/* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
@@ -3193,6 +3191,7 @@ static const char *do_last(struct nameidata *nd,unsigned seq;struct inode *inode;struct dentry *dentry; +const char *res;int error; nd->flags &= ~LOOKUP_PARENT ;
@@ -3294,18 +3293,12 @@ static const char *do_last(struct nameidata *nd, finish_lookup:if (nd->depth)put_link (nd); - error =step_into (nd,0 , dentry, inode, seq); -if (unlikely (error)) { -const char *s; -if (error <0 ) -return ERR_PTR (error); - s =get_link (nd); -if (s) { - nd->flags |=LOOKUP_PARENT ; - nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); - nd->stack[0 ].name =NULL ; -return s; - } + res =step_into (nd,0 , dentry, inode, seq); +if (unlikely (res)) { + nd->flags |=LOOKUP_PARENT ; + nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); + nd->stack[0 ].name =NULL ; +return res; }if (unlikely ((open_flag & (O_EXCL |O_CREAT )) == (O_EXCL |O_CREAT ))) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 24/69 merging pick_link() with get_link(), part 6
In reply to Al ViroFrom: Al Viro <[email protected]>
move the only remaining call of get_link() into pick_link()
--- fs/namei.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-)
fs/namei.c +5 -8
@@ -1793,14 +1793,14 @@ static inline int handle_dots(struct nameidata *nd, int type)return 0 ; } -static int pick_link (struct nameidata *nd,struct path *link, +static const char *pick_link (struct nameidata *nd,struct path *link,struct inode *inode,unsigned seq) {int error;struct saved *last;if (unlikely (nd->total_link_count++ >=MAXSYMLINKS )) {path_to_nameidata (link, nd); -return -ELOOP ; +return ERR_PTR (-ELOOP ); }if (!(nd->flags &LOOKUP_RCU )) {if (link->mnt == nd->path.mnt)
@@ -1821,7 +1821,7 @@ static int pick_link(struct nameidata *nd, struct path *link, }if (error) {path_put (link); -return error; +return ERR_PTR (error); } }
@@ -1830,7 +1830,7 @@ static int pick_link(struct nameidata *nd, struct path *link,clear_delayed_call (&last->done); nd->link_inode = inode; last->seq = seq; -return 1 ; +return get_link (nd); }enum {WALK_FOLLOW =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 };
@@ -1863,10 +1863,7 @@ static const char *step_into(struct nameidata *nd, int flags,if (read_seqcount_retry (&path.dentry->d_seq, seq))return ERR_PTR (-ECHILD ); } - err =pick_link (nd, &path, inode, seq); -if (err >0 ) -return get_link (nd); -return ERR_PTR (err); +return pick_link (nd, &path, inode, seq); }static const char *walk_component (struct nameidata *nd,int flags)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 25/69 finally fold get_link() into pick_link()
In reply to Al ViroFrom: Al Viro <[email protected]>
kill nd->link_inode, while we are at it
--- fs/namei.c | 135 ++++++++++++++++++++++++++++--------------------------------- 1 file changed, 61 insertions(+), 74 deletions(-)
fs/namei.c +61 -74
@@ -503,7 +503,6 @@ struct nameidata { } *stack, internal[EMBEDDED_LEVELS ];struct filename *name;struct nameidata *saved; -struct inode *link_inode;unsigned root_seq;int dfd; } __randomize_layout;
@@ -962,9 +961,8 @@ int sysctl_protected_regular __read_mostly;* * Returns 0 if following the symlink is allowed, -ve on error. */ -static inline int may_follow_link (struct nameidata *nd) +static inline int may_follow_link (struct nameidata *nd,const struct inode *inode) { -const struct inode *inode;const struct inode *parent;kuid_t puid;
@@ -972,7 +970,6 @@ static inline int may_follow_link(struct nameidata *nd)return 0 ;/* Allowed if owner and follower match. */ - inode = nd->link_inode;if (uid_eq (current_cred ()->fsuid, inode->i_uid))return 0 ;
@@ -1106,73 +1103,6 @@ static int may_create_in_sticky(umode_t dir_mode, kuid_t dir_uid,return 0 ; } -static __always_inline -const char *get_link(struct nameidata *nd) -{ -struct saved *last = nd->stack + nd->depth -1 ; -struct dentry *dentry = last->link.dentry; -struct inode *inode = nd->link_inode; -int error; -const char *res; - -if (!(nd->flags &LOOKUP_PARENT )) { - error =may_follow_link (nd); -if (unlikely (error)) -return ERR_PTR (error); - } - -if (unlikely (nd->flags &LOOKUP_NO_SYMLINKS )) -return ERR_PTR (-ELOOP ); - -if (!(nd->flags &LOOKUP_RCU )) { -touch_atime (&last->link); -cond_resched (); - }else if (atime_needs_update (&last->link, inode)) { -if (unlikely (unlazy_walk (nd))) -return ERR_PTR (-ECHILD ); -touch_atime (&last->link); - } - - error =security_inode_follow_link (dentry, inode, - nd->flags &LOOKUP_RCU ); -if (unlikely (error)) -return ERR_PTR (error); - - nd->last_type =LAST_BIND ; - res =READ_ONCE (inode->i_link); -if (!res) { -const char * (*get)(struct dentry *,struct inode *, -struct delayed_call *); - get = inode->i_op->get_link; -if (nd->flags &LOOKUP_RCU ) { - res =get (NULL , inode, &last->done); -if (res ==ERR_PTR (-ECHILD )) { -if (unlikely (unlazy_walk (nd))) -return ERR_PTR (-ECHILD ); - res =get (dentry, inode, &last->done); - } - }else { - res =get (dentry, inode, &last->done); - } -if (!res) - goto all_done; -if (IS_ERR (res)) -return res; - } -if (*res =='/' ) { - error =nd_jump_root (nd); -if (unlikely (error)) -return ERR_PTR (error); -while (unlikely (*++res =='/' )) - ; - } -if (*res) -return res; -all_done:// pure jump -put_link (nd); -return NULL ; -} -/* * follow_up - Find the mountpoint of path's vfsmount *
@@ -1796,8 +1726,10 @@ static inline int handle_dots(struct nameidata *nd, int type)static const char *pick_link (struct nameidata *nd,struct path *link,struct inode *inode,unsigned seq) { -int error;struct saved *last; +const char *res; +int error; +if (unlikely (nd->total_link_count++ >=MAXSYMLINKS )) {path_to_nameidata (link, nd);return ERR_PTR (-ELOOP );
@@ -1828,9 +1760,64 @@ static const char *pick_link(struct nameidata *nd, struct path *link, last = nd->stack + nd->depth++; last->link = *link;clear_delayed_call (&last->done); - nd->link_inode = inode; last->seq = seq; -return get_link (nd); + +if (!(nd->flags &LOOKUP_PARENT )) { + error =may_follow_link (nd, inode); +if (unlikely (error)) +return ERR_PTR (error); + } + +if (unlikely (nd->flags &LOOKUP_NO_SYMLINKS )) +return ERR_PTR (-ELOOP ); + +if (!(nd->flags &LOOKUP_RCU )) { +touch_atime (&last->link); +cond_resched (); + }else if (atime_needs_update (&last->link, inode)) { +if (unlikely (unlazy_walk (nd))) +return ERR_PTR (-ECHILD ); +touch_atime (&last->link); + } + + error =security_inode_follow_link (link->dentry, inode, + nd->flags &LOOKUP_RCU ); +if (unlikely (error)) +return ERR_PTR (error); + + nd->last_type =LAST_BIND ; + res =READ_ONCE (inode->i_link); +if (!res) { +const char * (*get)(struct dentry *,struct inode *, +struct delayed_call *); + get = inode->i_op->get_link; +if (nd->flags &LOOKUP_RCU ) { + res =get (NULL , inode, &last->done); +if (res ==ERR_PTR (-ECHILD )) { +if (unlikely (unlazy_walk (nd))) +return ERR_PTR (-ECHILD ); + res =get (link->dentry, inode, &last->done); + } + }else { + res =get (link->dentry, inode, &last->done); + } +if (!res) + goto all_done; +if (IS_ERR (res)) +return res; + } +if (*res =='/' ) { + error =nd_jump_root (nd); +if (unlikely (error)) +return ERR_PTR (error); +while (unlikely (*++res =='/' )) + ; + } +if (*res) +return res; +all_done:// pure jump +put_link (nd); +return NULL ; }enum {WALK_FOLLOW =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 };
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 26/69 sanitize handling of nd->last_type, kill LAST_BIND
In reply to Al ViroFrom: Al Viro <[email protected]>
->last_type values are set in 3 places: path_init() (sets to LAST_ROOT), link_path_walk (LAST_NORM/DOT/DOTDOT) and pick_link (LAST_BIND).
The are checked in walk_component(), lookup_last() and do_last(). They also get copied to the caller by filename_parentat(). In the last 3 cases the value is what we had at the return from link_path_walk(). In case of walk_component() it's either directly downstream from assignment in link_path_walk() or, when called by lookup_last(), the value we have at the return from link_path_walk().
The value at the entry into link_path_walk() can survive to return only if the pathname contains nothing but slashes. Note that pick_link() never returns such - pure jumps are handled directly. So for the calls of link_path_walk() for trailing symlinks it does not matter what value had been there at the entry; the value at the return won't depend upon it.
There are 3 call chains that might have pick_link() storing LAST_BIND:
1) pick_link() from step_into() from walk_component() from link_path_walk(). In that case we will either be parsing the next component immediately after return into link_path_walk(), which will overwrite the ->last_type before anyone has a chance to look at it, or we'll fail, in which case nobody will be looking at ->last_type at all.
2) pick_link() from step_into() from walk_component() from lookup_last(). The value is never looked at due to the above; it won't affect the value seen at return from any link_path_walk().
3) pick_link() from step_into() from do_last(). Ditto.
In other words, assignemnt in pick_link() is pointless, and so is LAST_BIND itself; nothing ever looks at that value. Kill it off. And make link_path_walk() _always_ assign ->last_type - in the only case when the value at the entry might survive to the return that value is always LAST_ROOT, inherited from path_init(). Move that assignment from path_init() into the beginning of link_path_walk(), to consolidate the things.
Historical note: LAST_BIND used to be used for the kludge with trailing pure jump symlinks (extra iteration through the top-level loop). No point keeping it anymore...
--- Documentation/filesystems/path-lookup.rst | 7 ++----- fs/namei.c | 3 +-- include/linux/namei.h | 2 +- 3 files changed, 4 insertions(+), 8 deletions(-)
Documentation/filesystems/path-lookup.rst +2 -5
@@ -404,11 +404,8 @@ that is the "next" component in the pathname. ``int last_type`` ~~~~~~~~~~~~~~~~~ -This is one of ``LAST_NORM``, ``LAST_ROOT``, ``LAST_DOT``, ``LAST_DOTDOT``, or -``LAST_BIND``. The ``last`` field is only valid if the type is -``LAST_NORM``. ``LAST_BIND`` is used when following a symlink and no -components of the symlink have been processed yet. Others should be -fairly self-explanatory. +This is one of ``LAST_NORM``, ``LAST_ROOT``, ``LAST_DOT`` or ``LAST_DOTDOT``. +The ``last`` field is only valid if the type is ``LAST_NORM``. ``struct path root`` ~~~~~~~~~~~~~~~~~~~~
fs/namei.c +1 -2
@@ -1785,7 +1785,6 @@ static const char *pick_link(struct nameidata *nd, struct path *link,if (unlikely (error))return ERR_PTR (error); - nd->last_type =LAST_BIND ; res =READ_ONCE (inode->i_link);if (!res) { const char * (*get)(struct dentry *, struct inode *,
@@ -2123,6 +2122,7 @@ static int link_path_walk(const char *name, struct nameidata *nd) {int err; + nd->last_type =LAST_ROOT ;if (IS_ERR (name))return PTR_ERR (name);while (*name=='/' )
@@ -2224,7 +2224,6 @@ static const char *path_init(struct nameidata *nd, unsigned flags)if (flags &LOOKUP_RCU )rcu_read_lock (); - nd->last_type =LAST_ROOT ;/* if there are only slashes... */ nd->flags = flags |LOOKUP_JUMPED |LOOKUP_PARENT ; nd->depth =0 ;
include/linux/namei.h +1 -1
@@ -15,7 +15,7 @@ enum { MAX_NESTED_LINKS = 8 };/* * Type of the last component on LOOKUP_PARENT */ -enum {LAST_NORM ,LAST_ROOT ,LAST_DOT ,LAST_DOTDOT ,LAST_BIND }; +enum {LAST_NORM ,LAST_ROOT ,LAST_DOT ,LAST_DOTDOT };/* pathwalk mode */ #define LOOKUP_FOLLOW 0x0001/* follow links at the end */
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 27/69 namei: invert the meaning of WALK_FOLLOW
In reply to Al ViroFrom: Al Viro <[email protected]>
old flags & WALK_FOLLOW <=> new !(flags & WALK_TRAILING) That's what that flag had really been used for.
--- fs/namei.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
fs/namei.c +7 -7
@@ -1819,7 +1819,7 @@ static const char *pick_link(struct nameidata *nd, struct path *link,return NULL ; } -enum {WALK_FOLLOW =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 }; +enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 };/* * Do we need to follow links? We _really_ want to be able
@@ -1836,8 +1836,8 @@ static const char *step_into(struct nameidata *nd, int flags,if (err <0 )return ERR_PTR (err);if (likely (!d_is_symlink (path.dentry)) || - !(flags &WALK_FOLLOW || nd->flags &LOOKUP_FOLLOW ) || - flags &WALK_NOFOLLOW ) { + ((flags &WALK_TRAILING ) && !(nd->flags &LOOKUP_FOLLOW )) || + (flags &WALK_NOFOLLOW )) {/* not a symlink or should not follow */ path_to_nameidata (&path, nd); nd->inode = inode;
@@ -2190,10 +2190,10 @@ static int link_path_walk(const char *name, struct nameidata *nd)if (!name)return 0 ;/* last component of nested symlink */ - link =walk_component (nd,WALK_FOLLOW ); + link =walk_component (nd,0 ); }else {/* not the last component */ - link =walk_component (nd,WALK_FOLLOW |WALK_MORE ); + link =walk_component (nd,WALK_MORE ); }if (unlikely (link)) {if (IS_ERR (link))
@@ -2321,7 +2321,7 @@ static inline const char *lookup_last(struct nameidata *nd) nd->flags |=LOOKUP_FOLLOW |LOOKUP_DIRECTORY ; nd->flags &= ~LOOKUP_PARENT ; - link =walk_component (nd,0 ); + link =walk_component (nd,WALK_TRAILING );if (link) { nd->flags |=LOOKUP_PARENT ; nd->stack[0 ].name =NULL ;
@@ -3276,7 +3276,7 @@ static const char *do_last(struct nameidata *nd, finish_lookup:if (nd->depth)put_link (nd); - res =step_into (nd,0 , dentry, inode, seq); + res =step_into (nd,WALK_TRAILING , dentry, inode, seq);if (unlikely (res)) { nd->flags |=LOOKUP_PARENT ; nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL );
Signature · 1 line
2.11.0
Re: [RFC][PATCH v4 27/69] namei: invert the meaning of WALK_FOLLOW
fs/namei.c static const char *step_into(struct nameidata *nd, int flags, · line 1840
Quoted 5 lines · Al Viro
fs/namei.c +2
-2- !(flags & WALK_FOLLOW || nd->flags & LOOKUP_FOLLOW) || - flags & WALK_NOFOLLOW) { + ((flags & WALK_TRAILING) && !(nd->flags & LOOKUP_FOLLOW)) || + (flags & WALK_NOFOLLOW)) {
Oh, and here you fix the implicit precedence thing I was complaining about earlier.
Maybe my original complaint had happened at this point, and I'd missed the original place.
Likely.
Linus
Al Viro
maintainerRFC PATCH v4 28/69 pick_link(): check for WALK_TRAILING, not LOOKUP_PARENT
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
fs/namei.c +5 -5
@@ -1723,8 +1723,10 @@ static inline int handle_dots(struct nameidata *nd, int type)return 0 ; } +enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 }; +static const char *pick_link (struct nameidata *nd,struct path *link, -struct inode *inode,unsigned seq) +struct inode *inode,unsigned seq,int flags) {struct saved *last;const char *res;
@@ -1762,7 +1764,7 @@ static const char *pick_link(struct nameidata *nd, struct path *link,clear_delayed_call (&last->done); last->seq = seq; -if (!(nd->flags &LOOKUP_PARENT )) { +if (flags &WALK_TRAILING ) { error =may_follow_link (nd, inode);if (unlikely (error))return ERR_PTR (error);
@@ -1819,8 +1821,6 @@ static const char *pick_link(struct nameidata *nd, struct path *link,return NULL ; } -enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 }; -/* * Do we need to follow links? We _really_ want to be able * to do this check without having to look at inode->i_op,
@@ -1849,7 +1849,7 @@ static const char *step_into(struct nameidata *nd, int flags,if (read_seqcount_retry (&path.dentry->d_seq, seq))return ERR_PTR (-ECHILD ); } -return pick_link (nd, &path, inode, seq); +return pick_link (nd, &path, inode, seq, flags); }static const char *walk_component (struct nameidata *nd,int flags)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 29/69 link_path_walk(): simplify stack handling
In reply to Al ViroFrom: Al Viro <[email protected]>
We use nd->stack to store two things: pinning down the symlinks we are resolving and resuming the name traversal when a nested symlink is finished.
Currently, nd->depth is used to keep track of both. It's 0 when we call link_path_walk() for the first time (for the pathname itself) and 1 on all subsequent calls (for trailing symlinks, if any). That's fine, as far as pinning symlinks goes - when handling a trailing symlink, the string we are interpreting is the body of symlink pinned down in nd->stack[0]. It's rather inconvenient with respect to handling nested symlinks, though - when we run out of a string we are currently interpreting, we need to decide whether it's a nested symlink (in which case we need to pick the string saved back when we started to interpret that nested symlink and resume its traversal) or not (in which case we are done with link_path_walk()).
Current solution is a bit of a kludge - in handling of trailing symlink (in lookup_last() and open_last_lookups() we clear nd->stack[0].name. That allows link_path_walk() to use the following rules when running out of a string to interpret:
* if nd->depth is zero, we are at the end of pathname itself.
* if nd->depth is positive, check the saved string; for
nested symlink it will be non-NULL, for trailing symlink - NULL.
It works, but it's rather non-obvious. Note that we have two sets:
the set of symlinks currently being traversed and the set of postponed pathname tails. The former is stored in nd->stack[0..nd->depth-1].link and it's valid throught the pathname resolution; the latter is valid only during an individual call of link_path_walk() and it occupies nd->stack[0..nd->depth-1].name for the first call of link_path_walk() and nd->stack[1..nd->depth-1].name for subsequent ones. The kludge is basically a way to recognize the second set becoming empty.
The things get simpler if we keep track of the second set's size explicitly and always store it in nd->stack[0..depth-1].name. We access the second set only inside link_path_walk(), so its size can live in a local variable; that way the check becomes trivial without the need of that kludge.
--- fs/namei.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-)
fs/namei.c +5 -9
@@ -2120,6 +2120,7 @@ static inline u64 hash_name(const void *salt, const char *name)*/ static int link_path_walk (const char *name,struct nameidata *nd) { +int depth =0 ;// depth <= nd->depth int err; nd->last_type =LAST_ROOT ;
@@ -2182,14 +2183,11 @@ static int link_path_walk(const char *name, struct nameidata *nd) }while (unlikely (*name =='/' ));if (unlikely (!*name)) { OK: -/* pathname body, done */ -if (!nd->depth) -return 0 ; - name = nd->stack[nd->depth -1 ].name; -/* trailing symlink, done */ -if (!name) +/* pathname or trailing symlink, done */ +if (!depth)return 0 ;/* last component of nested symlink */ + name = nd->stack[--depth].name; link =walk_component (nd,0 ); }else {/* not the last component */
@@ -2199,7 +2197,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)if (IS_ERR (link))return PTR_ERR (link);/* a symlink to follow */ - nd->stack[nd->depth -1 ].name = name; + nd->stack[depth++].name = name; name = link;continue ; }
@@ -2324,7 +2322,6 @@ static inline const char *lookup_last(struct nameidata *nd) link =walk_component (nd,WALK_TRAILING );if (link) { nd->flags |=LOOKUP_PARENT ; - nd->stack[0 ].name =NULL ; }return link; }
@@ -3280,7 +3277,6 @@ static const char *do_last(struct nameidata *nd,if (unlikely (res)) { nd->flags |=LOOKUP_PARENT ; nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); - nd->stack[0 ].name =NULL ;return res; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 30/69 namei: have link_path_walk() maintain LOOKUP_PARENT
In reply to Al ViroFrom: Al Viro <[email protected]>
set on entry, clear when we get to the last component.
--- fs/namei.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
fs/namei.c +6 -11
@@ -2124,6 +2124,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)int err; nd->last_type =LAST_ROOT ; + nd->flags |=LOOKUP_PARENT ;if (IS_ERR (name))return PTR_ERR (name);while (*name=='/' )
@@ -2184,8 +2185,10 @@ static int link_path_walk(const char *name, struct nameidata *nd)if (unlikely (!*name)) { OK:/* pathname or trailing symlink, done */ -if (!depth) +if (!depth) { + nd->flags &= ~LOOKUP_PARENT ;return 0 ; + }/* last component of nested symlink */ name = nd->stack[--depth].name; link =walk_component (nd,0 );
@@ -2222,7 +2225,7 @@ static const char *path_init(struct nameidata *nd, unsigned flags)if (flags &LOOKUP_RCU )rcu_read_lock (); - nd->flags = flags |LOOKUP_JUMPED |LOOKUP_PARENT ; + nd->flags = flags |LOOKUP_JUMPED ; nd->depth =0 ; nd->m_seq =__read_seqcount_begin (&mount_lock.seqcount);
@@ -2314,16 +2317,10 @@ static const char *path_init(struct nameidata *nd, unsigned flags)static inline const char *lookup_last (struct nameidata *nd) { -const char *link;if (nd->last_type ==LAST_NORM && nd->last.name[nd->last.len]) nd->flags |=LOOKUP_FOLLOW |LOOKUP_DIRECTORY ; - nd->flags &= ~LOOKUP_PARENT ; - link =walk_component (nd,WALK_TRAILING ); -if (link) { - nd->flags |=LOOKUP_PARENT ; - } -return link; +return walk_component (nd,WALK_TRAILING ); }static int handle_lookup_down (struct nameidata *nd)
@@ -3174,7 +3171,6 @@ static const char *do_last(struct nameidata *nd,const char *res;int error; - nd->flags &= ~LOOKUP_PARENT ; nd->flags |= op->intent;if (nd->last_type !=LAST_NORM ) {
@@ -3275,7 +3271,6 @@ static const char *do_last(struct nameidata *nd,put_link (nd); res =step_into (nd,WALK_TRAILING , dentry, inode, seq);if (unlikely (res)) { - nd->flags |=LOOKUP_PARENT ; nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL );return res; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 31/69 massage __follow_mount_rcu() a bit
In reply to Al ViroFrom: Al Viro <[email protected]>
make the loop more similar to that in follow_managed(), with explicit tracking of flags, etc.
--- fs/namei.c | 70 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 35 insertions(+), 35 deletions(-)
fs/namei.c +35 -35
@@ -1269,12 +1269,6 @@ int follow_down_one(struct path *path) }EXPORT_SYMBOL (follow_down_one); -static inline int managed_dentry_rcu (const struct path *path) -{ -return (path->dentry->d_flags &DCACHE_MANAGE_TRANSIT ) ? - path->dentry->d_op->d_manage (path, true) :0 ; -} -/* * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if * we meet a managed dentry that would need blocking.
@@ -1282,43 +1276,49 @@ static inline int managed_dentry_rcu(const struct path *path)static bool __follow_mount_rcu (struct nameidata *nd,struct path *path,struct inode **inode,unsigned *seqp) { +struct dentry *dentry = path->dentry; +unsigned int flags = dentry->d_flags; + +if (likely (!(flags &DCACHE_MANAGED_DENTRY ))) +return true; + +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return false; +for (;;) { -struct mount *mounted;/* * Don't forget we might have a non-mountpoint managed dentry * that wants to block transit. */ -switch (managed_dentry_rcu (path)) { -case -ECHILD : -default : -return false; -case -EISDIR : -return true; -case 0 : -break ; +if (unlikely (flags &DCACHE_MANAGE_TRANSIT )) { +int res = dentry->d_op->d_manage (path, true); +if (res) +return res == -EISDIR ; + flags = dentry->d_flags; } -if (!d_mountpoint (path->dentry)) -return !(path->dentry->d_flags &DCACHE_NEED_AUTOMOUNT ); - - mounted =__lookup_mnt (path->mnt, path->dentry); -if (!mounted) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return false; - path->mnt = &mounted->mnt; - path->dentry = mounted->mnt.mnt_root; - nd->flags |=LOOKUP_JUMPED ; - *seqp =read_seqcount_begin (&path->dentry->d_seq); -/* -* Update the inode too. We don't need to re-check the -* dentry sequence number here after this d_inode read, -* because a mount-point is always pinned. -*/ - *inode = path->dentry->d_inode; +if (flags &DCACHE_MOUNTED ) { +struct mount *mounted =__lookup_mnt (path->mnt, dentry); +if (mounted) { + path->mnt = &mounted->mnt; + dentry = path->dentry = mounted->mnt.mnt_root; + nd->flags |=LOOKUP_JUMPED ; + *seqp =read_seqcount_begin (&dentry->d_seq); + *inode = dentry->d_inode; +/* +* We don't need to re-check ->d_seq after this +* ->d_inode read - there will be an RCU delay +* between mount hash removal and ->mnt_root +* becoming unpinned. +*/ + flags = dentry->d_flags; +continue ; + } +if (read_seqretry (&mount_lock, nd->m_seq)) +return false; + } +return !(flags &DCACHE_NEED_AUTOMOUNT ); } -return !read_seqretry (&mount_lock, nd->m_seq) && - !(path->dentry->d_flags &DCACHE_NEED_AUTOMOUNT ); } static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 32/69 new helper: traverse_mounts()
In reply to Al ViroFrom: Al Viro <[email protected]>
common guts of follow_down() and follow_managed() taken to a new helper - traverse_mounts(). The remnants of follow_managed() are folded into its sole remaining caller (handle_mounts()). Calling conventions of handle_mounts() slightly sanitized - instead of the weird "1 for success, -E... for failure" that used to be imposed by the calling conventions of walk_component() et.al. we can use the normal "0 for success, -E... for failure".
--- fs/namei.c | 177 +++++++++++++++++++++++++------------------------------------ 1 file changed, 72 insertions(+), 105 deletions(-)
fs/namei.c +72 -105
@@ -1168,91 +1168,79 @@ static int follow_automount(struct path *path, int *count, unsigned lookup_flags }/* -* Handle a dentry that is managed in some way. -* - Flagged for transit management (autofs) -* - Flagged as mountpoint -* - Flagged as automount point -* -* This may only be called in refwalk mode. -* On success path->dentry is known positive. -* -* Serialization is taken care of in namespace.c +* mount traversal - out-of-line part. One note on ->d_flags accesses - +* dentries are pinned but not locked here, so negative dentry can go +* positive right under us. Use of smp_load_acquire() provides a barrier +* sufficient for ->d_inode and ->d_flags consistency. */ -static int follow_managed (struct path *path,struct nameidata *nd) +static int __traverse_mounts (struct path *path,unsigned flags,bool *jumped, +int *count,unsigned lookup_flags) { -struct vfsmount *mnt = path->mnt;/* held by caller, must be left alone */ -unsigned flags; +struct vfsmount *mnt = path->mnt;bool need_mntput = false;int ret =0 ; -/* Given that we're not holding a lock here, we retain the value in a -* local variable for each dentry as we look at it so that we don't see -* the components of that value change under us */ -while (flags =smp_load_acquire (&path->dentry->d_flags), -unlikely (flags &DCACHE_MANAGED_DENTRY )) { +while (flags &DCACHE_MANAGED_DENTRY ) {/* Allow the filesystem to manage the transit without i_mutex * being held. */ if (flags &DCACHE_MANAGE_TRANSIT ) { -BUG_ON (!path->dentry->d_op); -BUG_ON (!path->dentry->d_op->d_manage); ret = path->dentry->d_op->d_manage (path, false); flags =smp_load_acquire (&path->dentry->d_flags);if (ret <0 )break ; } -/* Transit to a mounted filesystem. */ -if (flags &DCACHE_MOUNTED ) { +if (flags &DCACHE_MOUNTED ) {// something's mounted on it.. struct vfsmount *mounted =lookup_mnt (path); -if (mounted) { +if (mounted) {// ... in our namespace dput (path->dentry);if (need_mntput)mntput (path->mnt); path->mnt = mounted; path->dentry =dget (mounted->mnt_root); +// here we know it's positive + flags = path->dentry->d_flags; need_mntput = true;continue ; } - -/* Something is mounted on this dentry in another -* namespace and/or whatever was mounted there in this -* namespace got unmounted before lookup_mnt() could -* get it */ } -/* Handle an automount point */ -if (flags &DCACHE_NEED_AUTOMOUNT ) { - ret =follow_automount (path, &nd->total_link_count, - nd->flags); -if (ret <0 ) -break ; -continue ; - } +if (!(flags &DCACHE_NEED_AUTOMOUNT )) +break ; -/* We didn't change the current path point */ -break ; +// uncovered automount point + ret =follow_automount (path, count, lookup_flags); + flags =smp_load_acquire (&path->dentry->d_flags); +if (ret <0 ) +break ; } -if (need_mntput) { -if (path->mnt == mnt) -mntput (path->mnt); -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) - ret = -EXDEV ; -else - nd->flags |=LOOKUP_JUMPED ; - } -if (ret == -EISDIR || !ret) - ret =1 ; -if (ret >0 &&unlikely (d_flags_negative (flags))) +if (ret == -EISDIR ) + ret =0 ; +// possible if you race with several mount --move +if (need_mntput && path->mnt == mnt) +mntput (path->mnt); +if (!ret &&unlikely (d_flags_negative (flags))) ret = -ENOENT ; -if (unlikely (ret <0 )) { -dput (path->dentry); -if (path->mnt != nd->path.mnt) -mntput (path->mnt); - } + *jumped = need_mntput;return ret; } +static inline int traverse_mounts (struct path *path,bool *jumped, +int *count,unsigned lookup_flags) +{ +unsigned flags =smp_load_acquire (&path->dentry->d_flags); + +/* fastpath */ +if (likely (!(flags &DCACHE_MANAGED_DENTRY ))) { + *jumped = false; +if (unlikely (d_flags_negative (flags))) +return -ENOENT ; +return 0 ; + } +return __traverse_mounts (path, flags, jumped, count, lookup_flags); +} +int follow_down_one (struct path *path) {struct vfsmount *mounted;
@@ -1270,6 +1258,23 @@ int follow_down_one(struct path *path)EXPORT_SYMBOL (follow_down_one);/* +* Follow down to the covering mount currently visible to userspace. At each +* point, the filesystem owning that dentry may be queried as to whether the +* caller is permitted to proceed or not. +*/ +int follow_down (struct path *path) +{ +struct vfsmount *mnt = path->mnt; +bool jumped; +int ret =traverse_mounts (path, &jumped,NULL ,0 ); + +if (path->mnt != mnt) +mntput (mnt); +return ret; +} +EXPORT_SYMBOL (follow_down); + +/* * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if * we meet a managed dentry that would need blocking. */
@@ -1325,6 +1330,7 @@ static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry, struct path *path, struct inode **inode, unsigned int *seqp) { + bool jumped;int ret; path->mnt = nd->path.mnt;
@@ -1334,15 +1340,25 @@ static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,if (unlikely (!*inode))return -ENOENT ;if (likely (__follow_mount_rcu (nd, path, inode, seqp))) -return 1 ; +return 0 ;if (unlazy_child (nd, dentry, seq))return -ECHILD ;// *path might've been clobbered by __follow_mount_rcu() path->mnt = nd->path.mnt; path->dentry = dentry; } - ret =follow_managed (path, nd); -if (likely (ret >=0 )) { + ret =traverse_mounts (path, &jumped, &nd->total_link_count, nd->flags); +if (jumped) { +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) + ret = -EXDEV ; +else + nd->flags |=LOOKUP_JUMPED ; + } +if (unlikely (ret)) { +dput (path->dentry); +if (path->mnt != nd->path.mnt) +mntput (path->mnt); + }else { *inode =d_backing_inode (path->dentry); *seqp =0 ;/* out of RCU mode, so the value doesn't matter */ }
@@ -1411,55 +1427,6 @@ static int follow_dotdot_rcu(struct nameidata *nd) }/* -* Follow down to the covering mount currently visible to userspace. At each -* point, the filesystem owning that dentry may be queried as to whether the -* caller is permitted to proceed or not. -*/ -int follow_down (struct path *path) -{ -unsigned managed; -int ret; - -while (managed =READ_ONCE (path->dentry->d_flags), -unlikely (managed &DCACHE_MANAGED_DENTRY )) { -/* Allow the filesystem to manage the transit without i_mutex -* being held. -* -* We indicate to the filesystem if someone is trying to mount -* something here. This gives autofs the chance to deny anyone -* other than its daemon the right to mount on its -* superstructure. -* -* The filesystem may sleep at this point. -*/ -if (managed &DCACHE_MANAGE_TRANSIT ) { -BUG_ON (!path->dentry->d_op); -BUG_ON (!path->dentry->d_op->d_manage); - ret = path->dentry->d_op->d_manage (path, false); -if (ret <0 ) -return ret == -EISDIR ?0 : ret; - } - -/* Transit to a mounted filesystem. */ -if (managed &DCACHE_MOUNTED ) { -struct vfsmount *mounted =lookup_mnt (path); -if (!mounted) -break ; -dput (path->dentry); -mntput (path->mnt); - path->mnt = mounted; - path->dentry =dget (mounted->mnt_root); -continue ; - } - -/* Don't handle automount points here */ -break ; - } -return 0 ; -} -EXPORT_SYMBOL (follow_down); - -/* * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() */ static void follow_mount (struct path *path)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 33/69 atomic_open(): return the right dentry in FMODE_OPENED case
In reply to Al ViroFrom: Al Viro <[email protected]>
->atomic_open() might have used a different alias than the one we'd passed to it; in "not opened" case we take care of that, in "opened" one we don't. Currently we don't care downstream of "opened" case which alias to return; however, that will change shortly when we get to unifying may_open() calls.
It's not hard to get right in all cases, anyway.
--- fs/namei.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
fs/namei.c +5 -1
@@ -2949,11 +2949,15 @@ static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,d_lookup_done (dentry);if (!error) {if (file->f_mode &FMODE_OPENED ) { +int acc_mode = op->acc_mode; +if (unlikely (dentry != file->f_path.dentry)) { +dput (dentry); + dentry =dget (file->f_path.dentry); + }/* * We didn't have the inode before the open, so check open * permission here. */ -int acc_mode = op->acc_mode;if (file->f_mode &FMODE_CREATED ) {WARN_ON (!(open_flag &O_CREAT ));fsnotify_create (dir, dentry);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 34/69 atomic_open(): lift the call of may_open() into do_last()
In reply to Al ViroFrom: Al Viro <[email protected]>
there we'll be able to merge it with its counterparts in other cases, and there's no reason to do it before the parent has been unlocked
--- fs/namei.c | 26 +++++++++++--------------- 1 file changed, 11 insertions(+), 15 deletions(-)
fs/namei.c +11 -15
@@ -2949,23 +2949,12 @@ static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,d_lookup_done (dentry);if (!error) {if (file->f_mode &FMODE_OPENED ) { -int acc_mode = op->acc_mode;if (unlikely (dentry != file->f_path.dentry)) {dput (dentry); dentry =dget (file->f_path.dentry); } -/* -* We didn't have the inode before the open, so check open -* permission here. -*/ -if (file->f_mode &FMODE_CREATED ) { -WARN_ON (!(open_flag &O_CREAT )); +if (file->f_mode &FMODE_CREATED )fsnotify_create (dir, dentry); - acc_mode =0 ; - } - error =may_open (&file->f_path, acc_mode, open_flag); -if (WARN_ON (error >0 )) - error = -EINVAL ; }else if (WARN_ON (file->f_path.dentry ==DENTRY_NOT_SET )) { error = -EIO ; }else {
@@ -3208,12 +3197,19 @@ static const char *do_last(struct nameidata *nd, }if (file->f_mode &FMODE_OPENED ) { -if ((file->f_mode &FMODE_CREATED ) || - !S_ISREG (file_inode (file)->i_mode)) +if (file->f_mode &FMODE_CREATED ) { + open_flag &= ~O_TRUNC ; + will_truncate = false; + acc_mode =0 ; + }else if (!S_ISREG (file_inode (file)->i_mode)) will_truncate = false;audit_inode (nd->name, file->f_path.dentry,0 ); -dput (dentry); +dput (nd->path.dentry); + nd->path.dentry = dentry; + error =may_open (&nd->path, acc_mode, open_flag); +if (error) + goto out; goto opened; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 35/69 do_last(): merge the may_open() calls
In reply to Al ViroFrom: Al Viro <[email protected]>
have FMODE_OPENED case rejoin the main path at earlier point
--- fs/namei.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
fs/namei.c +3 -7
@@ -3207,10 +3207,7 @@ static const char *do_last(struct nameidata *nd,audit_inode (nd->name, file->f_path.dentry,0 );dput (nd->path.dentry); nd->path.dentry = dentry; - error =may_open (&nd->path, acc_mode, open_flag); -if (error) - goto out; - goto opened; + goto finish_open_created; }if (file->f_mode &FMODE_CREATED ) {
@@ -3277,11 +3274,10 @@ static const char *do_last(struct nameidata *nd, error =may_open (&nd->path, acc_mode, open_flag);if (error) goto out; -BUG_ON (file->f_mode &FMODE_OPENED );/* once it's opened, it's opened */ - error =vfs_open (&nd->path, file); +if (!(file->f_mode &FMODE_OPENED )) + error =vfs_open (&nd->path, file);if (error) goto out; -opened: error =ima_file_check (file, op->acc_mode);if (!error && will_truncate) error =handle_truncate (file);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 36/69 do_last(): don't bother with keeping got_write in FMODE_OPENED case
In reply to Al ViroFrom: Al Viro <[email protected]>
it's easier to drop it right after lookup_open() and regain if needed (i.e. if we will need to truncate). On the non-FMODE_OPENED path we do that anyway. In case of FMODE_CREATED we won't be needing it. And it's easier to prove correctness that way, especially since the initial failure to get write access is not always fatal; proving that we'll never end up truncating in that case is rather convoluted.
--- fs/namei.c | 31 +++++++++++-------------------- 1 file changed, 11 insertions(+), 20 deletions(-)
fs/namei.c +11 -20
@@ -3191,11 +3191,14 @@ static const char *do_last(struct nameidata *nd,else inode_unlock_shared (dir->d_inode); -if (IS_ERR (dentry)) { - error =PTR_ERR (dentry); - goto out; +if (got_write) { +mnt_drop_write (nd->path.mnt); + got_write = false; } +if (IS_ERR (dentry)) +return ERR_CAST (dentry); +if (file->f_mode &FMODE_OPENED ) {if (file->f_mode &FMODE_CREATED ) { open_flag &= ~O_TRUNC ;
@@ -3220,16 +3223,6 @@ static const char *do_last(struct nameidata *nd, goto finish_open_created; } -/* -* If atomic_open() acquired write access it is dropped now due to -* possible mount and symlink following (this might be optimized away if -* necessary...) -*/ -if (got_write) { -mnt_drop_write (nd->path.mnt); - got_write = false; - } - finish_lookup:if (nd->depth)put_link (nd);
@@ -3250,27 +3243,25 @@ static const char *do_last(struct nameidata *nd,return ERR_PTR (error);audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) { - error = -EISDIR ;if (d_is_dir (nd->path.dentry)) - goto out; +return ERR_PTR (-EISDIR ); error =may_create_in_sticky (dir_mode, dir_uid,d_backing_inode (nd->path.dentry));if (unlikely (error)) - goto out; +return ERR_PTR (error); } - error = -ENOTDIR ;if ((nd->flags &LOOKUP_DIRECTORY ) && !d_can_lookup (nd->path.dentry)) - goto out; +return ERR_PTR (-ENOTDIR );if (!d_is_reg (nd->path.dentry)) will_truncate = false; +finish_open_created:if (will_truncate) { error =mnt_want_write (nd->path.mnt);if (error) - goto out; +return ERR_PTR (error); got_write = true; } -finish_open_created: error =may_open (&nd->path, acc_mode, open_flag);if (error) goto out;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 37/69 do_last(): rejoing the common path earlier in FMODE_{OPENED,CREATED} case
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-)
fs/namei.c +8 -13
@@ -3200,13 +3200,6 @@ static const char *do_last(struct nameidata *nd,return ERR_CAST (dentry);if (file->f_mode &FMODE_OPENED ) { -if (file->f_mode &FMODE_CREATED ) { - open_flag &= ~O_TRUNC ; - will_truncate = false; - acc_mode =0 ; - }else if (!S_ISREG (file_inode (file)->i_mode)) - will_truncate = false; -audit_inode (nd->name, file->f_path.dentry,0 );dput (nd->path.dentry); nd->path.dentry = dentry;
@@ -3214,10 +3207,6 @@ static const char *do_last(struct nameidata *nd, }if (file->f_mode &FMODE_CREATED ) { -/* Don't check for write permission, don't truncate */ - open_flag &= ~O_TRUNC ; - will_truncate = false; - acc_mode =0 ;dput (nd->path.dentry); nd->path.dentry = dentry; goto finish_open_created;
@@ -3252,10 +3241,16 @@ static const char *do_last(struct nameidata *nd, }if ((nd->flags &LOOKUP_DIRECTORY ) && !d_can_lookup (nd->path.dentry))return ERR_PTR (-ENOTDIR ); -if (!d_is_reg (nd->path.dentry)) - will_truncate = false; finish_open_created: +if (file->f_mode &FMODE_CREATED ) { +/* Don't check for write permission, don't truncate */ + open_flag &= ~O_TRUNC ; + will_truncate = false; + acc_mode =0 ; + }else if (!d_is_reg (nd->path.dentry)) { + will_truncate = false; + }if (will_truncate) { error =mnt_want_write (nd->path.mnt);if (error)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 38/69 do_last(): simplify the liveness analysis past finish_open_created
In reply to Al ViroFrom: Al Viro <[email protected]>
Don't mess with got_write there - it is guaranteed to be false on entry and it will be set true if and only if we decide to go for truncation and manage to get write access for that.
Don't carry acc_mode through the entire thing - it's only used in that part. And don't bother with gotos in there - compiler is quite capable of optimizing that.
--- fs/namei.c | 28 +++++++++++----------------- 1 file changed, 11 insertions(+), 17 deletions(-)
fs/namei.c +11 -17
@@ -3122,9 +3122,9 @@ static const char *do_last(struct nameidata *nd,kuid_t dir_uid = nd->inode->i_uid;umode_t dir_mode = nd->inode->i_mode;int open_flag = op->open_flag; -bool will_truncate = (open_flag &O_TRUNC ) !=0 ; +bool do_truncate;bool got_write = false; -int acc_mode = op->acc_mode; +int acc_mode;unsigned seq;struct inode *inode;struct dentry *dentry;
@@ -3243,36 +3243,30 @@ static const char *do_last(struct nameidata *nd,return ERR_PTR (-ENOTDIR ); finish_open_created: + do_truncate = false; + acc_mode = op->acc_mode;if (file->f_mode &FMODE_CREATED ) {/* Don't check for write permission, don't truncate */ open_flag &= ~O_TRUNC ; - will_truncate = false; acc_mode =0 ; - }else if (!d_is_reg (nd->path.dentry)) { - will_truncate = false; - } -if (will_truncate) { + }else if (d_is_reg (nd->path.dentry) && open_flag &O_TRUNC ) { error =mnt_want_write (nd->path.mnt);if (error)return ERR_PTR (error); - got_write = true; + do_truncate = true; } error =may_open (&nd->path, acc_mode, open_flag); -if (error) - goto out; -if (!(file->f_mode &FMODE_OPENED )) +if (!error && !(file->f_mode &FMODE_OPENED )) error =vfs_open (&nd->path, file); -if (error) - goto out; - error =ima_file_check (file, op->acc_mode); -if (!error && will_truncate) +if (!error) + error =ima_file_check (file, op->acc_mode); +if (!error && do_truncate) error =handle_truncate (file); -out:if (unlikely (error >0 )) {WARN_ON (1 ); error = -EINVAL ; } -if (got_write) +if (do_truncate)mnt_drop_write (nd->path.mnt);return ERR_PTR (error); }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 39/69 do_last(): rejoin the common path even earlier in FMODE_{OPENED,CREATED} case
In reply to Al ViroFrom: Al Viro <[email protected]>
... getting may_create_in_sticky() checks in FMODE_OPENED case as well.
--- fs/namei.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
fs/namei.c +4 -10
@@ -3199,14 +3199,7 @@ static const char *do_last(struct nameidata *nd,if (IS_ERR (dentry))return ERR_CAST (dentry); -if (file->f_mode &FMODE_OPENED ) { -audit_inode (nd->name, file->f_path.dentry,0 ); -dput (nd->path.dentry); - nd->path.dentry = dentry; - goto finish_open_created; - } - -if (file->f_mode &FMODE_CREATED ) { +if (file->f_mode & (FMODE_OPENED |FMODE_CREATED )) {dput (nd->path.dentry); nd->path.dentry = dentry; goto finish_open_created;
@@ -3230,7 +3223,9 @@ static const char *do_last(struct nameidata *nd, error =complete_walk (nd);if (error)return ERR_PTR (error); -audit_inode (nd->name, nd->path.dentry,0 ); +finish_open_created: +if (!(file->f_mode &FMODE_CREATED )) +audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) {if (d_is_dir (nd->path.dentry))return ERR_PTR (-EISDIR );
@@ -3242,7 +3237,6 @@ static const char *do_last(struct nameidata *nd,if ((nd->flags &LOOKUP_DIRECTORY ) && !d_can_lookup (nd->path.dentry))return ERR_PTR (-ENOTDIR ); -finish_open_created: do_truncate = false; acc_mode = op->acc_mode;if (file->f_mode &FMODE_CREATED ) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 40/69 split the lookup-related parts of do_last() into a separate helper
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 51 +++++++++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 22 deletions(-)
fs/namei.c +29 -22
@@ -3112,19 +3112,12 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file,return ERR_PTR (error); } -/* -* Handle the last step of open() -*/ -static const char *do_last (struct nameidata *nd, +static const char *open_last_lookups (struct nameidata *nd,struct file *file,const struct open_flags *op) {struct dentry *dir = nd->path.dentry; -kuid_t dir_uid = nd->inode->i_uid; -umode_t dir_mode = nd->inode->i_mode;int open_flag = op->open_flag; -bool do_truncate;bool got_write = false; -int acc_mode;unsigned seq;struct inode *inode;struct dentry *dentry;
@@ -3137,9 +3130,9 @@ static const char *do_last(struct nameidata *nd,if (nd->depth)put_link (nd); error =handle_dots (nd, nd->last_type); -if (unlikely (error)) -return ERR_PTR (error); - goto finish_open; +if (likely (!error)) + error =complete_walk (nd); +return ERR_PTR (error); }if (!(open_flag &O_CREAT )) {
@@ -3152,7 +3145,6 @@ static const char *do_last(struct nameidata *nd,if (likely (dentry)) goto finish_lookup; -BUG_ON (nd->inode != dir->d_inode);BUG_ON (nd->flags &LOOKUP_RCU ); }else {/* create side of things */
@@ -3162,7 +3154,7 @@ static const char *do_last(struct nameidata *nd,* about to look up */ error =complete_walk (nd); -if (error) +if (unlikely (error))return ERR_PTR (error);audit_inode (nd->name, dir,AUDIT_INODE_PARENT );
@@ -3191,10 +3183,8 @@ static const char *do_last(struct nameidata *nd,else inode_unlock_shared (dir->d_inode); -if (got_write) { +if (got_write)mnt_drop_write (nd->path.mnt); - got_write = false; - }if (IS_ERR (dentry))return ERR_CAST (dentry);
@@ -3202,7 +3192,7 @@ static const char *do_last(struct nameidata *nd,if (file->f_mode & (FMODE_OPENED |FMODE_CREATED )) {dput (nd->path.dentry); nd->path.dentry = dentry; - goto finish_open_created; +return NULL ; } finish_lookup:
@@ -3218,12 +3208,29 @@ static const char *do_last(struct nameidata *nd,audit_inode (nd->name, nd->path.dentry,0 );return ERR_PTR (-EEXIST ); } -finish_open: +/* Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... */ - error =complete_walk (nd); -if (error) -return ERR_PTR (error); -finish_open_created: +return ERR_PTR (complete_walk (nd)); +} + +/* +* Handle the last step of open() +*/ +static const char *do_last (struct nameidata *nd, +struct file *file,const struct open_flags *op) +{ +kuid_t dir_uid = nd->inode->i_uid; +umode_t dir_mode = nd->inode->i_mode; +int open_flag = op->open_flag; +bool do_truncate; +int acc_mode; +const char *link; +int error; + + link =open_last_lookups (nd, file, op); +if (unlikely (link)) +return link; +if (!(file->f_mode &FMODE_CREATED ))audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 41/69 path_connected(): pass mount and dentry separately
In reply to Al ViroFrom: Al Viro <[email protected]>
eventually we'll want to do that check *before* mangling nd->path.dentry...
--- fs/namei.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
fs/namei.c +5 -7
@@ -550,22 +550,20 @@ static int __nd_alloc_stack(struct nameidata *nd) }/** -* path_connected - Verify that a path->dentry is below path->mnt.mnt_root -* @path: nameidate to verify +* path_connected - Verify that a dentry is below mnt.mnt_root * * Rename can sometimes move a file or directory outside of a bind * mount, path_connected allows those cases to be detected. */ -static bool path_connected (const struct path *path) +static bool path_connected (struct vfsmount *mnt,struct dentry *dentry) { -struct vfsmount *mnt = path->mnt;struct super_block *sb = mnt->mnt_sb;/* Bind mounts and multi-root filesystems can have disconnected paths */ if (!(sb->s_iflags &SB_I_MULTIROOT ) && (mnt->mnt_root == sb->s_root))return true; -return is_subdir (path->dentry, mnt->mnt_root); +return is_subdir (dentry, mnt->mnt_root); }static inline int nd_alloc_stack (struct nameidata *nd)
@@ -1386,7 +1384,7 @@ static int follow_dotdot_rcu(struct nameidata *nd)return -ECHILD ; nd->path.dentry = parent; nd->seq = seq; -if (unlikely (!path_connected (&nd->path))) +if (unlikely (!path_connected (nd->path.mnt, parent)))return -ECHILD ;break ; }else {
@@ -1448,7 +1446,7 @@ static int path_parent_directory(struct path *path)/* rare case of legitimate dget_parent()... */ path->dentry =dget_parent (path->dentry);dput (old); -if (unlikely (!path_connected (path))) +if (unlikely (!path_connected (path->mnt, path->dentry)))return -ENOENT ;return 0 ; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 42/69 path_parent_directory(): leave changing path->dentry to callers
In reply to Al ViroFrom: Al Viro <[email protected]>
Instead of returning 0, return new dentry; instead of returning -ENOENT, return NULL. Adjust the callers accordingly.
--- fs/namei.c | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-)
fs/namei.c +19 -15
@@ -1440,19 +1440,21 @@ static void follow_mount(struct path *path) } } -static int path_parent_directory (struct path *path) +static struct dentry *path_parent_directory (struct path *path) { -struct dentry *old = path->dentry;/* rare case of legitimate dget_parent()... */ - path->dentry =dget_parent (path->dentry); -dput (old); -if (unlikely (!path_connected (path->mnt, path->dentry))) -return -ENOENT ; -return 0 ; +struct dentry *parent =dget_parent (path->dentry); + +if (unlikely (!path_connected (path->mnt, parent))) { +dput (parent); + parent =NULL ; + } +return parent; }static int follow_dotdot (struct nameidata *nd) { +struct dentry *parent;while (1 ) {if (path_equal (&nd->path, &nd->root)) {if (unlikely (nd->flags &LOOKUP_BENEATH ))
@@ -1460,9 +1462,11 @@ static int follow_dotdot(struct nameidata *nd)break ; }if (nd->path.dentry != nd->path.mnt->mnt_root) { -int ret =path_parent_directory (&nd->path); -if (ret) -return ret; + parent =path_parent_directory (&nd->path); +if (!parent) +return -ENOENT ; +dput (nd->path.dentry); + nd->path.dentry = parent;break ; }if (!follow_up (&nd->path))
@@ -2600,13 +2604,13 @@ int path_pts(struct path *path)*/ struct dentry *child, *parent;struct qstr this; -int ret; - ret =path_parent_directory (path); -if (ret) -return ret; + parent =path_parent_directory (path); +if (!parent) +return -ENOENT ; - parent = path->dentry; +dput (path->dentry); + path->dentry = parent; this.name ="pts" ; this.len =3 ; child =d_hash_and_lookup (parent, &this);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 43/69 expand path_parent_directory() in its callers
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-)
fs/namei.c +11 -18
@@ -1440,18 +1440,6 @@ static void follow_mount(struct path *path) } } -static struct dentry *path_parent_directory (struct path *path) -{ -/* rare case of legitimate dget_parent()... */ -struct dentry *parent =dget_parent (path->dentry); - -if (unlikely (!path_connected (path->mnt, parent))) { -dput (parent); - parent =NULL ; - } -return parent; -} -static int follow_dotdot (struct nameidata *nd) {struct dentry *parent;
@@ -1462,9 +1450,13 @@ static int follow_dotdot(struct nameidata *nd)break ; }if (nd->path.dentry != nd->path.mnt->mnt_root) { - parent =path_parent_directory (&nd->path); -if (!parent) +/* rare case of legitimate dget_parent()... */ + parent =dget_parent (nd->path.dentry); + +if (unlikely (!path_connected (nd->path.mnt, parent))) { +dput (parent);return -ENOENT ; + }dput (nd->path.dentry); nd->path.dentry = parent;break ;
@@ -2602,13 +2594,14 @@ int path_pts(struct path *path)/* Find something mounted on "pts" in the same directory as * the input path. */ -struct dentry *child, *parent; +struct dentry *parent =dget_parent (path->dentry); +struct dentry *child;struct qstr this; - parent =path_parent_directory (path); -if (!parent) +if (unlikely (!path_connected (path->mnt, parent))) { +dput (parent);return -ENOENT ; - + }dput (path->dentry); path->dentry = parent; this.name ="pts" ;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 44/69 follow_dotdot{,_rcu}(): lift switching nd->path to parent out of loop
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-)
fs/namei.c +12 -8
@@ -1365,7 +1365,9 @@ static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,static int follow_dotdot_rcu (struct nameidata *nd) { +struct dentry *parent =NULL ;struct inode *inode = nd->inode; +unsigned seq;while (1 ) {if (path_equal (&nd->path, &nd->root)) {
@@ -1375,15 +1377,12 @@ static int follow_dotdot_rcu(struct nameidata *nd) }if (nd->path.dentry != nd->path.mnt->mnt_root) {struct dentry *old = nd->path.dentry; -struct dentry *parent = old->d_parent; -unsigned seq; + parent = old->d_parent; inode = parent->d_inode; seq =read_seqcount_begin (&parent->d_seq);if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq)))return -ECHILD ; - nd->path.dentry = parent; - nd->seq = seq;if (unlikely (!path_connected (nd->path.mnt, parent)))return -ECHILD ;break ;
@@ -1406,6 +1405,10 @@ static int follow_dotdot_rcu(struct nameidata *nd) nd->seq = seq; } } +if (likely (parent)) { + nd->path.dentry = parent; + nd->seq = seq; + }while (unlikely (d_mountpoint (nd->path.dentry))) {struct mount *mounted; mounted =__lookup_mnt (nd->path.mnt, nd->path.dentry);
@@ -1442,7 +1445,7 @@ static void follow_mount(struct path *path)static int follow_dotdot (struct nameidata *nd) { -struct dentry *parent; +struct dentry *parent =NULL ;while (1 ) {if (path_equal (&nd->path, &nd->root)) {if (unlikely (nd->flags &LOOKUP_BENEATH ))
@@ -1452,13 +1455,10 @@ static int follow_dotdot(struct nameidata *nd)if (nd->path.dentry != nd->path.mnt->mnt_root) {/* rare case of legitimate dget_parent()... */ parent =dget_parent (nd->path.dentry); -if (unlikely (!path_connected (nd->path.mnt, parent))) {dput (parent);return -ENOENT ; } -dput (nd->path.dentry); - nd->path.dentry = parent;break ; }if (!follow_up (&nd->path))
@@ -1466,6 +1466,10 @@ static int follow_dotdot(struct nameidata *nd)if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return -EXDEV ; } +if (likely (parent)) { +dput (nd->path.dentry); + nd->path.dentry = parent; + }follow_mount (&nd->path); nd->inode = nd->path.dentry->d_inode;return 0 ;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 45/69 follow_dotdot{,_rcu}(): lift LOOKUP_BENEATH checks out of loop
In reply to Al ViroFrom: Al Viro <[email protected]>
Behaviour change: LOOKUP_BENEATH lookup of .. in absolute root yields an error even if it's not the process' root. That's possible only if you'd managed to escape chroot jail by way of procfs symlinks, but IMO the resulting behaviour is not worse - more consistent and easier to describe:
".." in root is "stay where you are", uness LOOKUP_BENEATH has been given, in which case it's "fail with EXDEV".
--- fs/namei.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
fs/namei.c +10 -10
@@ -1370,11 +1370,8 @@ static int follow_dotdot_rcu(struct nameidata *nd)unsigned seq;while (1 ) { -if (path_equal (&nd->path, &nd->root)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -ECHILD ; +if (path_equal (&nd->path, &nd->root))break ; - }if (nd->path.dentry != nd->path.mnt->mnt_root) {struct dentry *old = nd->path.dentry;
@@ -1405,7 +1402,10 @@ static int follow_dotdot_rcu(struct nameidata *nd) nd->seq = seq; } } -if (likely (parent)) { +if (unlikely (!parent)) { +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return -ECHILD ; + }else { nd->path.dentry = parent; nd->seq = seq; }
@@ -1447,11 +1447,8 @@ static int follow_dotdot(struct nameidata *nd) {struct dentry *parent =NULL ;while (1 ) { -if (path_equal (&nd->path, &nd->root)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -EXDEV ; +if (path_equal (&nd->path, &nd->root))break ; - }if (nd->path.dentry != nd->path.mnt->mnt_root) {/* rare case of legitimate dget_parent()... */ parent =dget_parent (nd->path.dentry);
@@ -1466,7 +1463,10 @@ static int follow_dotdot(struct nameidata *nd)if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return -EXDEV ; } -if (likely (parent)) { +if (unlikely (!parent)) { +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return -EXDEV ; + }else {dput (nd->path.dentry); nd->path.dentry = parent; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 46/69 move handle_dots(), follow_dotdot() and follow_dotdot_rcu() past step_into()
In reply to Al ViroFrom: Al Viro <[email protected]>
pure move; we are going to have step_into() called by that bunch.
--- fs/namei.c | 260 ++++++++++++++++++++++++++++++------------------------------- 1 file changed, 130 insertions(+), 130 deletions(-)
fs/namei.c +130 -130
@@ -1363,70 +1363,6 @@ static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,return ret; } -static int follow_dotdot_rcu (struct nameidata *nd) -{ -struct dentry *parent =NULL ; -struct inode *inode = nd->inode; -unsigned seq; - -while (1 ) { -if (path_equal (&nd->path, &nd->root)) -break ; -if (nd->path.dentry != nd->path.mnt->mnt_root) { -struct dentry *old = nd->path.dentry; - - parent = old->d_parent; - inode = parent->d_inode; - seq =read_seqcount_begin (&parent->d_seq); -if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq))) -return -ECHILD ; -if (unlikely (!path_connected (nd->path.mnt, parent))) -return -ECHILD ; -break ; - }else { -struct mount *mnt =real_mount (nd->path.mnt); -struct mount *mparent = mnt->mnt_parent; -struct dentry *mountpoint = mnt->mnt_mountpoint; -struct inode *inode2 = mountpoint->d_inode; -unsigned seq =read_seqcount_begin (&mountpoint->d_seq); -if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return -ECHILD ; -if (&mparent->mnt == nd->path.mnt) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -ECHILD ; -/* we know that mountpoint was pinned */ - nd->path.dentry = mountpoint; - nd->path.mnt = &mparent->mnt; - inode = inode2; - nd->seq = seq; - } - } -if (unlikely (!parent)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -ECHILD ; - }else { - nd->path.dentry = parent; - nd->seq = seq; - } -while (unlikely (d_mountpoint (nd->path.dentry))) { -struct mount *mounted; - mounted =__lookup_mnt (nd->path.mnt, nd->path.dentry); -if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return -ECHILD ; -if (!mounted) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -ECHILD ; - nd->path.mnt = &mounted->mnt; - nd->path.dentry = mounted->mnt.mnt_root; - inode = nd->path.dentry->d_inode; - nd->seq =read_seqcount_begin (&nd->path.dentry->d_seq); - } - nd->inode = inode; -return 0 ; -} -/* * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() */
@@ -1443,38 +1379,6 @@ static void follow_mount(struct path *path) } } -static int follow_dotdot (struct nameidata *nd) -{ -struct dentry *parent =NULL ; -while (1 ) { -if (path_equal (&nd->path, &nd->root)) -break ; -if (nd->path.dentry != nd->path.mnt->mnt_root) { -/* rare case of legitimate dget_parent()... */ - parent =dget_parent (nd->path.dentry); -if (unlikely (!path_connected (nd->path.mnt, parent))) { -dput (parent); -return -ENOENT ; - } -break ; - } -if (!follow_up (&nd->path)) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -EXDEV ; - } -if (unlikely (!parent)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -EXDEV ; - }else { -dput (nd->path.dentry); - nd->path.dentry = parent; - } -follow_mount (&nd->path); - nd->inode = nd->path.dentry->d_inode; -return 0 ; -} -/* * This looks up the name in dcache and possibly revalidates the found dentry. * NULL is returned if the dentry does not exist in the cache.
@@ -1654,40 +1558,6 @@ static inline int may_lookup(struct nameidata *nd)return inode_permission (nd->inode,MAY_EXEC ); } -static inline int handle_dots (struct nameidata *nd,int type) -{ -if (type ==LAST_DOTDOT ) { -int error =0 ; - -if (!nd->root.mnt) { - error =set_root (nd); -if (error) -return error; - } -if (nd->flags &LOOKUP_RCU ) - error =follow_dotdot_rcu (nd); -else - error =follow_dotdot (nd); -if (error) -return error; - -if (unlikely (nd->flags &LOOKUP_IS_SCOPED )) { -/* -* If there was a racing rename or mount along our -* path, then we can't be sure that ".." hasn't jumped -* above nd->root (and so userspace should retry or use -* some fallback). -*/ -smp_rmb (); -if (unlikely (__read_seqcount_retry (&mount_lock.seqcount, nd->m_seq))) -return -EAGAIN ; -if (unlikely (__read_seqcount_retry (&rename_lock.seqcount, nd->r_seq))) -return -EAGAIN ; - } - } -return 0 ; -} -enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 }; static const char *pick_link(struct nameidata *nd, struct path *link,
@@ -1817,6 +1687,136 @@ static const char *step_into(struct nameidata *nd, int flags,return pick_link (nd, &path, inode, seq, flags); } +static int follow_dotdot_rcu (struct nameidata *nd) +{ +struct dentry *parent =NULL ; +struct inode *inode = nd->inode; +unsigned seq; + +while (1 ) { +if (path_equal (&nd->path, &nd->root)) +break ; +if (nd->path.dentry != nd->path.mnt->mnt_root) { +struct dentry *old = nd->path.dentry; + + parent = old->d_parent; + inode = parent->d_inode; + seq =read_seqcount_begin (&parent->d_seq); +if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq))) +return -ECHILD ; +if (unlikely (!path_connected (nd->path.mnt, parent))) +return -ECHILD ; +break ; + }else { +struct mount *mnt =real_mount (nd->path.mnt); +struct mount *mparent = mnt->mnt_parent; +struct dentry *mountpoint = mnt->mnt_mountpoint; +struct inode *inode2 = mountpoint->d_inode; +unsigned seq =read_seqcount_begin (&mountpoint->d_seq); +if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) +return -ECHILD ; +if (&mparent->mnt == nd->path.mnt) +break ; +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return -ECHILD ; +/* we know that mountpoint was pinned */ + nd->path.dentry = mountpoint; + nd->path.mnt = &mparent->mnt; + inode = inode2; + nd->seq = seq; + } + } +if (unlikely (!parent)) { +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return -ECHILD ; + }else { + nd->path.dentry = parent; + nd->seq = seq; + } +while (unlikely (d_mountpoint (nd->path.dentry))) { +struct mount *mounted; + mounted =__lookup_mnt (nd->path.mnt, nd->path.dentry); +if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) +return -ECHILD ; +if (!mounted) +break ; +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return -ECHILD ; + nd->path.mnt = &mounted->mnt; + nd->path.dentry = mounted->mnt.mnt_root; + inode = nd->path.dentry->d_inode; + nd->seq =read_seqcount_begin (&nd->path.dentry->d_seq); + } + nd->inode = inode; +return 0 ; +} + +static int follow_dotdot (struct nameidata *nd) +{ +struct dentry *parent =NULL ; +while (1 ) { +if (path_equal (&nd->path, &nd->root)) +break ; +if (nd->path.dentry != nd->path.mnt->mnt_root) { +/* rare case of legitimate dget_parent()... */ + parent =dget_parent (nd->path.dentry); +if (unlikely (!path_connected (nd->path.mnt, parent))) { +dput (parent); +return -ENOENT ; + } +break ; + } +if (!follow_up (&nd->path)) +break ; +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return -EXDEV ; + } +if (unlikely (!parent)) { +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return -EXDEV ; + }else { +dput (nd->path.dentry); + nd->path.dentry = parent; + } +follow_mount (&nd->path); + nd->inode = nd->path.dentry->d_inode; +return 0 ; +} + +static inline int handle_dots (struct nameidata *nd,int type) +{ +if (type ==LAST_DOTDOT ) { +int error =0 ; + +if (!nd->root.mnt) { + error =set_root (nd); +if (error) +return error; + } +if (nd->flags &LOOKUP_RCU ) + error =follow_dotdot_rcu (nd); +else + error =follow_dotdot (nd); +if (error) +return error; + +if (unlikely (nd->flags &LOOKUP_IS_SCOPED )) { +/* +* If there was a racing rename or mount along our +* path, then we can't be sure that ".." hasn't jumped +* above nd->root (and so userspace should retry or use +* some fallback). +*/ +smp_rmb (); +if (unlikely (__read_seqcount_retry (&mount_lock.seqcount, nd->m_seq))) +return -EAGAIN ; +if (unlikely (__read_seqcount_retry (&rename_lock.seqcount, nd->r_seq))) +return -EAGAIN ; + } + } +return 0 ; +} +static const char *walk_component (struct nameidata *nd,int flags) {struct dentry *dentry;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 47/69 handle_dots(), follow_dotdot{,_rcu}(): preparation to switch to step_into()
In reply to Al ViroFrom: Al Viro <[email protected]>
Right now the tail ends of follow_dotdot{,_rcu}() are pretty much the open-coded analogues of step_into(). The differences:
* the lack of proper LOOKUP_NO_XDEV handling in non-RCU case
(arguably a bug)
* the lack of ->d_manage() handling (again, arguably a bug)
Adjust the calling conventions so that on the next step with could just switch those functions to returning step_into().
--- fs/namei.c | 52 +++++++++++++++++++++++++--------------------------- 1 file changed, 25 insertions(+), 27 deletions(-)
fs/namei.c +25 -27
@@ -1687,7 +1687,7 @@ static const char *step_into(struct nameidata *nd, int flags,return pick_link (nd, &path, inode, seq, flags); } -static int follow_dotdot_rcu (struct nameidata *nd) +static const char *follow_dotdot_rcu (struct nameidata *nd) {struct dentry *parent =NULL ;struct inode *inode = nd->inode;
@@ -1703,9 +1703,9 @@ static int follow_dotdot_rcu(struct nameidata *nd) inode = parent->d_inode; seq =read_seqcount_begin (&parent->d_seq);if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq))) -return -ECHILD ; +return ERR_PTR (-ECHILD );if (unlikely (!path_connected (nd->path.mnt, parent))) -return -ECHILD ; +return ERR_PTR (-ECHILD );break ; }else {struct mount *mnt =real_mount (nd->path.mnt);
@@ -1714,11 +1714,11 @@ static int follow_dotdot_rcu(struct nameidata *nd)struct inode *inode2 = mountpoint->d_inode;unsigned seq =read_seqcount_begin (&mountpoint->d_seq);if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return -ECHILD ; +return ERR_PTR (-ECHILD );if (&mparent->mnt == nd->path.mnt)break ;if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -ECHILD ; +return ERR_PTR (-ECHILD );/* we know that mountpoint was pinned */ nd->path.dentry = mountpoint; nd->path.mnt = &mparent->mnt;
@@ -1728,7 +1728,7 @@ static int follow_dotdot_rcu(struct nameidata *nd) }if (unlikely (!parent)) {if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -ECHILD ; +return ERR_PTR (-ECHILD ); }else { nd->path.dentry = parent; nd->seq = seq;
@@ -1737,21 +1737,21 @@ static int follow_dotdot_rcu(struct nameidata *nd)struct mount *mounted; mounted =__lookup_mnt (nd->path.mnt, nd->path.dentry);if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return -ECHILD ; +return ERR_PTR (-ECHILD );if (!mounted)break ;if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -ECHILD ; +return ERR_PTR (-ECHILD ); nd->path.mnt = &mounted->mnt; nd->path.dentry = mounted->mnt.mnt_root; inode = nd->path.dentry->d_inode; nd->seq =read_seqcount_begin (&nd->path.dentry->d_seq); } nd->inode = inode; -return 0 ; +return NULL ; } -static int follow_dotdot (struct nameidata *nd) +static const char *follow_dotdot (struct nameidata *nd) {struct dentry *parent =NULL ;while (1 ) {
@@ -1762,34 +1762,34 @@ static int follow_dotdot(struct nameidata *nd) parent =dget_parent (nd->path.dentry);if (unlikely (!path_connected (nd->path.mnt, parent))) {dput (parent); -return -ENOENT ; +return ERR_PTR (-ENOENT ); }break ; }if (!follow_up (&nd->path))break ;if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return -EXDEV ; +return ERR_PTR (-EXDEV ); }if (unlikely (!parent)) {if (unlikely (nd->flags &LOOKUP_BENEATH )) -return -EXDEV ; +return ERR_PTR (-EXDEV ); }else {dput (nd->path.dentry); nd->path.dentry = parent; }follow_mount (&nd->path); nd->inode = nd->path.dentry->d_inode; -return 0 ; +return NULL ; } -static inline int handle_dots (struct nameidata *nd,int type) +static const char *handle_dots (struct nameidata *nd,int type) {if (type ==LAST_DOTDOT ) { -int error =0 ; +const char *error =NULL ;if (!nd->root.mnt) { - error =set_root (nd); + error =ERR_PTR (set_root (nd));if (error)return error; }
@@ -1809,12 +1809,12 @@ static inline int handle_dots(struct nameidata *nd, int type)*/ smp_rmb ();if (unlikely (__read_seqcount_retry (&mount_lock.seqcount, nd->m_seq))) -return -EAGAIN ; +return ERR_PTR (-EAGAIN );if (unlikely (__read_seqcount_retry (&rename_lock.seqcount, nd->r_seq))) -return -EAGAIN ; +return ERR_PTR (-EAGAIN ); } } -return 0 ; +return NULL ; }static const char *walk_component (struct nameidata *nd,int flags)
@@ -1822,7 +1822,6 @@ static const char *walk_component(struct nameidata *nd, int flags)struct dentry *dentry;struct inode *inode;unsigned seq; -int err;/* * "." and ".." are special - ".." especially so because it has * to be able to know about the current root directory and
@@ -1831,8 +1830,7 @@ static const char *walk_component(struct nameidata *nd, int flags)if (unlikely (nd->last_type !=LAST_NORM )) {if (!(flags &WALK_MORE ) && nd->depth)put_link (nd); - err =handle_dots (nd, nd->last_type); -return ERR_PTR (err); +return handle_dots (nd, nd->last_type); } dentry =lookup_fast (nd, &inode, &seq);if (IS_ERR (dentry))
@@ -3128,10 +3126,10 @@ static const char *open_last_lookups(struct nameidata *nd,if (nd->last_type !=LAST_NORM ) {if (nd->depth)put_link (nd); - error =handle_dots (nd, nd->last_type); -if (likely (!error)) - error =complete_walk (nd); -return ERR_PTR (error); + res =handle_dots (nd, nd->last_type); +if (likely (!res)) + res =ERR_PTR (complete_walk (nd)); +return res; }if (!(open_flag &O_CREAT )) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 48/69 follow_dotdot{,_rcu}(): switch to use of step_into()
In reply to Al ViroFrom: Al Viro <[email protected]>
gets the regular mount crossing on result of ..
--- fs/namei.c | 31 +++++++------------------------ 1 file changed, 7 insertions(+), 24 deletions(-)
fs/namei.c +7 -24
@@ -1722,33 +1722,18 @@ static const char *follow_dotdot_rcu(struct nameidata *nd)/* we know that mountpoint was pinned */ nd->path.dentry = mountpoint; nd->path.mnt = &mparent->mnt; - inode = inode2; + inode = nd->inode = inode2; nd->seq = seq; } }if (unlikely (!parent)) {if (unlikely (nd->flags &LOOKUP_BENEATH ))return ERR_PTR (-ECHILD ); +return step_into (nd,WALK_NOFOLLOW , + nd->path.dentry, nd->inode, nd->seq); }else { - nd->path.dentry = parent; - nd->seq = seq; +return step_into (nd,WALK_NOFOLLOW , parent, inode, seq); } -while (unlikely (d_mountpoint (nd->path.dentry))) { -struct mount *mounted; - mounted =__lookup_mnt (nd->path.mnt, nd->path.dentry); -if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return ERR_PTR (-ECHILD ); -if (!mounted) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return ERR_PTR (-ECHILD ); - nd->path.mnt = &mounted->mnt; - nd->path.dentry = mounted->mnt.mnt_root; - inode = nd->path.dentry->d_inode; - nd->seq =read_seqcount_begin (&nd->path.dentry->d_seq); - } - nd->inode = inode; -return NULL ; }static const char *follow_dotdot (struct nameidata *nd)
@@ -1774,13 +1759,11 @@ static const char *follow_dotdot(struct nameidata *nd)if (unlikely (!parent)) {if (unlikely (nd->flags &LOOKUP_BENEATH ))return ERR_PTR (-EXDEV ); +return step_into (nd,WALK_NOFOLLOW , +dget (nd->path.dentry), nd->inode, nd->seq); }else { -dput (nd->path.dentry); - nd->path.dentry = parent; +return step_into (nd,WALK_NOFOLLOW , parent, parent->d_inode,0 ); } -follow_mount (&nd->path); - nd->inode = nd->path.dentry->d_inode; -return NULL ; }static const char *handle_dots (struct nameidata *nd,int type)
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 49/69 lift all calls of step_into() out of follow_dotdot/follow_dotdot_rcu
In reply to Al ViroFrom: Al Viro <[email protected]>
lift step_into() into handle_dots() (where they merge with each other); have follow_... return dentry and pass inode/seq to the caller.
--- fs/namei.c | 72 ++++++++++++++++++++++++++++++++------------------------------ 1 file changed, 37 insertions(+), 35 deletions(-)
fs/namei.c +37 -35
@@ -1687,31 +1687,29 @@ static const char *step_into(struct nameidata *nd, int flags,return pick_link (nd, &path, inode, seq, flags); } -static const char *follow_dotdot_rcu (struct nameidata *nd) +static struct dentry *follow_dotdot_rcu (struct nameidata *nd, +struct inode **inodep, +unsigned *seqp) { -struct dentry *parent =NULL ; -struct inode *inode = nd->inode; -unsigned seq; -while (1 ) {if (path_equal (&nd->path, &nd->root))break ;if (nd->path.dentry != nd->path.mnt->mnt_root) {struct dentry *old = nd->path.dentry; +struct dentry *parent = old->d_parent; - parent = old->d_parent; - inode = parent->d_inode; - seq =read_seqcount_begin (&parent->d_seq); + *inodep = parent->d_inode; + *seqp =read_seqcount_begin (&parent->d_seq);if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq)))return ERR_PTR (-ECHILD );if (unlikely (!path_connected (nd->path.mnt, parent)))return ERR_PTR (-ECHILD ); -break ; +return parent; }else {struct mount *mnt =real_mount (nd->path.mnt);struct mount *mparent = mnt->mnt_parent;struct dentry *mountpoint = mnt->mnt_mountpoint; -struct inode *inode2 = mountpoint->d_inode; +struct inode *inode = mountpoint->d_inode;unsigned seq =read_seqcount_begin (&mountpoint->d_seq);if (unlikely (read_seqretry (&mount_lock, nd->m_seq)))return ERR_PTR (-ECHILD );
@@ -1722,54 +1720,51 @@ static const char *follow_dotdot_rcu(struct nameidata *nd)/* we know that mountpoint was pinned */ nd->path.dentry = mountpoint; nd->path.mnt = &mparent->mnt; - inode = nd->inode = inode2; + nd->inode = inode; nd->seq = seq; } } -if (unlikely (!parent)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return ERR_PTR (-ECHILD ); -return step_into (nd,WALK_NOFOLLOW , - nd->path.dentry, nd->inode, nd->seq); - }else { -return step_into (nd,WALK_NOFOLLOW , parent, inode, seq); - } +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return ERR_PTR (-ECHILD ); +return NULL ; } -static const char *follow_dotdot (struct nameidata *nd) +static struct dentry *follow_dotdot (struct nameidata *nd, +struct inode **inodep, +unsigned *seqp) { -struct dentry *parent =NULL ;while (1 ) {if (path_equal (&nd->path, &nd->root))break ;if (nd->path.dentry != nd->path.mnt->mnt_root) {/* rare case of legitimate dget_parent()... */ - parent =dget_parent (nd->path.dentry); +struct dentry *parent =dget_parent (nd->path.dentry);if (unlikely (!path_connected (nd->path.mnt, parent))) {dput (parent);return ERR_PTR (-ENOENT ); } -break ; + *seqp =0 ; + *inodep = parent->d_inode; +return parent; }if (!follow_up (&nd->path))break ;if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return ERR_PTR (-EXDEV ); } -if (unlikely (!parent)) { -if (unlikely (nd->flags &LOOKUP_BENEATH )) -return ERR_PTR (-EXDEV ); -return step_into (nd,WALK_NOFOLLOW , -dget (nd->path.dentry), nd->inode, nd->seq); - }else { -return step_into (nd,WALK_NOFOLLOW , parent, parent->d_inode,0 ); - } +if (unlikely (nd->flags &LOOKUP_BENEATH )) +return ERR_PTR (-EXDEV ); +dget (nd->path.dentry); +return NULL ; }static const char *handle_dots (struct nameidata *nd,int type) {if (type ==LAST_DOTDOT ) {const char *error =NULL ; +struct dentry *parent; +struct inode *inode; +unsigned seq;if (!nd->root.mnt) { error =ERR_PTR (set_root (nd));
@@ -1777,11 +1772,18 @@ static const char *handle_dots(struct nameidata *nd, int type)return error; }if (nd->flags &LOOKUP_RCU ) - error =follow_dotdot_rcu (nd); + parent =follow_dotdot_rcu (nd, &inode, &seq);else - error =follow_dotdot (nd); -if (error) -return error; + parent =follow_dotdot (nd, &inode, &seq); +if (IS_ERR (parent)) +return ERR_CAST (parent); +if (unlikely (!parent)) { + error =step_into (nd,WALK_NOFOLLOW , + nd->path.dentry, nd->inode, nd->seq); + }else { + error =step_into (nd,WALK_NOFOLLOW , + parent, inode, seq); + }if (unlikely (nd->flags &LOOKUP_IS_SCOPED )) {/*
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 50/69 follow_dotdot{,_rcu}(): massage loops
In reply to Al ViroFrom: Al Viro <[email protected]>
The logics in both of them is the same:
while true
if in process' root // uncommon
break
if *not* in mount root // normal case
find the parent
return
if at absolute root // very uncommon
break
move to underlying mountpoint
report that we are in root
Pull the common path out of the loop:
if in process' root // uncommon
goto in_root
if unlikely(in mount root)
while true
if at absolute root
goto in_root
move to underlying mountpoint if in process' root
goto in_root
if in mount root
break;
find the parent // we are not in mount root
returnin_root:
report that we are in root
The reason for that transformation is that we get to keep the common path straight *and* get a separate block for "move through underlying mountpoints", which will allow to sanitize NO_XDEV handling there. What's more, the pared-down loops will be easier to deal with - in particular, non-RCU case has no need to grab mount_lock and rewriting it to the form that wouldn't do that is a non-trivial change. Better do that with less stuff getting in the way...
--- fs/namei.c | 77 ++++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 45 insertions(+), 32 deletions(-)
fs/namei.c +45 -32
@@ -1691,21 +1691,12 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd,struct inode **inodep, unsigned *seqp) { -while (1 ) { -if (path_equal (&nd->path, &nd->root)) -break ; -if (nd->path.dentry != nd->path.mnt->mnt_root) { -struct dentry *old = nd->path.dentry; -struct dentry *parent = old->d_parent; + struct dentry *parent, *old; - *inodep = parent->d_inode; - *seqp =read_seqcount_begin (&parent->d_seq); -if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq))) -return ERR_PTR (-ECHILD ); -if (unlikely (!path_connected (nd->path.mnt, parent))) -return ERR_PTR (-ECHILD ); -return parent; - }else { +if (path_equal (&nd->path, &nd->root)) + goto in_root; +if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { +while (1 ) {struct mount *mnt =real_mount (nd->path.mnt);struct mount *mparent = mnt->mnt_parent;struct dentry *mountpoint = mnt->mnt_mountpoint;
@@ -1714,7 +1705,7 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd,if (unlikely (read_seqretry (&mount_lock, nd->m_seq)))return ERR_PTR (-ECHILD );if (&mparent->mnt == nd->path.mnt) -break ; + goto in_root;if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return ERR_PTR (-ECHILD );/* we know that mountpoint was pinned */
@@ -1722,8 +1713,22 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd, nd->path.mnt = &mparent->mnt; nd->inode = inode; nd->seq = seq; +if (path_equal (&nd->path, &nd->root)) + goto in_root; +if (nd->path.dentry != nd->path.mnt->mnt_root) +break ; } } + old = nd->path.dentry; + parent = old->d_parent; + *inodep = parent->d_inode; + *seqp =read_seqcount_begin (&parent->d_seq); +if (unlikely (read_seqcount_retry (&old->d_seq, nd->seq))) +return ERR_PTR (-ECHILD ); +if (unlikely (!path_connected (nd->path.mnt, parent))) +return ERR_PTR (-ECHILD ); +return parent; +in_root:if (unlikely (nd->flags &LOOKUP_BENEATH ))return ERR_PTR (-ECHILD );return NULL ;
@@ -1733,25 +1738,33 @@ static struct dentry *follow_dotdot(struct nameidata *nd,struct inode **inodep, unsigned *seqp) { -while (1 ) { -if (path_equal (&nd->path, &nd->root)) -break ; -if (nd->path.dentry != nd->path.mnt->mnt_root) { -/* rare case of legitimate dget_parent()... */ -struct dentry *parent =dget_parent (nd->path.dentry); -if (unlikely (!path_connected (nd->path.mnt, parent))) { -dput (parent); -return ERR_PTR (-ENOENT ); - } - *seqp =0 ; - *inodep = parent->d_inode; -return parent; + struct dentry *parent; + +if (path_equal (&nd->path, &nd->root)) + goto in_root; +if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { +while (1 ) { +if (!follow_up (&nd->path)) + goto in_root; +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return ERR_PTR (-EXDEV ); +if (path_equal (&nd->path, &nd->root)) + goto in_root; +if (nd->path.dentry != nd->path.mnt->mnt_root) +break ; } -if (!follow_up (&nd->path)) -break ; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return ERR_PTR (-EXDEV ); } +/* rare case of legitimate dget_parent()... */ + parent =dget_parent (nd->path.dentry); +if (unlikely (!path_connected (nd->path.mnt, parent))) { +dput (parent); +return ERR_PTR (-ENOENT ); + } + *seqp =0 ; + *inodep = parent->d_inode; +return parent; + +in_root:if (unlikely (nd->flags &LOOKUP_BENEATH ))return ERR_PTR (-EXDEV );dget (nd->path.dentry);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 51/69 follow_dotdot_rcu(): be lazy about changing nd->path
In reply to Al ViroFrom: Al Viro <[email protected]>
Change nd->path only after the loop is done and only in case we hadn't ended up finding ourselves in root. Same for NO_XDEV check. Don't recheck mount_lock on each step either.
That separates the "check how far back do we need to go through the mount stack" logics from the rest of .. traversal.
Note that the sequence for d_seq/d_inode here is
* sample mount_lock seqcount
...
* sample d_seq
* fetch d_inode
* verify mount_lock seqcount
The last step makes sure that d_inode value we'd got matches d_seq - it dentry is guaranteed to have been a mountpoint through the entire thing, so its d_inode must have been stable.
--- fs/namei.c | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-)
fs/namei.c +20 -15
@@ -1696,28 +1696,31 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd,if (path_equal (&nd->path, &nd->root)) goto in_root;if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { +struct path path = nd->path; +unsigned seq; +while (1 ) { -struct mount *mnt =real_mount (nd->path.mnt); +struct mount *mnt =real_mount (path.mnt);struct mount *mparent = mnt->mnt_parent;struct dentry *mountpoint = mnt->mnt_mountpoint; -struct inode *inode = mountpoint->d_inode; -unsigned seq =read_seqcount_begin (&mountpoint->d_seq); -if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) -return ERR_PTR (-ECHILD ); -if (&mparent->mnt == nd->path.mnt) + seq =read_seqcount_begin (&mountpoint->d_seq); +if (&mparent->mnt == path.mnt) goto in_root; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return ERR_PTR (-ECHILD ); -/* we know that mountpoint was pinned */ - nd->path.dentry = mountpoint; - nd->path.mnt = &mparent->mnt; - nd->inode = inode; - nd->seq = seq; -if (path_equal (&nd->path, &nd->root)) + path.dentry = mountpoint; + path.mnt = &mparent->mnt; +if (path_equal (&path, &nd->root)) goto in_root; -if (nd->path.dentry != nd->path.mnt->mnt_root) +if (path.dentry != path.mnt->mnt_root)break ; } +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return ERR_PTR (-ECHILD ); + nd->path = path; + nd->inode = path.dentry->d_inode; + nd->seq = seq; +if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) +return ERR_PTR (-ECHILD ); +/* we know that mountpoint was pinned */ } old = nd->path.dentry; parent = old->d_parent;
@@ -1729,6 +1732,8 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd,return ERR_PTR (-ECHILD );return parent; in_root: +if (unlikely (read_seqretry (&mount_lock, nd->m_seq))) +return ERR_PTR (-ECHILD );if (unlikely (nd->flags &LOOKUP_BENEATH ))return ERR_PTR (-ECHILD );return NULL ;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 52/69 follow_dotdot(): be lazy about changing nd->path
In reply to Al ViroFrom: Al Viro <[email protected]>
Change nd->path only after the loop is done and only in case we hadn't ended up finding ourselves in root. Same for NO_XDEV check.
That separates the "check how far back do we need to go through the mount stack" logics from the rest of .. traversal.
NOTE: path_get/path_put introduced here are temporary. They will go away later in the series.
--- fs/namei.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-)
fs/namei.c +13 -5
@@ -1748,16 +1748,24 @@ static struct dentry *follow_dotdot(struct nameidata *nd,if (path_equal (&nd->path, &nd->root)) goto in_root;if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { +struct path path = nd->path; +path_get (&path);while (1 ) { -if (!follow_up (&nd->path)) +if (!follow_up (&path)) { +path_put (&path); goto in_root; -if (unlikely (nd->flags &LOOKUP_NO_XDEV )) -return ERR_PTR (-EXDEV ); -if (path_equal (&nd->path, &nd->root)) + } +if (path_equal (&path, &nd->root)) { +path_put (&path); goto in_root; -if (nd->path.dentry != nd->path.mnt->mnt_root) + } +if (path.dentry != nd->path.mnt->mnt_root)break ; } +path_put (&nd->path); + nd->path = path; +if (unlikely (nd->flags &LOOKUP_NO_XDEV )) +return ERR_PTR (-EXDEV ); }/* rare case of legitimate dget_parent()... */ parent =dget_parent (nd->path.dentry);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 53/69 helper for mount rootwards traversal
In reply to Al ViroFrom: Al Viro <[email protected]>
The loops in follow_dotdot{_rcu()} are doing the same thing:
we have a mount and we want to find out how far up the chain of mounts do we need to go.
We follow the chain of mount until we find one that is not directly overmounting the root of another mount. If such a mount is found, we want the location it's mounted upon. If we run out of chain (i.e. get to a mount that is not mounted on anything else) or run into process' root, we report failure.
On success, we want (in RCU case) d_seq of resulting location sampled or (in non-RCU case) references to that location acquired.
This commit introduces such primitive for RCU case and switches follow_dotdot_rcu() to it; non-RCU case will be go in the next commit.
--- fs/namei.c | 40 ++++++++++++++++++++++++---------------- 1 file changed, 24 insertions(+), 16 deletions(-)
fs/namei.c +24 -16
@@ -1363,6 +1363,26 @@ static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,return ret; } +static bool choose_mountpoint_rcu (struct mount *m,const struct path *root, +struct path *path,unsigned *seqp) +{ +while (mnt_has_parent (m)) { +struct dentry *mountpoint = m->mnt_mountpoint; + + m = m->mnt_parent; +if (unlikely (root->dentry == mountpoint && + root->mnt == &m->mnt)) +break ; +if (mountpoint != m->mnt.mnt_root) { + path->mnt = &m->mnt; + path->dentry = mountpoint; + *seqp =read_seqcount_begin (&mountpoint->d_seq); +return true; + } + } +return false; +} +/* * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() */
@@ -1696,23 +1716,11 @@ static struct dentry *follow_dotdot_rcu(struct nameidata *nd,if (path_equal (&nd->path, &nd->root)) goto in_root;if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { -struct path path = nd->path; +struct path path;unsigned seq; - -while (1 ) { -struct mount *mnt =real_mount (path.mnt); -struct mount *mparent = mnt->mnt_parent; -struct dentry *mountpoint = mnt->mnt_mountpoint; - seq =read_seqcount_begin (&mountpoint->d_seq); -if (&mparent->mnt == path.mnt) - goto in_root; - path.dentry = mountpoint; - path.mnt = &mparent->mnt; -if (path_equal (&path, &nd->root)) - goto in_root; -if (path.dentry != path.mnt->mnt_root) -break ; - } +if (!choose_mountpoint_rcu (real_mount (nd->path.mnt), + &nd->root, &path, &seq)) + goto in_root;if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return ERR_PTR (-ECHILD ); nd->path = path;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 54/69 non-RCU analogue of the previous commit
In reply to Al ViroFrom: Al Viro <[email protected]>
new helper: choose_mountpoint(). Wrapper around choose_mountpoint_rcu(), similar to lookup_mnt() vs. __lookup_mnt(). follow_dotdot() switched to it. Now we don't grab mount_lock exclusive anymore; note that the primitive used non-RCU mount traversals in other direction (lookup_mnt()) doesn't bother with that either - it uses mount_lock seqcount instead.
--- fs/namei.c | 56 +++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 39 insertions(+), 17 deletions(-)
fs/namei.c +39 -17
@@ -605,10 +605,9 @@ static void terminate_walk(struct nameidata *nd) }/* path_put is needed afterwards regardless of success or failure */ -static bool legitimize_path (struct nameidata *nd, -struct path *path,unsigned seq) +static bool __legitimize_path (struct path *path,unsigned seq,unsigned mseq) { -int res =__legitimize_mnt (path->mnt, nd->m_seq); +int res =__legitimize_mnt (path->mnt, mseq);if (unlikely (res)) {if (res >0 ) path->mnt =NULL ;
@@ -622,6 +621,12 @@ static bool legitimize_path(struct nameidata *nd,return !read_seqcount_retry (&path->dentry->d_seq, seq); } +static inline bool legitimize_path (struct nameidata *nd, +struct path *path,unsigned seq) +{ +return __legitimize_path (path, nd->m_seq, seq); +} +static bool legitimize_links (struct nameidata *nd) {int i;
@@ -1383,6 +1388,31 @@ static bool choose_mountpoint_rcu(struct mount *m, const struct path *root,return false; } +static bool choose_mountpoint (struct mount *m,const struct path *root, +struct path *path) +{ +bool found; + +rcu_read_lock (); +while (1 ) { +unsigned seq, mseq =read_seqbegin (&mount_lock); + + found =choose_mountpoint_rcu (m, root, path, &seq); +if (unlikely (!found)) { +if (!read_seqretry (&mount_lock, mseq)) +break ; + }else { +if (likely (__legitimize_path (path, seq, mseq))) +break ; +rcu_read_unlock (); +path_put (path); +rcu_read_lock (); + } + } +rcu_read_unlock (); +return found; +} +/* * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() */
@@ -1756,22 +1786,14 @@ static struct dentry *follow_dotdot(struct nameidata *nd,if (path_equal (&nd->path, &nd->root)) goto in_root;if (unlikely (nd->path.dentry == nd->path.mnt->mnt_root)) { -struct path path = nd->path; -path_get (&path); -while (1 ) { -if (!follow_up (&path)) { -path_put (&path); - goto in_root; - } -if (path_equal (&path, &nd->root)) { -path_put (&path); - goto in_root; - } -if (path.dentry != nd->path.mnt->mnt_root) -break ; - } +struct path path; + +if (!choose_mountpoint (real_mount (nd->path.mnt), + &nd->root, &path)) + goto in_root;path_put (&nd->path); nd->path = path; + nd->inode = path.dentry->d_inode;if (unlikely (nd->flags &LOOKUP_NO_XDEV ))return ERR_PTR (-EXDEV ); }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 55/69 fs/namei.c: kill follow_mount()
In reply to Al ViroFrom: Al Viro <[email protected]>
The only remaining caller (path_pts()) should be using follow_down() anyway. And clean path_pts() a bit.
--- fs/namei.c | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-)
fs/namei.c +2 -20
@@ -1414,22 +1414,6 @@ static bool choose_mountpoint(struct mount *m, const struct path *root, }/* -* Skip to top of mountpoint pile in refwalk mode for follow_dotdot() -*/ -static void follow_mount (struct path *path) -{ -while (d_mountpoint (path->dentry)) { -struct vfsmount *mounted =lookup_mnt (path); -if (!mounted) -break ; -dput (path->dentry); -mntput (path->mnt); - path->mnt = mounted; - path->dentry =dget (mounted->mnt_root); - } -} - -/* * This looks up the name in dcache and possibly revalidates the found dentry. * NULL is returned if the dentry does not exist in the cache. */
@@ -2639,7 +2623,7 @@ int path_pts(struct path *path)*/ struct dentry *parent =dget_parent (path->dentry);struct dentry *child; -struct qstr this; +struct qstr this =QSTR_INIT ("pts" ,3 );if (unlikely (!path_connected (path->mnt, parent))) {dput (parent);
@@ -2647,15 +2631,13 @@ int path_pts(struct path *path) }dput (path->dentry); path->dentry = parent; - this.name ="pts" ; - this.len =3 ; child =d_hash_and_lookup (parent, &this);if (!child)return -ENOENT ; path->dentry = child;dput (parent); -follow_mount (path); +follow_down (path);return 0 ; }#endif
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 56/69 pick_link(): more straightforward handling of allocation failures
In reply to Al ViroFrom: Al Viro <[email protected]>
pick_link() needs to push onto stack; we start with using two-element array embedded into struct nameidata and the first time we need more than that we switch to separately allocated array.
Allocation can fail, of course, and handling of that would be simple enough - we need to drop 'link' and bugger off. However, the things get more complicated in RCU mode. There we must do GFP_ATOMIC allocation. If that fails, we try to switch to non-RCU mode and repeat the allocation.
To switch to non-RCU mode we need to grab references to 'link' and to everything in nameidata. The latter done by unlazy_walk(); the former - legitimize_path(). 'link' must go first - after unlazy_walk() we are out of RCU-critical period and it's too late to call legitimize_path() since the references in link->mnt and link->dentry might be pointing to freed and reused memory.
So we do legitimize_path(), then unlazy_walk(). And that's where it gets too subtle: what to do if the former fails? We MUST do path_put(link) to avoid leaks. And we can't do that under rcu_read_lock(). Solution in mainline was to empty then nameidata manually, drop out of RCU mode and then do put_path().
In effect, we open-code the things eventual terminate_walk() would've done on error in RCU mode. That looks badly out of place and confusing. We could add a comment along the lines of the explanation above, but... there's a simpler solution. Call unlazy_walk() even if legitimaze_path() fails. It will take us out of RCU mode, so we'll be able to do path_put(link).
Yes, it will do unnecessary work - attempt to grab references on the stuff in nameidata, only to have them dropped as soon as we return the error to upper layer and get terminate_walk() called there. So what? We are thoroughly off the fast path by that point - we had GFP_ATOMIC allocation fail, we had ->d_seq or mount_lock mismatch and we are about to try walking the same path from scratch in non-RCU mode. Which will need to do the same allocation, this time with GFP_KERNEL, so it will be able to apply memory pressure for blocking stuff.
Compared to that the cost of several lockref_get_not_dead() is noise. And the logics become much easier to understand that way.
--- fs/namei.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
fs/namei.c +7 -8
@@ -1612,14 +1612,13 @@ static const char *pick_link(struct nameidata *nd, struct path *link, error =nd_alloc_stack (nd);if (unlikely (error)) {if (error == -ECHILD ) { -if (unlikely (!legitimize_path (nd, link, seq))) { -drop_links (nd); - nd->depth =0 ; - nd->flags &= ~LOOKUP_RCU ; - nd->path.mnt =NULL ; - nd->path.dentry =NULL ; -rcu_read_unlock (); - }else if (likely (unlazy_walk (nd)) ==0 ) +// we must grab link first +bool grabbed_link =legitimize_path (nd, link, seq); +// ... and we must unlazy to be able to clean up + error =unlazy_walk (nd); +if (unlikely (!grabbed_link)) + error = -ECHILD ; +if (!error) error =nd_alloc_stack (nd); }if (error) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 57/69 pick_link(): pass it struct path already with normal refcounting rules
In reply to Al ViroFrom: Al Viro <[email protected]>
step_into() tries to avoid grabbing and dropping mount references on the steps that do not involve crossing mountpoints (which is obviously the majority of cases). So it uses a local struct path with unusual refcounting rules - path.mnt is pinned if and only if it's not equal to nd->path.mnt.
We used to have similar beasts all over the place and we had quite a few bugs crop up in their handling - it's easy to get confused when changing e.g. cleanup on failure exits (or adding a new check, etc.)
Now that's mostly gone - the step_into() instance (which is what we need them for) is the only one left. It is exposed to mount traversal and it's (shortly) seen by pick_link(). Since pick_link() needs to store it in link stack, where the normal rules apply, it has to make sure that mount is pinned regardless of nd->path.mnt value. That's done on all calls of pick_link() and very early in those. Let's do that in the caller (step_into()) instead - that way the fewer places need to be aware of such struct path instances.
--- fs/namei.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
fs/namei.c +6 -6
@@ -1602,13 +1602,10 @@ static const char *pick_link(struct nameidata *nd, struct path *link,int error;if (unlikely (nd->total_link_count++ >=MAXSYMLINKS )) { -path_to_nameidata (link, nd); +if (!(nd->flags &LOOKUP_RCU )) +path_put (link);return ERR_PTR (-ELOOP ); } -if (!(nd->flags &LOOKUP_RCU )) { -if (link->mnt == nd->path.mnt) -mntget (link->mnt); - } error =nd_alloc_stack (nd);if (unlikely (error)) {if (error == -ECHILD ) {
@@ -1712,10 +1709,13 @@ static const char *step_into(struct nameidata *nd, int flags, nd->seq = seq;return NULL ; } -/* make sure that d_is_symlink above matches inode */ if (nd->flags &LOOKUP_RCU ) { +/* make sure that d_is_symlink above matches inode */ if (read_seqcount_retry (&path.dentry->d_seq, seq))return ERR_PTR (-ECHILD ); + }else { +if (path.mnt == nd->path.mnt) +mntget (path.mnt); }return pick_link (nd, &path, inode, seq, flags); }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 58/69 fold path_to_nameidata() into its only remaining caller
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-)
fs/namei.c +6 -13
@@ -860,18 +860,6 @@ static int set_root(struct nameidata *nd)return 0 ; } -static inline void path_to_nameidata (const struct path *path, -struct nameidata *nd) -{ -if (!(nd->flags &LOOKUP_RCU )) { -dput (nd->path.dentry); -if (nd->path.mnt != path->mnt) -mntput (nd->path.mnt); - } - nd->path.mnt = path->mnt; - nd->path.dentry = path->dentry; -} -static int nd_jump_root (struct nameidata *nd) {if (unlikely (nd->flags &LOOKUP_BENEATH ))
@@ -1704,7 +1692,12 @@ static const char *step_into(struct nameidata *nd, int flags, ((flags & WALK_TRAILING) && !(nd->flags & LOOKUP_FOLLOW)) || (flags & WALK_NOFOLLOW)) {/* not a symlink or should not follow */ -path_to_nameidata (&path, nd); +if (!(nd->flags &LOOKUP_RCU )) { +dput (nd->path.dentry); +if (nd->path.mnt != path.mnt) +mntput (nd->path.mnt); + } + nd->path = path; nd->inode = inode; nd->seq = seq;return NULL ;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 59/69 pick_link(): take reserving space on stack into a new helper
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 46 +++++++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 21 deletions(-)
fs/namei.c +25 -21
@@ -1580,6 +1580,28 @@ static inline int may_lookup(struct nameidata *nd)return inode_permission (nd->inode,MAY_EXEC ); } +static int reserve_stack (struct nameidata *nd,struct path *link,unsigned seq) +{ +int error; + +if (unlikely (nd->total_link_count++ >=MAXSYMLINKS )) +return -ELOOP ; + error =nd_alloc_stack (nd); +if (likely (!error)) +return 0 ; +if (error == -ECHILD ) { +// we must grab link first +bool grabbed_link =legitimize_path (nd, link, seq); +// ... and we must unlazy to be able to clean up + error =unlazy_walk (nd); +if (unlikely (!grabbed_link)) + error = -ECHILD ; +if (!error) + error =nd_alloc_stack (nd); + } +return error; +} +enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 }; static const char *pick_link(struct nameidata *nd, struct path *link,
@@ -1587,31 +1609,13 @@ static const char *pick_link(struct nameidata *nd, struct path *link, {struct saved *last;const char *res; -int error; +int error =reserve_stack (nd, link, seq); -if (unlikely (nd->total_link_count++ >=MAXSYMLINKS )) { -if (!(nd->flags &LOOKUP_RCU )) -path_put (link); -return ERR_PTR (-ELOOP ); - } - error =nd_alloc_stack (nd);if (unlikely (error)) { -if (error == -ECHILD ) { -// we must grab link first -bool grabbed_link =legitimize_path (nd, link, seq); -// ... and we must unlazy to be able to clean up - error =unlazy_walk (nd); -if (unlikely (!grabbed_link)) - error = -ECHILD ; -if (!error) - error =nd_alloc_stack (nd); - } -if (error) { +if (!(nd->flags &LOOKUP_RCU ))path_put (link); -return ERR_PTR (error); - } +return ERR_PTR (error); } - last = nd->stack + nd->depth++; last->link = *link;clear_delayed_call (&last->done);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 60/69 reserve_stack(): switch to __nd_alloc_stack()
In reply to Al ViroFrom: Al Viro <[email protected]>
expand the call of nd_alloc_stack() into it (and don't recheck the depth on the second call)
--- fs/namei.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-)
fs/namei.c +8 -11
@@ -566,15 +566,6 @@ static bool path_connected(struct vfsmount *mnt, struct dentry *dentry)return is_subdir (dentry, mnt->mnt_root); } -static inline int nd_alloc_stack (struct nameidata *nd) -{ -if (likely (nd->depth !=EMBEDDED_LEVELS )) -return 0 ; -if (likely (nd->stack != nd->internal)) -return 0 ; -return __nd_alloc_stack (nd); -} -static void drop_links (struct nameidata *nd) {int i = nd->depth;
@@ -1586,7 +1577,13 @@ static int reserve_stack(struct nameidata *nd, struct path *link, unsigned seq)if (unlikely (nd->total_link_count++ >=MAXSYMLINKS ))return -ELOOP ; - error =nd_alloc_stack (nd); + +if (likely (nd->depth !=EMBEDDED_LEVELS )) +return 0 ; +if (likely (nd->stack != nd->internal)) +return 0 ; + + error =__nd_alloc_stack (nd);if (likely (!error))return 0 ;if (error == -ECHILD ) {
@@ -1597,7 +1594,7 @@ static int reserve_stack(struct nameidata *nd, struct path *link, unsigned seq)if (unlikely (!grabbed_link)) error = -ECHILD ;if (!error) - error =nd_alloc_stack (nd); + error =__nd_alloc_stack (nd); }return error; }
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 61/69 __nd_alloc_stack(): make it return bool
In reply to Al ViroFrom: Al Viro <[email protected]>
... and adjust the caller (reserve_stack()). Rename to nd_alloc_stack(), while we are at it.
--- fs/namei.c | 45 ++++++++++++++++++--------------------------- 1 file changed, 18 insertions(+), 27 deletions(-)
fs/namei.c +18 -27
@@ -529,24 +529,17 @@ static void restore_nameidata(void)kfree (now->stack); } -static int __nd_alloc_stack (struct nameidata *nd) +static bool nd_alloc_stack (struct nameidata *nd) {struct saved *p; -if (nd->flags &LOOKUP_RCU ) { - p=kmalloc_array (MAXSYMLINKS ,sizeof (struct saved ), -GFP_ATOMIC ); -if (unlikely (!p)) -return -ECHILD ; - }else { - p=kmalloc_array (MAXSYMLINKS ,sizeof (struct saved ), -GFP_KERNEL ); -if (unlikely (!p)) -return -ENOMEM ; - } + p=kmalloc_array (MAXSYMLINKS ,sizeof (struct saved ), + nd->flags &LOOKUP_RCU ?GFP_ATOMIC :GFP_KERNEL ); +if (unlikely (!p)) +return false;memcpy (p, nd->internal,sizeof (nd->internal)); nd->stack = p; -return 0 ; +return true; }/**
@@ -1573,8 +1566,6 @@ static inline int may_lookup(struct nameidata *nd)static int reserve_stack (struct nameidata *nd,struct path *link,unsigned seq) { -int error; -if (unlikely (nd->total_link_count++ >=MAXSYMLINKS ))return -ELOOP ;
@@ -1582,21 +1573,21 @@ static int reserve_stack(struct nameidata *nd, struct path *link, unsigned seq)return 0 ;if (likely (nd->stack != nd->internal))return 0 ; - - error =__nd_alloc_stack (nd); -if (likely (!error)) +if (likely (nd_alloc_stack (nd)))return 0 ; -if (error == -ECHILD ) { -// we must grab link first + +if (nd->flags &LOOKUP_RCU ) { +// we need to grab link before we do unlazy. And we can't skip +// unlazy even if we fail to grab the link - cleanup needs it bool grabbed_link =legitimize_path (nd, link, seq); -// ... and we must unlazy to be able to clean up - error =unlazy_walk (nd); -if (unlikely (!grabbed_link)) - error = -ECHILD ; -if (!error) - error =__nd_alloc_stack (nd); + +if (unlazy_walk (nd) !=0 || !grabbed_link) +return -ECHILD ; + +if (nd_alloc_stack (nd)) +return 0 ; } -return error; +return -ENOMEM ; }enum {WALK_TRAILING =1 ,WALK_MORE =2 ,WALK_NOFOLLOW =4 };
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 62/69 link_path_walk(): sample parent's i_uid and i_mode for the last component
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-)
fs/namei.c +7 -10
@@ -505,6 +505,8 @@ struct nameidata {struct nameidata *saved;unsigned root_seq;int dfd; +kuid_t dir_uid; +umode_t dir_mode; } __randomize_layout;static void set_nameidata (struct nameidata *p,int dfd,struct filename *name)
@@ -938,9 +940,6 @@ int sysctl_protected_regular __read_mostly;*/ static inline int may_follow_link (struct nameidata *nd,const struct inode *inode) { -const struct inode *parent; -kuid_t puid; -if (!sysctl_protected_symlinks)return 0 ;
@@ -949,13 +948,11 @@ static inline int may_follow_link(struct nameidata *nd, const struct inode *inodreturn 0 ;/* Allowed if parent directory not sticky and world-writable. */ - parent = nd->inode; -if ((parent->i_mode & (S_ISVTX |S_IWOTH )) != (S_ISVTX |S_IWOTH )) +if ((nd->dir_mode & (S_ISVTX |S_IWOTH )) != (S_ISVTX |S_IWOTH ))return 0 ;/* Allowed if parent directory and link owner match. */ - puid = parent->i_uid; -if (uid_valid (puid) &&uid_eq (puid, inode->i_uid)) +if (uid_valid (nd->dir_uid) &&uid_eq (nd->dir_uid, inode->i_uid))return 0 ;if (nd->flags &LOOKUP_RCU )
@@ -2158,6 +2155,8 @@ static int link_path_walk(const char *name, struct nameidata *nd) OK:/* pathname or trailing symlink, done */ if (!depth) { + nd->dir_uid = nd->inode->i_uid; + nd->dir_mode = nd->inode->i_mode; nd->flags &= ~LOOKUP_PARENT ;return 0 ; }
@@ -3223,8 +3222,6 @@ static const char *open_last_lookups(struct nameidata *nd,static const char *do_last (struct nameidata *nd,struct file *file,const struct open_flags *op) { -kuid_t dir_uid = nd->inode->i_uid; -umode_t dir_mode = nd->inode->i_mode;int open_flag = op->open_flag;bool do_truncate;int acc_mode;
@@ -3240,7 +3237,7 @@ static const char *do_last(struct nameidata *nd,if (open_flag &O_CREAT ) {if (d_is_dir (nd->path.dentry))return ERR_PTR (-EISDIR ); - error =may_create_in_sticky (dir_mode, dir_uid, + error =may_create_in_sticky (nd->dir_mode, nd->dir_uid,d_backing_inode (nd->path.dentry));if (unlikely (error))return ERR_PTR (error);
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 63/69 take post-lookup part of do_last() out of loop
In reply to Al ViroFrom: Al Viro <[email protected]>
now we can have open_last_lookups() directly from the loop in path_openat() - the rest of do_last() never returns a symlink to follow, so we can bloody well leave the loop first.
Rename the rest of that thing from do_last() to do_open() and make it return an int.
--- fs/namei.c | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-)
fs/namei.c +9 -12
@@ -3219,31 +3219,26 @@ static const char *open_last_lookups(struct nameidata *nd,/* * Handle the last step of open() */ -static const char *do_last (struct nameidata *nd, +static int do_open (struct nameidata *nd,struct file *file,const struct open_flags *op) {int open_flag = op->open_flag;bool do_truncate;int acc_mode; -const char *link;int error; - link =open_last_lookups (nd, file, op); -if (unlikely (link)) -return link; -if (!(file->f_mode &FMODE_CREATED ))audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) {if (d_is_dir (nd->path.dentry)) -return ERR_PTR (-EISDIR ); +return -EISDIR ; error =may_create_in_sticky (nd->dir_mode, nd->dir_uid,d_backing_inode (nd->path.dentry));if (unlikely (error)) -return ERR_PTR (error); +return error; }if ((nd->flags &LOOKUP_DIRECTORY ) && !d_can_lookup (nd->path.dentry)) -return ERR_PTR (-ENOTDIR ); +return -ENOTDIR ; do_truncate = false; acc_mode = op->acc_mode;
@@ -3254,7 +3249,7 @@ static const char *do_last(struct nameidata *nd, }else if (d_is_reg (nd->path.dentry) && open_flag &O_TRUNC ) { error =mnt_want_write (nd->path.mnt);if (error) -return ERR_PTR (error); +return error; do_truncate = true; } error =may_open (&nd->path, acc_mode, open_flag);
@@ -3270,7 +3265,7 @@ static const char *do_last(struct nameidata *nd, }if (do_truncate)mnt_drop_write (nd->path.mnt); -return ERR_PTR (error); +return error; }struct dentry *vfs_tmpfile (struct dentry *dentry,umode_t mode,int open_flag)
@@ -3373,8 +3368,10 @@ static struct file *path_openat(struct nameidata *nd, }else {const char *s =path_init (nd, flags);while (!(error =link_path_walk (s, nd)) && - (s =do_last (nd, file, op)) !=NULL ) + (s =open_last_lookups (nd, file, op)) !=NULL ) ; +if (!error) + error =do_open (nd, file, op);terminate_walk (nd); }if (likely (!error)) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 64/69 open_last_lookups(): consolidate fsnotify_create() calls
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
fs/namei.c +2 -5
@@ -2956,8 +2956,6 @@ static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,dput (dentry); dentry =dget (file->f_path.dentry); } -if (file->f_mode &FMODE_CREATED ) -fsnotify_create (dir, dentry); }else if (WARN_ON (file->f_path.dentry ==DENTRY_NOT_SET )) { error = -EIO ; }else {
@@ -2965,8 +2963,6 @@ static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,dput (dentry); dentry = file->f_path.dentry; } -if (file->f_mode &FMODE_CREATED ) -fsnotify_create (dir, dentry);if (unlikely (d_is_negative (dentry))) error = -ENOENT ; }
@@ -3102,7 +3098,6 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file, open_flag & O_EXCL);if (error) goto out_dput; -fsnotify_create (dir_inode, dentry); }if (unlikely (create_error) && !dentry->d_inode) { error = create_error;
@@ -3181,6 +3176,8 @@ static const char *open_last_lookups(struct nameidata *nd,else inode_lock_shared (dir->d_inode); dentry =lookup_open (nd, file, op, got_write); +if (!IS_ERR (dentry) && (file->f_mode &FMODE_CREATED )) +fsnotify_create (dir->d_inode, dentry);if (open_flag &O_CREAT )inode_unlock (dir->d_inode);else
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 65/69 open_last_lookups(): don't abuse complete_walk() when all we want is unlazy
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-)
fs/namei.c +5 -9
@@ -3146,15 +3146,11 @@ static const char *open_last_lookups(struct nameidata *nd,BUG_ON (nd->flags &LOOKUP_RCU ); }else {/* create side of things */ -/* -* This will *only* deal with leaving RCU mode - LOOKUP_JUMPED -* has been cleared when we got to the last component we are -* about to look up -*/ - error =complete_walk (nd); -if (unlikely (error)) -return ERR_PTR (error); - +if (nd->flags &LOOKUP_RCU ) { + error =unlazy_walk (nd); +if (unlikely (error)) +return ERR_PTR (error); + }audit_inode (nd->name, dir,AUDIT_INODE_PARENT );/* trailing slashes? */ if (unlikely (nd->last.name[nd->last.len]))
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 66/69 open_last_lookups(): lift O_EXCL|O_CREAT handling into do_open()
In reply to Al ViroFrom: Al Viro <[email protected]>
Currently path_openat() has "EEXIST on O_EXCL|O_CREAT" checks done on one of the ways out of open_last_lookups(). There are 4 cases:
1) the last component is . or ..; check is not done.
2) we had FMODE_OPENED or FMODE_CREATED set while in lookup_open();
check is not done.
3) symlink to be traversed is found; check is not done (nor
should it be)
4) everything else: check done (before complete_walk(), even).
In case (1) O_EXCL|O_CREAT ends up failing with -EISDIR - that's
open("/tmp/.", O_CREAT|O_EXCL, 0600)
Note that in the same conditions
open("/tmp", O_CREAT|O_EXCL, 0600)would have yielded EEXIST. Either error is allowed, switching to -EEXIST in these cases would've been more consistent.
Case (2) is more subtle; first of all, if we have FMODE_CREATED set, the object hadn't existed prior to the call. The check should not be done in such a case. The rest is problematic, though - we have
FMODE_OPENED set (i.e. it went through ->atomic_open() and got
successfully opened there)
FMODE_CREATED is *NOT* set
O_CREAT and O_EXCL are both set.
Any such case is a bug - either we failed to set FMODE_CREATED when we had, in fact, created an object (no such instances in the tree) or we have opened a pre-existing file despite having had both O_CREAT and O_EXCL passed. One of those was, in fact caught (and fixed) while sorting out this mess (gfs2 on cold dcache). And in such situations we should fail with EEXIST.
Note that for (1) and (4) FMODE_CREATED is not set - for (1) there's nothing in handle_dots() to set it, for (4) we'd explicitly checked that.
And (1), (2) and (4) are exactly the cases when we leave the loop in the caller, with do_open() called immediately after that loop. IOW, we can move the check over there, and make it
If we have O_CREAT|O_EXCL and after successful pathname resolutionFMODE_CREATED is *not* set, we must have run into a preexisting file and should fail with EEXIST.
--- fs/namei.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
fs/namei.c +2 -5
@@ -3200,11 +3200,6 @@ static const char *open_last_lookups(struct nameidata *nd,return res; } -if (unlikely ((open_flag & (O_EXCL |O_CREAT )) == (O_EXCL |O_CREAT ))) { -audit_inode (nd->name, nd->path.dentry,0 ); -return ERR_PTR (-EEXIST ); - } -/* Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... */ return ERR_PTR (complete_walk (nd)); }
@@ -3223,6 +3218,8 @@ static int do_open(struct nameidata *nd,if (!(file->f_mode &FMODE_CREATED ))audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) { +if ((open_flag &O_EXCL ) && !(file->f_mode &FMODE_CREATED )) +return -EEXIST ;if (d_is_dir (nd->path.dentry))return -EISDIR ; error = may_create_in_sticky(nd->dir_mode, nd->dir_uid,
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 67/69 open_last_lookups(): move complete_walk() into do_open()
In reply to Al ViroFrom: Al Viro <[email protected]>
--- fs/namei.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
fs/namei.c +8 -10
@@ -3127,10 +3127,7 @@ static const char *open_last_lookups(struct nameidata *nd,if (nd->last_type !=LAST_NORM ) {if (nd->depth)put_link (nd); - res =handle_dots (nd, nd->last_type); -if (likely (!res)) - res =ERR_PTR (complete_walk (nd)); -return res; +return handle_dots (nd, nd->last_type); }if (!(open_flag &O_CREAT )) {
@@ -3195,13 +3192,9 @@ static const char *open_last_lookups(struct nameidata *nd,if (nd->depth)put_link (nd); res =step_into (nd,WALK_TRAILING , dentry, inode, seq); -if (unlikely (res)) { +if (unlikely (res)) nd->flags &= ~(LOOKUP_OPEN |LOOKUP_CREATE |LOOKUP_EXCL ); -return res; - } - -/* Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... */ -return ERR_PTR (complete_walk (nd)); +return res; }/*
@@ -3215,6 +3208,11 @@ static int do_open(struct nameidata *nd,int acc_mode;int error; +if (!(file->f_mode & (FMODE_OPENED |FMODE_CREATED ))) { + error =complete_walk (nd); +if (error) +return error; + }if (!(file->f_mode &FMODE_CREATED ))audit_inode (nd->name, nd->path.dentry,0 );if (open_flag &O_CREAT ) {
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 68/69 atomic_open(): no need to pass struct open_flags anymore
In reply to Al ViroFrom: Al Viro <[email protected]>
argument had been unused since 1643b43fbd052 (lookup_open(): lift the "fallback to !O_CREAT" logics from atomic_open()) back in 2016
--- fs/namei.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/namei.c +1 -2
@@ -2932,7 +2932,6 @@ static int may_o_create(const struct path *dir, struct dentry *dentry, umode_t m*/ static struct dentry *atomic_open (struct nameidata *nd,struct dentry *dentry,struct file *file, -const struct open_flags *op,int open_flag,umode_t mode) {struct dentry *const DENTRY_NOT_SET = (void *)-1UL ;
@@ -3065,7 +3064,7 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file, }if (dir_inode->i_op->atomic_open) { - dentry =atomic_open (nd, dentry, file, op, open_flag, mode); + dentry =atomic_open (nd, dentry, file, open_flag, mode);if (unlikely (create_error) && dentry ==ERR_PTR (-ENOENT )) dentry =ERR_PTR (create_error);return dentry;
Signature · 1 line
2.11.0
Al Viro
maintainerRFC PATCH v4 69/69 lookup_open(): don't bother with fallbacks to lookup+create
In reply to Al ViroFrom: Al Viro <[email protected]>
We fall back to lookup+create (instead of atomic_open) in several cases:
1) we don't have write access to filesystem and O_TRUNC is
present in the flags. It's not something we want ->atomic_open() to see - it just might go ahead and truncate the file. However, we can pass it the flags sans O_TRUNC - eventually do_open() will call handle_truncate() anyway.
2) we have O_CREAT | O_EXCL and we can't write to parent.
That's going to be an error, of course, but we want to know _which_ error should that be - might be EEXIST (if file exists), might be EACCES or EROFS. Simply stripping O_CREAT (and checking if we see ENOENT) would suffice, if not for O_EXCL. However, we used to have ->atomic_open() fully responsible for rejecting O_CREAT | O_EXCL on existing file and just stripping O_CREAT would've disarmed those checks. With nothing downstream to catch the problem - FMODE_OPENED used to be "don't bother with EEXIST checks, ->atomic_open() has done those". Now EEXIST checks downstream are skipped only if FMODE_CREATED is set - FMODE_OPENED alone is not enough. That has eliminated the need to fall back onto lookup+create path in this case.
3) O_WRONLY or O_RDWR when we have no write access to
filesystem, with nothing else objectionable. Fallback is (and had always been) pointless.
IOW, we don't really need that fallback; all we need in such cases is to trim O_TRUNC and O_CREAT properly.
--- fs/namei.c | 34 +++++++++------------------------- 1 file changed, 9 insertions(+), 25 deletions(-)
fs/namei.c +9 -25
@@ -2938,9 +2938,6 @@ static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,struct inode *dir = nd->path.dentry->d_inode;int error; -if (!(~open_flag & (O_EXCL |O_CREAT )))/* both O_EXCL and O_CREAT */ - open_flag &= ~O_TRUNC ; -if (nd->flags &LOOKUP_DIRECTORY ) open_flag |=O_DIRECTORY ;
@@ -3037,32 +3034,20 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file,* Another problem is returing the "right" error value (e.g. for an * O_EXCL open we want to return EEXIST not EROFS). */ +if (unlikely (!got_write)) + open_flag &= ~O_TRUNC ;if (open_flag &O_CREAT ) { +if (open_flag &O_EXCL ) + open_flag &= ~O_TRUNC ;if (!IS_POSIXACL (dir->d_inode)) mode &= ~current_umask (); -if (unlikely (!got_write)) { - create_error = -EROFS ; - open_flag &= ~O_CREAT ; -if (open_flag & (O_EXCL |O_TRUNC )) - goto no_open; -/* No side effects, safe to clear O_CREAT */ - }else { +if (likely (got_write)) create_error =may_o_create (&nd->path, dentry, mode); -if (create_error) { - open_flag &= ~O_CREAT ; -if (open_flag &O_EXCL ) - goto no_open; - } - } - }else if ((open_flag & (O_TRUNC |O_WRONLY |O_RDWR )) && -unlikely (!got_write)) { -/* -* No O_CREATE -> atomicity not a requirement -> fall -* back to lookup + open -*/ - goto no_open; +else + create_error = -EROFS ; } - +if (create_error) + open_flag &= ~O_CREAT ;if (dir_inode->i_op->atomic_open) { dentry =atomic_open (nd, dentry, file, open_flag, mode);if (unlikely (create_error) && dentry ==ERR_PTR (-ENOENT ))
@@ -3070,7 +3055,6 @@ static struct dentry *lookup_open(struct nameidata *nd, struct file *file,return dentry; } -no_open:if (d_in_lookup (dentry)) {struct dentry *res = dir_inode->i_op->lookup (dir_inode, dentry, nd->flags);
Signature · 1 line
2.11.0
A message that is not in the archive (sent off-list or not yet received): [email protected]
Al Viro
maintainerRe: [RFC][PATCH v4 22/69] merging pick_link() with get_link(), part 4
Quoted 4 lines · Hillf Danton
Review
Quoted 2 lines
(quoted diff) +2
-0+ link = walk_component(nd, 0); + if (link) {Need to check that link is not err.
What for? It will do the right thing anyway.
A message that is not in the archive (sent off-list or not yet received): [email protected]
Al Viro
maintainerRe: [RFC][PATCH v4 23/69] merging pick_link() with get_link(), part 5
Quoted 10 lines · Hillf Danton
Review
Quoted 2 lines
(quoted diff) +2
-0+ res = step_into(nd, 0, dentry, inode, seq); + if (unlikely(res)) {Need to check that res is not err.
Review
Quoted 5 lines
(quoted diff) +4
-0+ nd->flags |= LOOKUP_PARENT; + nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL); + nd->stack[0].name = NULL; + return res; }
Not really...
A message that is not in the archive (sent off-list or not yet received): [email protected]
Al Viro
maintainerRe: [RFC][PATCH v4 38/69] do_last(): simplify the liveness analysis past finish_open_created
Quoted 62 lines · Hillf Danton
On Fri, 13 Mar 2020 23:53:26 +0000
Quoted 20 lines
From: Al Viro <[email protected]>
Don't mess with
got_writethere - it is guaranteed to be false on entry and it will be set true if and only if we decide to go for truncation and manage to get write access for that.Don't carry
acc_modethrough the entire thing - it's only used in that part. And don't bother with gotos in there - compiler is quite capable of optimizing that.Signed-off-by Al Viro <[email protected]>--- fs/namei.c | 28 +++++++++++----------------- 1 file changed, 11 insertions(+), 17 deletions(-)fs/namei.c +0
-0fs/namei.c static const char *do_last(struct nameidata *nd, · line 3126
Quoted 6 lines
fs/namei.c +1
-1@@ -3122,9 +3122,9 @@ static const char *do_last(struct nameidata *nd,kuid_t dir_uid = nd->inode->i_uid;umode_t dir_mode = nd->inode->i_mode;int open_flag = op->open_flag; -bool will_truncate = (open_flag &O_TRUNC ) !=0 ; +bool do_truncate;bool got_write = false;Without
got_writecut,Quoted 16 lines
fs/namei.c +3
-2-int acc_mode = op->acc_mode; +int acc_mode;unsigned seq;struct inode *inode;struct dentry *dentry;@@ -3243,36 +3243,30 @@ static const char *do_last(struct nameidata *nd,return ERR_PTR (-ENOTDIR ); finish_open_created: + do_truncate = false; + acc_mode = op->acc_mode;if (file->f_mode &FMODE_CREATED ) {/* Don't check for write permission, don't truncate */ open_flag &= ~O_TRUNC ; - will_truncate = false; acc_mode =0 ;fs/namei.c static const char *do_last(struct nameidata *nd, · line 3256
Quoted 10 lines
fs/namei.c +2
-5- }else if (!d_is_reg (nd->path.dentry)) { - will_truncate = false; - } -if (will_truncate) { + }else if (d_is_reg (nd->path.dentry) && open_flag &O_TRUNC ) { error =mnt_want_write (nd->path.mnt);if (error)return ERR_PTR (error); - got_write = true; + do_truncate = true;replacing its role with
do_truncateprobably makes it easier to maintaindo_last()leaving readers baffling and digging in logs after going up and down the code but failing to grip what is inteded in this patch.
Quoted 1 line
And that kink can be fixed perhaps simply by not axing this
got_write.
I'm sorry, I'd been unable to parse that ;-/ What do you mean?
A message that is not in the archive (sent off-list or not yet received): [email protected]
Al Viro
maintainerRe: [RFC][PATCH v4 26/69] sanitize handling of nd->last_type, kill LAST_BIND
Quoted 8 lines · Hillf Danton
Quoted 6 lines
And make
link_path_walk()_always_ assign ->last_type - in the only case when the value at the entry might survive to the return that value is alwaysLAST_ROOT, inherited frompath_init(). Move that assignment frompath_init()into the beginning oflink_path_walk(), to consolidate the things.If you agree that the move is not a huge change, drop it for the sake of init in order to close the time window of a random
last_type.
What time window of a random last_type and what does "drop for the sake of init" mean? Confused...
Re: [RFC][PATCHSET] sanitized pathwalk machinery (v4)
In reply to Al ViroQuoted 2 lines · Al Viro
Review and testing would be _very_ welcome;I didn't notice anythign else than the few things I sent out to individual patches.
But I have to say, 69 patches is too long of a series to review. I think you could send them out as multiple series (you describe them that way anyway - parts 1-7) with a day in between.
Because my eyes were starting to glaze over about halfway in the series.
But don't do it for this version. If you do a #5. But it would be good to be in -next regardless of whether you do a #5 or not.
Linus
Al Viro
maintainerRe: [RFC][PATCHSET] sanitized pathwalk machinery (v4)
Quoted 10 lines · Linus Torvalds
Quoted 2 lines · Al Viro
Review and testing would be _very_ welcome;I didn't notice anythign else than the few things I sent out to individual patches.
But I have to say, 69 patches is too long of a series to review. I think you could send them out as multiple series (you describe them that way anyway - parts 1-7) with a day in between.
A week of fun? OK...
Quoted 4 lines
Because my eyes were starting to glaze over about halfway in the series.
But don't do it for this version. If you do a #5. But it would be good to be in -next regardless of whether you do a #5 or not.
FWIW, I've dealt with bisect hazards and I'll probably reorder #56 after #57/#58, to get the stuff that deals with stack allocation (#56, #59..61) together, without "reduce the exposure to weird struct path instances" (57 and 58) mixed in the middle of that.
As for the rest... I'm not sure that choose_mountpoint{,_rcu}() is inserted into the right place in text - might be better next to follow_up(). There's also a couple of pick_link() pieces worth separate helpers, but I'd rather leave that for the next cycle - the series is bloody long as it is.
I'm not going to throw the immediate prereqs for ->atomic_open() calling conventions change into that pile - they don't harm anything, but they are unmotivated without the next step (method signature change) and it's really too late in the cycle for that. That's going to be a separate series, probably for the next cycle. Changes to instances are not huge; ceph is the worst by far and that's only +27/-22 lines. So I don't think there will be a lot of conflicts to cope with in the next cycle, especially since ceph side of things looks like we want to do some refactoring first, with much smaller changeover on top of that. That refactoring itself won't have prereqs at all, so that can be dealt with sanely and that'll soak most of the potential conflicts in.
There are other potential refactorings/cleanups, but that's definitely not for this cycle. So... short of regressions found in that series that's probably close to what I'll have for the coming window in this branch. If I see something else in there that can be usefully cleaned up, I'll keep it for after -rc1...
Next: context switch to uaccess series and getting that patchbomb ready. Oh, well...