Branch data Line data Source code
1 : : /*
2 : : * linux/fs/namei.c
3 : : *
4 : : * Copyright (C) 1991, 1992 Linus Torvalds
5 : : */
6 : :
7 : : /*
8 : : * Some corrections by tytso.
9 : : */
10 : :
11 : : /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
12 : : * lookup logic.
13 : : */
14 : : /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
15 : : */
16 : :
17 : : #include <linux/init.h>
18 : : #include <linux/export.h>
19 : : #include <linux/kernel.h>
20 : : #include <linux/slab.h>
21 : : #include <linux/fs.h>
22 : : #include <linux/namei.h>
23 : : #include <linux/pagemap.h>
24 : : #include <linux/fsnotify.h>
25 : : #include <linux/personality.h>
26 : : #include <linux/security.h>
27 : : #include <linux/ima.h>
28 : : #include <linux/syscalls.h>
29 : : #include <linux/mount.h>
30 : : #include <linux/audit.h>
31 : : #include <linux/capability.h>
32 : : #include <linux/file.h>
33 : : #include <linux/fcntl.h>
34 : : #include <linux/device_cgroup.h>
35 : : #include <linux/fs_struct.h>
36 : : #include <linux/posix_acl.h>
37 : : #include <asm/uaccess.h>
38 : :
39 : : #include "internal.h"
40 : : #include "mount.h"
41 : :
42 : : /* [Feb-1997 T. Schoebel-Theuer]
43 : : * Fundamental changes in the pathname lookup mechanisms (namei)
44 : : * were necessary because of omirr. The reason is that omirr needs
45 : : * to know the _real_ pathname, not the user-supplied one, in case
46 : : * of symlinks (and also when transname replacements occur).
47 : : *
48 : : * The new code replaces the old recursive symlink resolution with
49 : : * an iterative one (in case of non-nested symlink chains). It does
50 : : * this with calls to <fs>_follow_link().
51 : : * As a side effect, dir_namei(), _namei() and follow_link() are now
52 : : * replaced with a single function lookup_dentry() that can handle all
53 : : * the special cases of the former code.
54 : : *
55 : : * With the new dcache, the pathname is stored at each inode, at least as
56 : : * long as the refcount of the inode is positive. As a side effect, the
57 : : * size of the dcache depends on the inode cache and thus is dynamic.
58 : : *
59 : : * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
60 : : * resolution to correspond with current state of the code.
61 : : *
62 : : * Note that the symlink resolution is not *completely* iterative.
63 : : * There is still a significant amount of tail- and mid- recursion in
64 : : * the algorithm. Also, note that <fs>_readlink() is not used in
65 : : * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
66 : : * may return different results than <fs>_follow_link(). Many virtual
67 : : * filesystems (including /proc) exhibit this behavior.
68 : : */
69 : :
70 : : /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
71 : : * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
72 : : * and the name already exists in form of a symlink, try to create the new
73 : : * name indicated by the symlink. The old code always complained that the
74 : : * name already exists, due to not following the symlink even if its target
75 : : * is nonexistent. The new semantics affects also mknod() and link() when
76 : : * the name is a symlink pointing to a non-existent name.
77 : : *
78 : : * I don't know which semantics is the right one, since I have no access
79 : : * to standards. But I found by trial that HP-UX 9.0 has the full "new"
80 : : * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
81 : : * "old" one. Personally, I think the new semantics is much more logical.
82 : : * Note that "ln old new" where "new" is a symlink pointing to a non-existing
83 : : * file does succeed in both HP-UX and SunOs, but not in Solaris
84 : : * and in the old Linux semantics.
85 : : */
86 : :
87 : : /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
88 : : * semantics. See the comments in "open_namei" and "do_link" below.
89 : : *
90 : : * [10-Sep-98 Alan Modra] Another symlink change.
91 : : */
92 : :
93 : : /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
94 : : * inside the path - always follow.
95 : : * in the last component in creation/removal/renaming - never follow.
96 : : * if LOOKUP_FOLLOW passed - follow.
97 : : * if the pathname has trailing slashes - follow.
98 : : * otherwise - don't follow.
99 : : * (applied in that order).
100 : : *
101 : : * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
102 : : * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
103 : : * During the 2.4 we need to fix the userland stuff depending on it -
104 : : * hopefully we will be able to get rid of that wart in 2.5. So far only
105 : : * XEmacs seems to be relying on it...
106 : : */
107 : : /*
108 : : * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
109 : : * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives
110 : : * any extra contention...
111 : : */
112 : :
113 : : /* In order to reduce some races, while at the same time doing additional
114 : : * checking and hopefully speeding things up, we copy filenames to the
115 : : * kernel data space before using them..
116 : : *
117 : : * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
118 : : * PATH_MAX includes the nul terminator --RR.
119 : : */
120 : 0 : void final_putname(struct filename *name)
121 : : {
122 [ + + ]: 5205066 : if (name->separate) {
123 : 30 : __putname(name->name);
124 : 30 : kfree(name);
125 : : } else {
126 : 5205036 : __putname(name);
127 : : }
128 : 5205656 : }
129 : :
130 : : #define EMBEDDED_NAME_MAX (PATH_MAX - sizeof(struct filename))
131 : :
132 : : static struct filename *
133 : 0 : getname_flags(const char __user *filename, int flags, int *empty)
134 : : {
135 : : struct filename *result, *err;
136 : : int len;
137 : : long max;
138 : : char *kname;
139 : :
140 : : result = audit_reusename(filename);
141 [ + - ]: 5203117 : if (result)
142 : : return result;
143 : :
144 : 5203117 : result = __getname();
145 [ + + ]: 5203773 : if (unlikely(!result))
146 : : return ERR_PTR(-ENOMEM);
147 : :
148 : : /*
149 : : * First, try to embed the struct filename inside the names_cache
150 : : * allocation
151 : : */
152 : 5203753 : kname = (char *)result + sizeof(*result);
153 : 5203753 : result->name = kname;
154 : 5203753 : result->separate = false;
155 : : max = EMBEDDED_NAME_MAX;
156 : :
157 : : recopy:
158 : 5203783 : len = strncpy_from_user(kname, filename, max);
159 [ + + ]: 5203932 : if (unlikely(len < 0)) {
160 : : err = ERR_PTR(len);
161 : 71 : goto error;
162 : : }
163 : :
164 : : /*
165 : : * Uh-oh. We have a name that's approaching PATH_MAX. Allocate a
166 : : * separate struct filename so we can dedicate the entire
167 : : * names_cache allocation for the pathname, and re-do the copy from
168 : : * userland.
169 : : */
170 [ + + ]: 5203861 : if (len == EMBEDDED_NAME_MAX && max == EMBEDDED_NAME_MAX) {
171 : : kname = (char *)result;
172 : :
173 : : result = kzalloc(sizeof(*result), GFP_KERNEL);
174 [ + - ]: 30 : if (!result) {
175 : : err = ERR_PTR(-ENOMEM);
176 : : result = (struct filename *)kname;
177 : : goto error;
178 : : }
179 : 30 : result->name = kname;
180 : 30 : result->separate = true;
181 : : max = PATH_MAX;
182 : 30 : goto recopy;
183 : : }
184 : :
185 : : /* The empty path is special. */
186 [ + + ]: 5203831 : if (unlikely(!len)) {
187 [ + + ]: 54 : if (empty)
188 : 1 : *empty = 1;
189 : : err = ERR_PTR(-ENOENT);
190 [ + ]: 54 : if (!(flags & LOOKUP_EMPTY))
191 : : goto error;
192 : : }
193 : :
194 : : err = ERR_PTR(-ENAMETOOLONG);
195 [ + + ]: 5203468 : if (unlikely(len >= PATH_MAX))
196 : : goto error;
197 : :
198 : 5203438 : result->uptr = filename;
199 : 5203438 : result->aname = NULL;
200 : : audit_getname(result);
201 : 5203824 : return result;
202 : :
203 : : error:
204 : 464 : final_putname(result);
205 : 154 : return err;
206 : : }
207 : :
208 : : struct filename *
209 : 0 : getname(const char __user * filename)
210 : : {
211 : 4732376 : return getname_flags(filename, 0, NULL);
212 : : }
213 : :
214 : : /*
215 : : * The "getname_kernel()" interface doesn't do pathnames longer
216 : : * than EMBEDDED_NAME_MAX. Deal with it - you're a kernel user.
217 : : */
218 : : struct filename *
219 : 0 : getname_kernel(const char * filename)
220 : : {
221 : : struct filename *result;
222 : : char *kname;
223 : : int len;
224 : :
225 : 342 : len = strlen(filename);
226 [ + - ]: 342 : if (len >= EMBEDDED_NAME_MAX)
227 : : return ERR_PTR(-ENAMETOOLONG);
228 : :
229 : 342 : result = __getname();
230 [ + - ]: 342 : if (unlikely(!result))
231 : : return ERR_PTR(-ENOMEM);
232 : :
233 : 342 : kname = (char *)result + sizeof(*result);
234 : 342 : result->name = kname;
235 : 342 : result->uptr = NULL;
236 : 342 : result->aname = NULL;
237 : 342 : result->separate = false;
238 : :
239 : 342 : strlcpy(kname, filename, EMBEDDED_NAME_MAX);
240 : 342 : return result;
241 : : }
242 : :
243 : : #ifdef CONFIG_AUDITSYSCALL
244 : 0 : void putname(struct filename *name)
245 : : {
246 [ - + ]: 5205280 : if (unlikely(!audit_dummy_context()))
247 : 0 : return audit_putname(name);
248 : 5205280 : final_putname(name);
249 : : }
250 : : #endif
251 : :
252 : 0 : static int check_acl(struct inode *inode, int mask)
253 : : {
254 : : #ifdef CONFIG_FS_POSIX_ACL
255 : : struct posix_acl *acl;
256 : :
257 [ + + ]: 531692 : if (mask & MAY_NOT_BLOCK) {
258 : 531584 : acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
259 [ - + ]: 531584 : if (!acl)
260 : : return -EAGAIN;
261 : : /* no ->get_acl() calls in RCU mode... */
262 [ # # ]: 0 : if (acl == ACL_NOT_CACHED)
263 : : return -ECHILD;
264 : 0 : return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
265 : : }
266 : :
267 : 108 : acl = get_acl(inode, ACL_TYPE_ACCESS);
268 [ - + ]: 108 : if (IS_ERR(acl))
269 : 0 : return PTR_ERR(acl);
270 [ - + ]: 108 : if (acl) {
271 : 0 : int error = posix_acl_permission(inode, acl, mask);
272 : : posix_acl_release(acl);
273 : 0 : return error;
274 : : }
275 : : #endif
276 : :
277 : : return -EAGAIN;
278 : : }
279 : :
280 : : /*
281 : : * This does the basic permission checking
282 : : */
283 : 0 : static int acl_permission_check(struct inode *inode, int mask)
284 : : {
285 : 17785226 : unsigned int mode = inode->i_mode;
286 : :
287 [ + + ]: 17785226 : if (likely(uid_eq(current_fsuid(), inode->i_uid)))
288 : 13628691 : mode >>= 6;
289 : : else {
290 [ + + ][ + - ]: 4156535 : if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
291 : 531692 : int error = check_acl(inode, mask);
292 [ + - ]: 531692 : if (error != -EAGAIN)
293 : : return error;
294 : : }
295 : :
296 [ + + ]: 4156535 : if (in_group_p(inode->i_gid))
297 : 9743 : mode >>= 3;
298 : : }
299 : :
300 : : /*
301 : : * If the DACs are ok we don't need any capability check.
302 : : */
303 [ + + ]: 17785278 : if ((mask & ~mode & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
304 : : return 0;
305 : 33062 : return -EACCES;
306 : : }
307 : :
308 : : /**
309 : : * generic_permission - check for access rights on a Posix-like filesystem
310 : : * @inode: inode to check access rights for
311 : : * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
312 : : *
313 : : * Used to check for read/write/execute permissions on a file.
314 : : * We use "fsuid" for this, letting us set arbitrary permissions
315 : : * for filesystem access without changing the "normal" uids which
316 : : * are used for other things.
317 : : *
318 : : * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
319 : : * request cannot be satisfied (eg. requires blocking or too much complexity).
320 : : * It would then be called again in ref-walk mode.
321 : : */
322 : 0 : int generic_permission(struct inode *inode, int mask)
323 : : {
324 : : int ret;
325 : :
326 : : /*
327 : : * Do the basic permission checks.
328 : : */
329 : 17791907 : ret = acl_permission_check(inode, mask);
330 [ + + ]: 17818008 : if (ret != -EACCES)
331 : : return ret;
332 : :
333 [ + + ]: 33062 : if (S_ISDIR(inode->i_mode)) {
334 : : /* DACs are overridable for directories */
335 [ + + ]: 32578 : if (inode_capable(inode, CAP_DAC_OVERRIDE))
336 : : return 0;
337 [ + + ]: 234 : if (!(mask & MAY_WRITE))
338 [ + - ]: 213 : if (inode_capable(inode, CAP_DAC_READ_SEARCH))
339 : : return 0;
340 : : return -EACCES;
341 : : }
342 : : /*
343 : : * Read/write DACs are always overridable.
344 : : * Executable DACs are overridable when there is
345 : : * at least one exec bit set.
346 : : */
347 [ + + ][ + + ]: 484 : if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
348 [ + + ]: 479 : if (inode_capable(inode, CAP_DAC_OVERRIDE))
349 : : return 0;
350 : :
351 : : /*
352 : : * Searching includes executable on directories, else just read.
353 : : */
354 : 108 : mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
355 [ + + ]: 108 : if (mask == MAY_READ)
356 [ + - ]: 5 : if (inode_capable(inode, CAP_DAC_READ_SEARCH))
357 : : return 0;
358 : :
359 : : return -EACCES;
360 : : }
361 : :
362 : : /*
363 : : * We _really_ want to just do "generic_permission()" without
364 : : * even looking at the inode->i_op values. So we keep a cache
365 : : * flag in inode->i_opflags, that says "this has not special
366 : : * permission function, use the fast case".
367 : : */
368 : : static inline int do_inode_permission(struct inode *inode, int mask)
369 : : {
370 [ + + ]: 17857245 : if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
371 [ + + ]: 394130 : if (likely(inode->i_op->permission))
372 : 169147 : return inode->i_op->permission(inode, mask);
373 : :
374 : : /* This gets set once for the inode lifetime */
375 : : spin_lock(&inode->i_lock);
376 : 224834 : inode->i_opflags |= IOP_FASTPERM;
377 : : spin_unlock(&inode->i_lock);
378 : : }
379 : 17688115 : return generic_permission(inode, mask);
380 : : }
381 : :
382 : : /**
383 : : * __inode_permission - Check for access rights to a given inode
384 : : * @inode: Inode to check permission on
385 : : * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
386 : : *
387 : : * Check for read/write/execute permissions on an inode.
388 : : *
389 : : * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
390 : : *
391 : : * This does not check for a read-only file system. You probably want
392 : : * inode_permission().
393 : : */
394 : 0 : int __inode_permission(struct inode *inode, int mask)
395 : : {
396 : : int retval;
397 : :
398 [ + + ]: 17832427 : if (unlikely(mask & MAY_WRITE)) {
399 : : /*
400 : : * Nobody gets write access to an immutable file.
401 : : */
402 [ + ]: 2571460 : if (IS_IMMUTABLE(inode))
403 : : return -EACCES;
404 : : }
405 : :
406 : : retval = do_inode_permission(inode, mask);
407 [ + + ]: 17863210 : if (retval)
408 : : return retval;
409 : :
410 : : retval = devcgroup_inode_permission(inode, mask);
411 : : if (retval)
412 : : return retval;
413 : :
414 : 17838461 : return security_inode_permission(inode, mask);
415 : : }
416 : :
417 : : /**
418 : : * sb_permission - Check superblock-level permissions
419 : : * @sb: Superblock of inode to check permission on
420 : : * @inode: Inode to check permission on
421 : : * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
422 : : *
423 : : * Separate out file-system wide checks from inode-specific permission checks.
424 : : */
425 : : static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
426 : : {
427 [ + + ]: 17842309 : if (unlikely(mask & MAY_WRITE)) {
428 : 2571074 : umode_t mode = inode->i_mode;
429 : :
430 : : /* Nobody gets write access to a read-only fs. */
431 [ + + ][ - + ]: 2571074 : if ((sb->s_flags & MS_RDONLY) &&
432 [ # # ]: 17842307 : (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
433 : : return -EROFS;
434 : : }
435 : : return 0;
436 : : }
437 : :
438 : : /**
439 : : * inode_permission - Check for access rights to a given inode
440 : : * @inode: Inode to check permission on
441 : : * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
442 : : *
443 : : * Check for read/write/execute permissions on an inode. We use fs[ug]id for
444 : : * this, letting us set arbitrary permissions for filesystem access without
445 : : * changing the "normal" UIDs which are used for other things.
446 : : *
447 : : * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
448 : : */
449 : 0 : int inode_permission(struct inode *inode, int mask)
450 : : {
451 : : int retval;
452 : :
453 : 17842309 : retval = sb_permission(inode->i_sb, inode, mask);
454 [ + ]: 17842309 : if (retval)
455 : : return retval;
456 : 17865087 : return __inode_permission(inode, mask);
457 : : }
458 : :
459 : : /**
460 : : * path_get - get a reference to a path
461 : : * @path: path to get the reference to
462 : : *
463 : : * Given a path increment the reference count to the dentry and the vfsmount.
464 : : */
465 : 0 : void path_get(const struct path *path)
466 : : {
467 : 5535469 : mntget(path->mnt);
468 : 5535741 : dget(path->dentry);
469 : 163 : }
470 : : EXPORT_SYMBOL(path_get);
471 : :
472 : : /**
473 : : * path_put - put a reference to a path
474 : : * @path: path to put the reference to
475 : : *
476 : : * Given a path decrement the reference count to the dentry and the vfsmount.
477 : : */
478 : 0 : void path_put(const struct path *path)
479 : : {
480 : 11492535 : dput(path->dentry);
481 : 11492711 : mntput(path->mnt);
482 : 4158876 : }
483 : : EXPORT_SYMBOL(path_put);
484 : :
485 : : /*
486 : : * Path walking has 2 modes, rcu-walk and ref-walk (see
487 : : * Documentation/filesystems/path-lookup.txt). In situations when we can't
488 : : * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
489 : : * normal reference counts on dentries and vfsmounts to transition to rcu-walk
490 : : * mode. Refcounts are grabbed at the last known good point before rcu-walk
491 : : * got stuck, so ref-walk may continue from there. If this is not successful
492 : : * (eg. a seqcount has changed), then failure is returned and it's up to caller
493 : : * to restart the path walk from the beginning in ref-walk mode.
494 : : */
495 : :
496 : : /**
497 : : * unlazy_walk - try to switch to ref-walk mode.
498 : : * @nd: nameidata pathwalk data
499 : : * @dentry: child of nd->path.dentry or NULL
500 : : * Returns: 0 on success, -ECHILD on failure
501 : : *
502 : : * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
503 : : * for ref-walk mode. @dentry must be a path found by a do_lookup call on
504 : : * @nd or NULL. Must be called from rcu-walk context.
505 : : */
506 : 0 : static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
507 : : {
508 : 819355 : struct fs_struct *fs = current->fs;
509 : 819355 : struct dentry *parent = nd->path.dentry;
510 : :
511 [ - + ]: 819355 : BUG_ON(!(nd->flags & LOOKUP_RCU));
512 : :
513 : : /*
514 : : * After legitimizing the bastards, terminate_walk()
515 : : * will do the right thing for non-RCU mode, and all our
516 : : * subsequent exit cases should rcu_read_unlock()
517 : : * before returning. Do vfsmount first; if dentry
518 : : * can't be legitimized, just set nd->path.dentry to NULL
519 : : * and rely on dput(NULL) being a no-op.
520 : : */
521 [ + - ]: 819355 : if (!legitimize_mnt(nd->path.mnt, nd->m_seq))
522 : : return -ECHILD;
523 : 819361 : nd->flags &= ~LOOKUP_RCU;
524 : :
525 [ - + ]: 819361 : if (!lockref_get_not_dead(&parent->d_lockref)) {
526 : 0 : nd->path.dentry = NULL;
527 : 0 : goto out;
528 : : }
529 : :
530 : : /*
531 : : * For a negative lookup, the lookup sequence point is the parents
532 : : * sequence point, and it only needs to revalidate the parent dentry.
533 : : *
534 : : * For a positive lookup, we need to move both the parent and the
535 : : * dentry from the RCU domain to be properly refcounted. And the
536 : : * sequence number in the dentry validates *both* dentry counters,
537 : : * since we checked the sequence number of the parent after we got
538 : : * the child sequence number. So we know the parent must still
539 : : * be valid if the child sequence number is still valid.
540 : : */
541 [ + + ]: 819366 : if (!dentry) {
542 [ + ]: 598365 : if (read_seqcount_retry(&parent->d_seq, nd->seq))
543 : : goto out;
544 [ - + ]: 598368 : BUG_ON(nd->inode != parent->d_inode);
545 : : } else {
546 [ + - ]: 220998 : if (!lockref_get_not_dead(&dentry->d_lockref))
547 : : goto out;
548 [ + + ]: 220998 : if (read_seqcount_retry(&dentry->d_seq, nd->seq))
549 : : goto drop_dentry;
550 : : }
551 : :
552 : : /*
553 : : * Sequence counts matched. Now make sure that the root is
554 : : * still valid and get it if required.
555 : : */
556 [ + + ][ + + ]: 819360 : if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
557 : : spin_lock(&fs->lock);
558 [ + - ][ + ]: 811534 : if (nd->root.mnt != fs->root.mnt || nd->root.dentry != fs->root.dentry)
559 : : goto unlock_and_drop_dentry;
560 : 811537 : path_get(&nd->root);
561 : : spin_unlock(&fs->lock);
562 : : }
563 : :
564 : : rcu_read_unlock();
565 : 819365 : return 0;
566 : :
567 : : unlock_and_drop_dentry:
568 : : spin_unlock(&fs->lock);
569 : : drop_dentry:
570 : : rcu_read_unlock();
571 : 0 : dput(dentry);
572 : 0 : goto drop_root_mnt;
573 : : out:
574 : : rcu_read_unlock();
575 : : drop_root_mnt:
576 [ # # ]: 819355 : if (!(nd->flags & LOOKUP_ROOT))
577 : 0 : nd->root.mnt = NULL;
578 : : return -ECHILD;
579 : : }
580 : :
581 : : static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
582 : : {
583 : 294951 : return dentry->d_op->d_revalidate(dentry, flags);
584 : : }
585 : :
586 : : /**
587 : : * complete_walk - successful completion of path walk
588 : : * @nd: pointer nameidata
589 : : *
590 : : * If we had been in RCU mode, drop out of it and legitimize nd->path.
591 : : * Revalidate the final result, unless we'd already done that during
592 : : * the path walk or the filesystem doesn't ask for it. Return 0 on
593 : : * success, -error on failure. In case of failure caller does not
594 : : * need to drop nd->path.
595 : : */
596 : 0 : static int complete_walk(struct nameidata *nd)
597 : : {
598 : 6241272 : struct dentry *dentry = nd->path.dentry;
599 : : int status;
600 : :
601 [ + + ]: 6241272 : if (nd->flags & LOOKUP_RCU) {
602 : 4376541 : nd->flags &= ~LOOKUP_RCU;
603 [ + ]: 4376541 : if (!(nd->flags & LOOKUP_ROOT))
604 : 4378898 : nd->root.mnt = NULL;
605 : :
606 [ + + ]: 4376541 : if (!legitimize_mnt(nd->path.mnt, nd->m_seq)) {
607 : : rcu_read_unlock();
608 : 1 : return -ECHILD;
609 : : }
610 [ + + ]: 4380249 : if (unlikely(!lockref_get_not_dead(&dentry->d_lockref))) {
611 : : rcu_read_unlock();
612 : 4 : mntput(nd->path.mnt);
613 : 4 : return -ECHILD;
614 : : }
615 [ + + ]: 4373600 : if (read_seqcount_retry(&dentry->d_seq, nd->seq)) {
616 : : rcu_read_unlock();
617 : 247 : dput(dentry);
618 : 247 : mntput(nd->path.mnt);
619 : 247 : return -ECHILD;
620 : : }
621 : : rcu_read_unlock();
622 : : }
623 : :
624 [ + + ]: 6242489 : if (likely(!(nd->flags & LOOKUP_JUMPED)))
625 : : return 0;
626 : :
627 [ - + ]: 16699 : if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE)))
628 : : return 0;
629 : :
630 : 0 : status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);
631 [ # # ]: 0 : if (status > 0)
632 : : return 0;
633 : :
634 [ # # ]: 0 : if (!status)
635 : : status = -ESTALE;
636 : :
637 : : path_put(&nd->path);
638 : 0 : return status;
639 : : }
640 : :
641 : : static __always_inline void set_root(struct nameidata *nd)
642 : : {
643 [ - + ][ # # ]: 30312 : if (!nd->root.mnt)
[ + + ][ + - ]
[ - + ][ + + ]
644 : 570 : get_fs_root(current->fs, &nd->root);
645 : : }
646 : :
647 : : static int link_path_walk(const char *, struct nameidata *);
648 : :
649 : : static __always_inline void set_root_rcu(struct nameidata *nd)
650 : : {
651 [ + + ][ + + ]: 3258116 : if (!nd->root.mnt) {
652 : 3256092 : struct fs_struct *fs = current->fs;
653 : : unsigned seq;
654 : :
655 : : do {
656 : : seq = read_seqcount_begin(&fs->seq);
657 : 3256084 : nd->root = fs->root;
658 : 3256084 : nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
659 [ + - + ]: 3258066 : } while (read_seqcount_retry(&fs->seq, seq));
660 : : }
661 : : }
662 : :
663 : 206 : static void path_put_conditional(struct path *path, struct nameidata *nd)
664 : : {
665 : 206 : dput(path->dentry);
666 [ - + ]: 206 : if (path->mnt != nd->path.mnt)
667 : 0 : mntput(path->mnt);
668 : 0 : }
669 : :
670 : : static inline void path_to_nameidata(const struct path *path,
671 : : struct nameidata *nd)
672 : : {
673 [ + ][ + + ]: 9085598 : if (!(nd->flags & LOOKUP_RCU)) {
[ + + ][ + + ]
[ + + ][ + - ]
[ + - ][ + + ]
[ + + ][ + - ]
[ # # ]
674 : 1113376 : dput(nd->path.dentry);
675 [ - + - + : 1113236 : if (nd->path.mnt != path->mnt)
+ - + + -
+ - + - +
+ + - + +
+ # # ]
676 : 23294 : mntput(nd->path.mnt);
677 : : }
678 : 9082740 : nd->path.mnt = path->mnt;
679 : 1764558 : nd->path.dentry = path->dentry;
680 : : }
681 : :
682 : : /*
683 : : * Helper to directly jump to a known parsed path from ->follow_link,
684 : : * caller must have taken a reference to path beforehand.
685 : : */
686 : 0 : void nd_jump_link(struct nameidata *nd, struct path *path)
687 : : {
688 : : path_put(&nd->path);
689 : :
690 : 2446 : nd->path = *path;
691 : 2446 : nd->inode = nd->path.dentry->d_inode;
692 : 2446 : nd->flags |= LOOKUP_JUMPED;
693 : 2446 : }
694 : :
695 : : static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
696 : : {
697 : 137605 : struct inode *inode = link->dentry->d_inode;
698 [ # # ][ # # : 137605 : if (inode->i_op->put_link)
+ + # # ]
[ # # # #
# # ][ # # ]
[ - + # # ]
[ # # ][ + + ]
699 : 5356 : inode->i_op->put_link(link->dentry, nd, cookie);
700 : 137616 : path_put(link);
701 : : }
702 : :
703 : : int sysctl_protected_symlinks __read_mostly = 0;
704 : : int sysctl_protected_hardlinks __read_mostly = 0;
705 : :
706 : : /**
707 : : * may_follow_link - Check symlink following for unsafe situations
708 : : * @link: The path of the symlink
709 : : * @nd: nameidata pathwalk data
710 : : *
711 : : * In the case of the sysctl_protected_symlinks sysctl being enabled,
712 : : * CAP_DAC_OVERRIDE needs to be specifically ignored if the symlink is
713 : : * in a sticky world-writable directory. This is to protect privileged
714 : : * processes from failing races against path names that may change out
715 : : * from under them by way of other users creating malicious symlinks.
716 : : * It will permit symlinks to be followed only when outside a sticky
717 : : * world-writable directory, or when the uid of the symlink and follower
718 : : * match, or when the directory owner matches the symlink's owner.
719 : : *
720 : : * Returns 0 if following the symlink is allowed, -ve on error.
721 : : */
722 : : static inline int may_follow_link(struct path *link, struct nameidata *nd)
723 : : {
724 : : const struct inode *inode;
725 : : const struct inode *parent;
726 : :
727 [ + + ][ # # ]: 127039 : if (!sysctl_protected_symlinks)
[ + - ]
728 : : return 0;
729 : :
730 : : /* Allowed if owner and follower match. */
731 : 127035 : inode = link->dentry->d_inode;
732 [ + + ][ # # ]: 127035 : if (uid_eq(current_cred()->fsuid, inode->i_uid))
[ + + ]
733 : : return 0;
734 : :
735 : : /* Allowed if parent directory not sticky and world-writable. */
736 : 1445 : parent = nd->path.dentry->d_inode;
737 [ + + ][ # # ]: 1445 : if ((parent->i_mode & (S_ISVTX|S_IWOTH)) != (S_ISVTX|S_IWOTH))
[ - + ]
738 : : return 0;
739 : :
740 : : /* Allowed if parent directory and link owner match. */
741 [ + + ][ # # ]: 240 : if (uid_eq(parent->i_uid, inode->i_uid))
[ # # ]
742 : : return 0;
743 : :
744 : 192 : audit_log_link_denied("follow_link", link);
745 : 192 : path_put_conditional(link, nd);
746 : 192 : path_put(&nd->path);
747 : : return -EACCES;
748 : : }
749 : :
750 : : /**
751 : : * safe_hardlink_source - Check for safe hardlink conditions
752 : : * @inode: the source inode to hardlink from
753 : : *
754 : : * Return false if at least one of the following conditions:
755 : : * - inode is not a regular file
756 : : * - inode is setuid
757 : : * - inode is setgid and group-exec
758 : : * - access failure for read and write
759 : : *
760 : : * Otherwise returns true.
761 : : */
762 : 0 : static bool safe_hardlink_source(struct inode *inode)
763 : : {
764 : 55 : umode_t mode = inode->i_mode;
765 : :
766 : : /* Special files should not get pinned to the filesystem. */
767 [ + - ]: 55 : if (!S_ISREG(mode))
768 : : return false;
769 : :
770 : : /* Setuid files should not get pinned to the filesystem. */
771 [ + - ]: 55 : if (mode & S_ISUID)
772 : : return false;
773 : :
774 : : /* Executable setgid files should not get pinned to the filesystem. */
775 [ + - ]: 55 : if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
776 : : return false;
777 : :
778 : : /* Hardlinking to unreadable or unwritable sources is dangerous. */
779 [ + + ]: 55 : if (inode_permission(inode, MAY_READ | MAY_WRITE))
780 : : return false;
781 : :
782 : 28 : return true;
783 : : }
784 : :
785 : : /**
786 : : * may_linkat - Check permissions for creating a hardlink
787 : : * @link: the source to hardlink from
788 : : *
789 : : * Block hardlink when all of:
790 : : * - sysctl_protected_hardlinks enabled
791 : : * - fsuid does not match inode
792 : : * - hardlink source is unsafe (see safe_hardlink_source() above)
793 : : * - not CAP_FOWNER
794 : : *
795 : : * Returns 0 if successful, -ve on error.
796 : : */
797 : 0 : static int may_linkat(struct path *link)
798 : : {
799 : : const struct cred *cred;
800 : : struct inode *inode;
801 : :
802 [ + - ]: 5317 : if (!sysctl_protected_hardlinks)
803 : : return 0;
804 : :
805 : 5317 : cred = current_cred();
806 : 5317 : inode = link->dentry->d_inode;
807 : :
808 : : /* Source inode owner (or CAP_FOWNER) can hardlink all they like,
809 : : * otherwise, it must be a safe source.
810 : : */
811 [ + + ]: 5344 : if (uid_eq(cred->fsuid, inode->i_uid) || safe_hardlink_source(inode) ||
[ + + + - ]
812 : 27 : capable(CAP_FOWNER))
813 : : return 0;
814 : :
815 : 27 : audit_log_link_denied("linkat", link);
816 : 27 : return -EPERM;
817 : : }
818 : :
819 : : static __always_inline int
820 : : follow_link(struct path *link, struct nameidata *nd, void **p)
821 : : {
822 : 137619 : struct dentry *dentry = link->dentry;
823 : : int error;
824 : : char *s;
825 : :
826 [ - + ][ # # ]: 137619 : BUG_ON(nd->flags & LOOKUP_RCU);
[ - + ][ - + ]
827 : :
828 [ + + ][ # # ]: 137619 : if (link->mnt == nd->path.mnt)
[ + - ][ + - ]
829 : 137616 : mntget(link->mnt);
830 : :
831 : : error = -ELOOP;
832 [ + + ][ # # ]: 137616 : if (unlikely(current->total_link_count >= 40))
[ + + ][ + + ]
833 : : goto out_put_nd_path;
834 : :
835 : 137601 : cond_resched();
836 : 137604 : current->total_link_count++;
837 : :
838 : 137604 : touch_atime(link);
839 : : nd_set_link(nd, NULL);
840 : :
841 : 137595 : error = security_inode_follow_link(link->dentry, nd);
842 [ + + # # : 137599 : if (error)
+ - + - ]
843 : : goto out_put_nd_path;
844 : :
845 : 137589 : nd->last_type = LAST_BIND;
846 : 137589 : *p = dentry->d_inode->i_op->follow_link(dentry, nd);
847 : : error = PTR_ERR(*p);
848 [ + + # # : 137590 : if (IS_ERR(*p))
+ - + - ]
849 : : goto out_put_nd_path;
850 : :
851 : : error = 0;
852 : : s = nd_get_link(nd);
853 [ + + ][ # # ]: 137588 : if (s) {
[ + + ][ + - ]
854 [ - + ][ # # ]: 135145 : if (unlikely(IS_ERR(s))) {
[ - + ][ - + ]
855 : 0 : path_put(&nd->path);
856 : : put_link(nd, link, *p);
857 : : return PTR_ERR(s);
858 : : }
859 [ + + ][ # # ]: 135145 : if (*s == '/') {
[ + + ][ + + ]
860 : : set_root(nd);
861 : 29579 : path_put(&nd->path);
862 : 29579 : nd->path = nd->root;
863 : 29579 : path_get(&nd->root);
864 : 29579 : nd->flags |= LOOKUP_JUMPED;
865 : : }
866 : 135145 : nd->inode = nd->path.dentry->d_inode;
867 : 135145 : error = link_path_walk(s, nd);
868 [ - + # # : 135161 : if (unlikely(error))
- + - + ]
869 : : put_link(nd, link, *p);
870 : : }
871 : :
872 : : return error;
873 : :
874 : : out_put_nd_path:
875 : : *p = NULL;
876 : 27 : path_put(&nd->path);
877 : 15 : path_put(link);
878 : : return error;
879 : : }
880 : :
881 : : static int follow_up_rcu(struct path *path)
882 : : {
883 : : struct mount *mnt = real_mount(path->mnt);
884 : : struct mount *parent;
885 : : struct dentry *mountpoint;
886 : :
887 : 0 : parent = mnt->mnt_parent;
888 [ # # ]: 0 : if (&parent->mnt == path->mnt)
889 : : return 0;
890 : 0 : mountpoint = mnt->mnt_mountpoint;
891 : 0 : path->dentry = mountpoint;
892 : 0 : path->mnt = &parent->mnt;
893 : : return 1;
894 : : }
895 : :
896 : : /*
897 : : * follow_up - Find the mountpoint of path's vfsmount
898 : : *
899 : : * Given a path, find the mountpoint of its source file system.
900 : : * Replace @path with the path of the mountpoint in the parent mount.
901 : : * Up is towards /.
902 : : *
903 : : * Return 1 if we went up a level and 0 if we were already at the
904 : : * root.
905 : : */
906 : 0 : int follow_up(struct path *path)
907 : : {
908 : 0 : struct mount *mnt = real_mount(path->mnt);
909 : : struct mount *parent;
910 : : struct dentry *mountpoint;
911 : :
912 : : read_seqlock_excl(&mount_lock);
913 : 0 : parent = mnt->mnt_parent;
914 [ # # ]: 0 : if (parent == mnt) {
915 : : read_sequnlock_excl(&mount_lock);
916 : 0 : return 0;
917 : : }
918 : 0 : mntget(&parent->mnt);
919 : 0 : mountpoint = dget(mnt->mnt_mountpoint);
920 : : read_sequnlock_excl(&mount_lock);
921 : 0 : dput(path->dentry);
922 : 0 : path->dentry = mountpoint;
923 : 0 : mntput(path->mnt);
924 : 0 : path->mnt = &parent->mnt;
925 : 0 : return 1;
926 : : }
927 : :
928 : : /*
929 : : * Perform an automount
930 : : * - return -EISDIR to tell follow_managed() to stop and return the path we
931 : : * were called with.
932 : : */
933 : 0 : static int follow_automount(struct path *path, unsigned flags,
934 : : bool *need_mntput)
935 : : {
936 : : struct vfsmount *mnt;
937 : : int err;
938 : :
939 [ # # ][ # # ]: 0 : if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
940 : : return -EREMOTE;
941 : :
942 : : /* We don't want to mount if someone's just doing a stat -
943 : : * unless they're stat'ing a directory and appended a '/' to
944 : : * the name.
945 : : *
946 : : * We do, however, want to mount if someone wants to open or
947 : : * create a file of any type under the mountpoint, wants to
948 : : * traverse through the mountpoint or wants to open the
949 : : * mounted directory. Also, autofs may mark negative dentries
950 : : * as being automount points. These will need the attentions
951 : : * of the daemon to instantiate them before they can be used.
952 : : */
953 [ # # ]: 0 : if (!(flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
954 [ # # ]: 0 : LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
955 : 0 : path->dentry->d_inode)
956 : : return -EISDIR;
957 : :
958 : 0 : current->total_link_count++;
959 [ # # ]: 0 : if (current->total_link_count >= 40)
960 : : return -ELOOP;
961 : :
962 : 0 : mnt = path->dentry->d_op->d_automount(path);
963 [ # # ]: 0 : if (IS_ERR(mnt)) {
964 : : /*
965 : : * The filesystem is allowed to return -EISDIR here to indicate
966 : : * it doesn't want to automount. For instance, autofs would do
967 : : * this so that its userspace daemon can mount on this dentry.
968 : : *
969 : : * However, we can only permit this if it's a terminal point in
970 : : * the path being looked up; if it wasn't then the remainder of
971 : : * the path is inaccessible and we should say so.
972 : : */
973 [ # # ][ # # ]: 0 : if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT))
974 : : return -EREMOTE;
975 : 0 : return PTR_ERR(mnt);
976 : : }
977 : :
978 [ # # ]: 0 : if (!mnt) /* mount collision */
979 : : return 0;
980 : :
981 [ # # ]: 0 : if (!*need_mntput) {
982 : : /* lock_mount() may release path->mnt on error */
983 : 0 : mntget(path->mnt);
984 : 0 : *need_mntput = true;
985 : : }
986 : 0 : err = finish_automount(mnt, path);
987 : :
988 [ # # # ]: 0 : switch (err) {
989 : : case -EBUSY:
990 : : /* Someone else made a mount here whilst we were busy */
991 : : return 0;
992 : : case 0:
993 : : path_put(path);
994 : 0 : path->mnt = mnt;
995 : 0 : path->dentry = dget(mnt->mnt_root);
996 : 0 : return 0;
997 : : default:
998 : 0 : return err;
999 : : }
1000 : :
1001 : : }
1002 : :
1003 : : /*
1004 : : * Handle a dentry that is managed in some way.
1005 : : * - Flagged for transit management (autofs)
1006 : : * - Flagged as mountpoint
1007 : : * - Flagged as automount point
1008 : : *
1009 : : * This may only be called in refwalk mode.
1010 : : *
1011 : : * Serialization is taken care of in namespace.c
1012 : : */
1013 : 0 : static int follow_managed(struct path *path, unsigned flags)
1014 : : {
1015 : 2740919 : struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
1016 : : unsigned managed;
1017 : 2740919 : bool need_mntput = false;
1018 : : int ret = 0;
1019 : :
1020 : : /* Given that we're not holding a lock here, we retain the value in a
1021 : : * local variable for each dentry as we look at it so that we don't see
1022 : : * the components of that value change under us */
1023 [ + + ]: 2764236 : while (managed = ACCESS_ONCE(path->dentry->d_flags),
1024 : 2764236 : managed &= DCACHE_MANAGED_DENTRY,
1025 : 2764236 : unlikely(managed != 0)) {
1026 : : /* Allow the filesystem to manage the transit without i_mutex
1027 : : * being held. */
1028 [ - + ]: 27507 : if (managed & DCACHE_MANAGE_TRANSIT) {
1029 [ # # ]: 0 : BUG_ON(!path->dentry->d_op);
1030 [ # # ]: 0 : BUG_ON(!path->dentry->d_op->d_manage);
1031 : 0 : ret = path->dentry->d_op->d_manage(path->dentry, false);
1032 [ # # ]: 0 : if (ret < 0)
1033 : : break;
1034 : : }
1035 : :
1036 : : /* Transit to a mounted filesystem. */
1037 [ + - ]: 27507 : if (managed & DCACHE_MOUNTED) {
1038 : 27507 : struct vfsmount *mounted = lookup_mnt(path);
1039 [ + + ]: 27507 : if (mounted) {
1040 : 23317 : dput(path->dentry);
1041 [ + + ]: 23317 : if (need_mntput)
1042 : 23 : mntput(path->mnt);
1043 : 23317 : path->mnt = mounted;
1044 : 46634 : path->dentry = dget(mounted->mnt_root);
1045 : 23317 : need_mntput = true;
1046 : 23317 : continue;
1047 : : }
1048 : :
1049 : : /* Something is mounted on this dentry in another
1050 : : * namespace and/or whatever was mounted there in this
1051 : : * namespace got unmounted before lookup_mnt() could
1052 : : * get it */
1053 : : }
1054 : :
1055 : : /* Handle an automount point */
1056 [ - + ]: 4190 : if (managed & DCACHE_NEED_AUTOMOUNT) {
1057 : 0 : ret = follow_automount(path, flags, &need_mntput);
1058 [ # # ]: 0 : if (ret < 0)
1059 : : break;
1060 : 23317 : continue;
1061 : : }
1062 : :
1063 : : /* We didn't change the current path point */
1064 : : break;
1065 : : }
1066 : :
1067 [ + + ][ - + ]: 2740919 : if (need_mntput && path->mnt == mnt)
1068 : 0 : mntput(path->mnt);
1069 [ - + ]: 5481837 : if (ret == -EISDIR)
1070 : : ret = 0;
1071 [ + - ]: 2740918 : return ret < 0 ? ret : need_mntput;
1072 : : }
1073 : :
1074 : 0 : int follow_down_one(struct path *path)
1075 : : {
1076 : : struct vfsmount *mounted;
1077 : :
1078 : 0 : mounted = lookup_mnt(path);
1079 [ # # ]: 0 : if (mounted) {
1080 : 0 : dput(path->dentry);
1081 : 0 : mntput(path->mnt);
1082 : 0 : path->mnt = mounted;
1083 : 0 : path->dentry = dget(mounted->mnt_root);
1084 : 0 : return 1;
1085 : : }
1086 : : return 0;
1087 : : }
1088 : :
1089 : : static inline bool managed_dentry_might_block(struct dentry *dentry)
1090 : : {
1091 [ - + # # ]: 8811581 : return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
1092 : 0 : dentry->d_op->d_manage(dentry, true) < 0);
1093 : : }
1094 : :
1095 : : /*
1096 : : * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if
1097 : : * we meet a managed dentry that would need blocking.
1098 : : */
1099 : 8102674 : static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
1100 : : struct inode **inode)
1101 : : {
1102 : : for (;;) {
1103 : : struct mount *mounted;
1104 : : /*
1105 : : * Don't forget we might have a non-mountpoint managed dentry
1106 : : * that wants to block transit.
1107 : : */
1108 [ + ]: 8811581 : if (unlikely(managed_dentry_might_block(path->dentry)))
1109 : : return false;
1110 : :
1111 [ + + ]: 8819226 : if (!d_mountpoint(path->dentry))
1112 : : return true;
1113 : :
1114 : 712753 : mounted = __lookup_mnt(path->mnt, path->dentry);
1115 [ + + ]: 712748 : if (!mounted)
1116 : : break;
1117 : 708901 : path->mnt = &mounted->mnt;
1118 : 708901 : path->dentry = mounted->mnt.mnt_root;
1119 : 708901 : nd->flags |= LOOKUP_JUMPED;
1120 : 708901 : nd->seq = read_seqcount_begin(&path->dentry->d_seq);
1121 : : /*
1122 : : * Update the inode too. We don't need to re-check the
1123 : : * dentry sequence number here after this d_inode read,
1124 : : * because a mount-point is always pinned.
1125 : : */
1126 : 708907 : *inode = path->dentry->d_inode;
1127 : 708907 : }
1128 : 3847 : return read_seqretry(&mount_lock, nd->m_seq);
1129 : : }
1130 : :
1131 : 0 : static int follow_dotdot_rcu(struct nameidata *nd)
1132 : : {
1133 : : set_root_rcu(nd);
1134 : :
1135 : : while (1) {
1136 [ - + ][ # # ]: 2586 : if (nd->path.dentry == nd->root.dentry &&
1137 : 0 : nd->path.mnt == nd->root.mnt) {
1138 : : break;
1139 : : }
1140 [ + - ]: 2586 : if (nd->path.dentry != nd->path.mnt->mnt_root) {
1141 : : struct dentry *old = nd->path.dentry;
1142 : 2586 : struct dentry *parent = old->d_parent;
1143 : : unsigned seq;
1144 : :
1145 : : seq = read_seqcount_begin(&parent->d_seq);
1146 [ + + ]: 2586 : if (read_seqcount_retry(&old->d_seq, nd->seq))
1147 : : goto failed;
1148 : 2094 : nd->path.dentry = parent;
1149 : 2094 : nd->seq = seq;
1150 : 2094 : break;
1151 : : }
1152 [ # # ]: 0 : if (!follow_up_rcu(&nd->path))
1153 : : break;
1154 : 0 : nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1155 : 0 : }
1156 [ - + ]: 2094 : while (d_mountpoint(nd->path.dentry)) {
1157 : : struct mount *mounted;
1158 : 0 : mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry);
1159 [ # # ]: 0 : if (!mounted)
1160 : : break;
1161 : 0 : nd->path.mnt = &mounted->mnt;
1162 : 0 : nd->path.dentry = mounted->mnt.mnt_root;
1163 : 0 : nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1164 [ # # ]: 2094 : if (!read_seqretry(&mount_lock, nd->m_seq))
1165 : : goto failed;
1166 : : }
1167 : 2094 : nd->inode = nd->path.dentry->d_inode;
1168 : 2094 : return 0;
1169 : :
1170 : : failed:
1171 : 492 : nd->flags &= ~LOOKUP_RCU;
1172 [ + - ]: 492 : if (!(nd->flags & LOOKUP_ROOT))
1173 : 492 : nd->root.mnt = NULL;
1174 : : rcu_read_unlock();
1175 : 492 : return -ECHILD;
1176 : : }
1177 : :
1178 : : /*
1179 : : * Follow down to the covering mount currently visible to userspace. At each
1180 : : * point, the filesystem owning that dentry may be queried as to whether the
1181 : : * caller is permitted to proceed or not.
1182 : : */
1183 : 0 : int follow_down(struct path *path)
1184 : : {
1185 : : unsigned managed;
1186 : : int ret;
1187 : :
1188 [ # # ]: 0 : while (managed = ACCESS_ONCE(path->dentry->d_flags),
1189 : 0 : unlikely(managed & DCACHE_MANAGED_DENTRY)) {
1190 : : /* Allow the filesystem to manage the transit without i_mutex
1191 : : * being held.
1192 : : *
1193 : : * We indicate to the filesystem if someone is trying to mount
1194 : : * something here. This gives autofs the chance to deny anyone
1195 : : * other than its daemon the right to mount on its
1196 : : * superstructure.
1197 : : *
1198 : : * The filesystem may sleep at this point.
1199 : : */
1200 [ # # ]: 0 : if (managed & DCACHE_MANAGE_TRANSIT) {
1201 [ # # ]: 0 : BUG_ON(!path->dentry->d_op);
1202 [ # # ]: 0 : BUG_ON(!path->dentry->d_op->d_manage);
1203 : 0 : ret = path->dentry->d_op->d_manage(
1204 : : path->dentry, false);
1205 [ # # ]: 0 : if (ret < 0)
1206 [ # # ]: 0 : return ret == -EISDIR ? 0 : ret;
1207 : : }
1208 : :
1209 : : /* Transit to a mounted filesystem. */
1210 [ # # ]: 0 : if (managed & DCACHE_MOUNTED) {
1211 : 0 : struct vfsmount *mounted = lookup_mnt(path);
1212 [ # # ]: 0 : if (!mounted)
1213 : : break;
1214 : 0 : dput(path->dentry);
1215 : 0 : mntput(path->mnt);
1216 : 0 : path->mnt = mounted;
1217 : 0 : path->dentry = dget(mounted->mnt_root);
1218 : 0 : continue;
1219 : : }
1220 : :
1221 : : /* Don't handle automount points here */
1222 : : break;
1223 : : }
1224 : : return 0;
1225 : : }
1226 : :
1227 : : /*
1228 : : * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1229 : : */
1230 : 0 : static void follow_mount(struct path *path)
1231 : : {
1232 [ + + ]: 3878 : while (d_mountpoint(path->dentry)) {
1233 : 112 : struct vfsmount *mounted = lookup_mnt(path);
1234 [ + + ]: 112 : if (!mounted)
1235 : : break;
1236 : 83 : dput(path->dentry);
1237 : 83 : mntput(path->mnt);
1238 : 83 : path->mnt = mounted;
1239 : 83 : path->dentry = dget(mounted->mnt_root);
1240 : : }
1241 : 0 : }
1242 : :
1243 : 0 : static void follow_dotdot(struct nameidata *nd)
1244 : : {
1245 : : set_root(nd);
1246 : :
1247 : : while(1) {
1248 : 728 : struct dentry *old = nd->path.dentry;
1249 : :
1250 [ - + ][ # # ]: 728 : if (nd->path.dentry == nd->root.dentry &&
1251 : 0 : nd->path.mnt == nd->root.mnt) {
1252 : : break;
1253 : : }
1254 [ + - ]: 728 : if (nd->path.dentry != nd->path.mnt->mnt_root) {
1255 : : /* rare case of legitimate dget_parent()... */
1256 : 728 : nd->path.dentry = dget_parent(nd->path.dentry);
1257 : 728 : dput(old);
1258 : 728 : break;
1259 : : }
1260 [ # # ]: 0 : if (!follow_up(&nd->path))
1261 : : break;
1262 : : }
1263 : 728 : follow_mount(&nd->path);
1264 : 728 : nd->inode = nd->path.dentry->d_inode;
1265 : 728 : }
1266 : :
1267 : : /*
1268 : : * This looks up the name in dcache, possibly revalidates the old dentry and
1269 : : * allocates a new one if not found or not valid. In the need_lookup argument
1270 : : * returns whether i_op->lookup is necessary.
1271 : : *
1272 : : * dir->d_inode->i_mutex must be held
1273 : : */
1274 : 0 : static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
1275 : : unsigned int flags, bool *need_lookup)
1276 : : {
1277 : : struct dentry *dentry;
1278 : : int error;
1279 : :
1280 : 3625331 : *need_lookup = false;
1281 : 3625331 : dentry = d_lookup(dir, name);
1282 [ + + ]: 3625392 : if (dentry) {
1283 [ + + ]: 2845876 : if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
1284 : : error = d_revalidate(dentry, flags);
1285 [ - + ]: 240 : if (unlikely(error <= 0)) {
1286 [ # # ]: 0 : if (error < 0) {
1287 : 0 : dput(dentry);
1288 : 0 : return ERR_PTR(error);
1289 [ # # ]: 0 : } else if (!d_invalidate(dentry)) {
1290 : 0 : dput(dentry);
1291 : : dentry = NULL;
1292 : : }
1293 : : }
1294 : : }
1295 : : }
1296 : :
1297 [ + + ]: 7250575 : if (!dentry) {
1298 : 779349 : dentry = d_alloc(dir, name);
1299 [ + + ]: 779826 : if (unlikely(!dentry))
1300 : : return ERR_PTR(-ENOMEM);
1301 : :
1302 : 779814 : *need_lookup = true;
1303 : : }
1304 : 3625709 : return dentry;
1305 : : }
1306 : :
1307 : : /*
1308 : : * Call i_op->lookup on the dentry. The dentry must be negative and
1309 : : * unhashed.
1310 : : *
1311 : : * dir->d_inode->i_mutex must be held
1312 : : */
1313 : 0 : static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
1314 : : unsigned int flags)
1315 : : {
1316 : : struct dentry *old;
1317 : :
1318 : : /* Don't create child dentry for a dead directory. */
1319 [ + + ]: 779532 : if (unlikely(IS_DEADDIR(dir))) {
1320 : 3 : dput(dentry);
1321 : 3 : return ERR_PTR(-ENOENT);
1322 : : }
1323 : :
1324 : 779529 : old = dir->i_op->lookup(dir, dentry, flags);
1325 [ + + ]: 779774 : if (unlikely(old)) {
1326 : 72 : dput(dentry);
1327 : : dentry = old;
1328 : : }
1329 : 779809 : return dentry;
1330 : : }
1331 : :
1332 : 0 : static struct dentry *__lookup_hash(struct qstr *name,
1333 : : struct dentry *base, unsigned int flags)
1334 : : {
1335 : : bool need_lookup;
1336 : : struct dentry *dentry;
1337 : :
1338 : 1263834 : dentry = lookup_dcache(name, base, flags, &need_lookup);
1339 [ + + ]: 1263944 : if (!need_lookup)
1340 : : return dentry;
1341 : :
1342 : 202590 : return lookup_real(base->d_inode, dentry, flags);
1343 : : }
1344 : :
1345 : : /*
1346 : : * It's more convoluted than I'd like it to be, but... it's still fairly
1347 : : * small and for now I'd prefer to have fast path as straight as possible.
1348 : : * It _is_ time-critical.
1349 : : */
1350 : 0 : static int lookup_fast(struct nameidata *nd,
1351 : : struct path *path, struct inode **inode)
1352 : : {
1353 : 9215153 : struct vfsmount *mnt = nd->path.mnt;
1354 : 9215153 : struct dentry *dentry, *parent = nd->path.dentry;
1355 : : int need_reval = 1;
1356 : : int status = 1;
1357 : : int err;
1358 : :
1359 : : /*
1360 : : * Rename seqlock is not required here because in the off chance
1361 : : * of a false negative due to a concurrent rename, we're going to
1362 : : * do the non-racy lookup, below.
1363 : : */
1364 [ + + ]: 9215153 : if (nd->flags & LOOKUP_RCU) {
1365 : : unsigned seq;
1366 : 8751511 : dentry = __d_lookup_rcu(parent, &nd->last, &seq);
1367 [ + + ]: 8753818 : if (!dentry)
1368 : : goto unlazy;
1369 : :
1370 : : /*
1371 : : * This sequence count validates that the inode matches
1372 : : * the dentry name information from lookup.
1373 : : */
1374 : 8183635 : *inode = dentry->d_inode;
1375 [ + ]: 8183670 : if (read_seqcount_retry(&dentry->d_seq, seq))
1376 : 8107392 : return -ECHILD;
1377 : :
1378 : : /*
1379 : : * This sequence count validates that the parent had no
1380 : : * changes while we did the lookup of the dentry above.
1381 : : *
1382 : : * The memory barrier in read_seqcount_begin of child is
1383 : : * enough, we can use __read_seqcount_retry here.
1384 : : */
1385 [ + ]: 8191607 : if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1386 : : return -ECHILD;
1387 : 8193912 : nd->seq = seq;
1388 : :
1389 [ + + ]: 8193912 : if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1390 : 85187 : status = d_revalidate(dentry, nd->flags);
1391 [ + - ]: 85187 : if (unlikely(status <= 0)) {
1392 [ - + ]: 85187 : if (status != -ECHILD)
1393 : : need_reval = 0;
1394 : : goto unlazy;
1395 : : }
1396 : : }
1397 : 8108725 : path->mnt = mnt;
1398 : 8108725 : path->dentry = dentry;
1399 [ + + ]: 8108725 : if (unlikely(!__follow_mount_rcu(nd, path, inode)))
1400 : : goto unlazy;
1401 [ + ]: 8097931 : if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1402 : : goto unlazy;
1403 : : return 0;
1404 : : unlazy:
1405 [ + - ]: 643588 : if (unlazy_walk(nd, dentry))
1406 : : return -ECHILD;
1407 : : } else {
1408 : 463642 : dentry = __d_lookup(parent, &nd->last);
1409 : : }
1410 : :
1411 [ + + ]: 1123446 : if (unlikely(!dentry))
1412 : : goto need_lookup;
1413 : :
1414 [ + + ][ + - ]: 527604 : if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
1415 : 209524 : status = d_revalidate(dentry, nd->flags);
1416 [ + + ]: 527603 : if (unlikely(status <= 0)) {
1417 [ - + ]: 17 : if (status < 0) {
1418 : 0 : dput(dentry);
1419 : 0 : return status;
1420 : : }
1421 [ + - ]: 17 : if (!d_invalidate(dentry)) {
1422 : 17 : dput(dentry);
1423 : 17 : goto need_lookup;
1424 : : }
1425 : : }
1426 : :
1427 : 527586 : path->mnt = mnt;
1428 : 527586 : path->dentry = dentry;
1429 : 527586 : err = follow_managed(path, nd->flags);
1430 [ - + ]: 9742736 : if (unlikely(err < 0)) {
1431 : 0 : path_put_conditional(path, nd);
1432 : 0 : return err;
1433 : : }
1434 [ + + ]: 527583 : if (err)
1435 : 23294 : nd->flags |= LOOKUP_JUMPED;
1436 : 527583 : *inode = path->dentry->d_inode;
1437 : 527583 : return 0;
1438 : :
1439 : : need_lookup:
1440 : : return 1;
1441 : : }
1442 : :
1443 : : /* Fast lookup failed, do it the slow way */
1444 : 0 : static int lookup_slow(struct nameidata *nd, struct path *path)
1445 : : {
1446 : : struct dentry *dentry, *parent;
1447 : : int err;
1448 : :
1449 : 37680 : parent = nd->path.dentry;
1450 [ - + ]: 37680 : BUG_ON(nd->inode != parent->d_inode);
1451 : :
1452 : 37680 : mutex_lock(&parent->d_inode->i_mutex);
1453 : 37680 : dentry = __lookup_hash(&nd->last, parent, nd->flags);
1454 : 37680 : mutex_unlock(&parent->d_inode->i_mutex);
1455 [ + + ]: 37680 : if (IS_ERR(dentry))
1456 : 18 : return PTR_ERR(dentry);
1457 : 37662 : path->mnt = nd->path.mnt;
1458 : 37662 : path->dentry = dentry;
1459 : 37662 : err = follow_managed(path, nd->flags);
1460 [ - + ]: 37662 : if (unlikely(err < 0)) {
1461 : 0 : path_put_conditional(path, nd);
1462 : 0 : return err;
1463 : : }
1464 [ - + ]: 37662 : if (err)
1465 : 0 : nd->flags |= LOOKUP_JUMPED;
1466 : : return 0;
1467 : : }
1468 : :
1469 : : static inline int may_lookup(struct nameidata *nd)
1470 : : {
1471 [ + + ]: 14414809 : if (nd->flags & LOOKUP_RCU) {
1472 : 13950838 : int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
1473 [ + + ]: 13952281 : if (err != -ECHILD)
1474 : : return err;
1475 [ + ]: 24571 : if (unlazy_walk(nd, NULL))
1476 : : return -ECHILD;
1477 : : }
1478 : 492241 : return inode_permission(nd->inode, MAY_EXEC);
1479 : : }
1480 : :
1481 : : static inline int handle_dots(struct nameidata *nd, int type)
1482 : : {
1483 [ + + ][ # # ]: 1693930 : if (type == LAST_DOTDOT) {
[ + + ][ - + ]
[ + + ][ # # ]
1484 [ + + ][ # # ]: 3314 : if (nd->flags & LOOKUP_RCU) {
[ + + ][ # # ]
[ + + ][ # # ]
1485 [ + + ][ # # ]: 2586 : if (follow_dotdot_rcu(nd))
[ + + ][ # # ]
[ + - ][ # # ]
1486 : : return -ECHILD;
1487 : : } else
1488 : 2822 : follow_dotdot(nd);
1489 : : }
1490 : : return 0;
1491 : : }
1492 : :
1493 : 0 : static void terminate_walk(struct nameidata *nd)
1494 : : {
1495 [ + + ]: 3576958 : if (!(nd->flags & LOOKUP_RCU)) {
1496 : : path_put(&nd->path);
1497 : : } else {
1498 : 543394 : nd->flags &= ~LOOKUP_RCU;
1499 [ + ]: 543394 : if (!(nd->flags & LOOKUP_ROOT))
1500 : 543522 : nd->root.mnt = NULL;
1501 : : rcu_read_unlock();
1502 : : }
1503 : 3577174 : }
1504 : :
1505 : : /*
1506 : : * Do we need to follow links? We _really_ want to be able
1507 : : * to do this check without having to look at inode->i_op,
1508 : : * so we keep a cache of "no, this doesn't need follow_link"
1509 : : * for the common case.
1510 : : */
1511 : : static inline int should_follow_link(struct dentry *dentry, int follow)
1512 : : {
1513 [ + + ][ - + ]: 9736341 : return unlikely(d_is_symlink(dentry)) ? follow : 0;
[ + + ][ + + ]
[ + + ][ + + ]
1514 : : }
1515 : :
1516 : : static inline int walk_component(struct nameidata *nd, struct path *path,
1517 : : int follow)
1518 : : {
1519 : : struct inode *inode;
1520 : : int err;
1521 : : /*
1522 : : * "." and ".." are special - ".." especially so because it has
1523 : : * to be able to know about the current root directory and
1524 : : * parent relationships.
1525 : : */
1526 [ + + ][ + + ]: 9561413 : if (unlikely(nd->last_type != LAST_NORM))
[ + + ][ - + ]
1527 : : return handle_dots(nd, nd->last_type);
1528 : 7869488 : err = lookup_fast(nd, path, &inode);
1529 [ + + + + : 7873361 : if (unlikely(err)) {
+ + + + ]
1530 [ + + ][ + - ]: 37837 : if (err < 0)
[ + - ][ + - ]
1531 : : goto out_err;
1532 : :
1533 : 37680 : err = lookup_slow(nd, path);
1534 [ + + + - : 37680 : if (err < 0)
+ + + - ]
1535 : : goto out_err;
1536 : :
1537 : 37662 : inode = path->dentry->d_inode;
1538 : : }
1539 : : err = -ENOENT;
1540 [ + + ][ + + ]: 7873186 : if (!inode)
[ + + ][ + - ]
1541 : : goto out_path_put;
1542 : :
1543 [ + + ][ + + ]: 7336479 : if (should_follow_link(path->dentry, follow)) {
[ + + ][ + + ]
1544 [ + + ][ - + ]: 17120 : if (nd->flags & LOOKUP_RCU) {
[ + + ][ - + ]
1545 [ + - ][ # # ]: 11908 : if (unlikely(unlazy_walk(nd, path->dentry))) {
[ + - ][ # # ]
1546 : : err = -ECHILD;
1547 : : goto out_err;
1548 : : }
1549 : : }
1550 [ - + ][ - + ]: 17120 : BUG_ON(inode != path->dentry->d_inode);
[ - + ][ - + ]
1551 : : return 1;
1552 : : }
1553 : : path_to_nameidata(path, nd);
1554 : 7318182 : nd->inode = inode;
1555 : : return 0;
1556 : :
1557 : : out_path_put:
1558 : : path_to_nameidata(path, nd);
1559 : : out_err:
1560 : 535042 : terminate_walk(nd);
1561 : : return err;
1562 : : }
1563 : :
1564 : : /*
1565 : : * This limits recursive symlink follows to 8, while
1566 : : * limiting consecutive symlinks to 40.
1567 : : *
1568 : : * Without that kind of total limit, nasty chains of consecutive
1569 : : * symlinks can cause almost arbitrarily long lookups.
1570 : : */
1571 : : static inline int nested_symlink(struct path *path, struct nameidata *nd)
1572 : : {
1573 : : int res;
1574 : :
1575 [ - + ]: 10702 : if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
1576 : 0 : path_put_conditional(path, nd);
1577 : 0 : path_put(&nd->path);
1578 : : return -ELOOP;
1579 : : }
1580 [ - + ]: 10702 : BUG_ON(nd->depth >= MAX_NESTED_LINKS);
1581 : :
1582 : 10702 : nd->depth++;
1583 : 10702 : current->link_count++;
1584 : :
1585 : : do {
1586 : 10772 : struct path link = *path;
1587 : : void *cookie;
1588 : :
1589 : : res = follow_link(&link, nd, &cookie);
1590 [ + + ]: 10772 : if (res)
1591 : : break;
1592 : : res = walk_component(nd, path, LOOKUP_FOLLOW);
1593 : : put_link(nd, &link, cookie);
1594 [ + + ]: 10772 : } while (res > 0);
1595 : :
1596 : 10702 : current->link_count--;
1597 : 10702 : nd->depth--;
1598 : : return res;
1599 : : }
1600 : :
1601 : : /*
1602 : : * We can do the critical dentry name comparison and hashing
1603 : : * operations one word at a time, but we are limited to:
1604 : : *
1605 : : * - Architectures with fast unaligned word accesses. We could
1606 : : * do a "get_unaligned()" if this helps and is sufficiently
1607 : : * fast.
1608 : : *
1609 : : * - non-CONFIG_DEBUG_PAGEALLOC configurations (so that we
1610 : : * do not trap on the (extremely unlikely) case of a page
1611 : : * crossing operation.
1612 : : *
1613 : : * - Furthermore, we need an efficient 64-bit compile for the
1614 : : * 64-bit case in order to generate the "number of bytes in
1615 : : * the final mask". Again, that could be replaced with a
1616 : : * efficient population count instruction or similar.
1617 : : */
1618 : : #ifdef CONFIG_DCACHE_WORD_ACCESS
1619 : :
1620 : : #include <asm/word-at-a-time.h>
1621 : :
1622 : : #ifdef CONFIG_64BIT
1623 : :
1624 : : static inline unsigned int fold_hash(unsigned long hash)
1625 : : {
1626 : : hash += hash >> (8*sizeof(int));
1627 : : return hash;
1628 : : }
1629 : :
1630 : : #else /* 32-bit case */
1631 : :
1632 : : #define fold_hash(x) (x)
1633 : :
1634 : : #endif
1635 : :
1636 : 2241360 : unsigned int full_name_hash(const unsigned char *name, unsigned int len)
1637 : : {
1638 : : unsigned long a, mask;
1639 : : unsigned long hash = 0;
1640 : :
1641 : : for (;;) {
1642 : : a = load_unaligned_zeropad(name);
1643 [ + + ]: 3795553 : if (len < sizeof(unsigned long))
1644 : : break;
1645 : 2180374 : hash += a;
1646 : 2180374 : hash *= 9;
1647 : 2180374 : name += sizeof(unsigned long);
1648 : 2180374 : len -= sizeof(unsigned long);
1649 [ + + ]: 2180374 : if (!len)
1650 : : goto done;
1651 : : }
1652 : 1615179 : mask = bytemask_from_count(len);
1653 : 1615179 : hash += mask & a;
1654 : : done:
1655 : 0 : return fold_hash(hash);
1656 : : }
1657 : : EXPORT_SYMBOL(full_name_hash);
1658 : :
1659 : : /*
1660 : : * Calculate the length and hash of the path component, and
1661 : : * return the length of the component;
1662 : : */
1663 : : static inline unsigned long hash_name(const char *name, unsigned int *hashp)
1664 : : {
1665 : : unsigned long a, b, adata, bdata, mask, hash, len;
1666 : : const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
1667 : :
1668 : : hash = a = 0;
1669 : : len = -sizeof(unsigned long);
1670 : : do {
1671 : 35352122 : hash = (hash + a) * 9;
1672 : 35352122 : len += sizeof(unsigned long);
1673 : 35352122 : a = load_unaligned_zeropad(name+len);
1674 : 35352122 : b = a ^ REPEAT_BYTE('/');
1675 [ + + ]: 35352122 : } while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants)));
1676 : :
1677 : : adata = prep_zero_mask(a, adata, &constants);
1678 : : bdata = prep_zero_mask(b, bdata, &constants);
1679 : :
1680 : : mask = create_zero_mask(adata | bdata);
1681 : :
1682 : 14388905 : hash += a & zero_bytemask(mask);
1683 : 14388905 : *hashp = fold_hash(hash);
1684 : :
1685 : 14388905 : return len + find_zero(mask);
1686 : : }
1687 : :
1688 : : #else
1689 : :
1690 : : unsigned int full_name_hash(const unsigned char *name, unsigned int len)
1691 : : {
1692 : : unsigned long hash = init_name_hash();
1693 : : while (len--)
1694 : : hash = partial_name_hash(*name++, hash);
1695 : : return end_name_hash(hash);
1696 : : }
1697 : : EXPORT_SYMBOL(full_name_hash);
1698 : :
1699 : : /*
1700 : : * We know there's a real path component here of at least
1701 : : * one character.
1702 : : */
1703 : : static inline unsigned long hash_name(const char *name, unsigned int *hashp)
1704 : : {
1705 : : unsigned long hash = init_name_hash();
1706 : : unsigned long len = 0, c;
1707 : :
1708 : : c = (unsigned char)*name;
1709 : : do {
1710 : : len++;
1711 : : hash = partial_name_hash(c, hash);
1712 : : c = (unsigned char)name[len];
1713 : : } while (c && c != '/');
1714 : : *hashp = end_name_hash(hash);
1715 : : return len;
1716 : : }
1717 : :
1718 : : #endif
1719 : :
1720 : : /*
1721 : : * Name resolution.
1722 : : * This is the basic name resolution function, turning a pathname into
1723 : : * the final dentry. We expect 'base' to be positive and a directory.
1724 : : *
1725 : : * Returns 0 and nd will have valid dentry and mnt on success.
1726 : : * Returns error and drops reference to input namei data on failure.
1727 : : */
1728 : 0 : static int link_path_walk(const char *name, struct nameidata *nd)
1729 : : {
1730 : : struct path next;
1731 : : int err;
1732 : :
1733 [ + + ]: 9115784 : while (*name=='/')
1734 : 3285197 : name++;
1735 [ + ]: 5830587 : if (!*name)
1736 : : return 0;
1737 : :
1738 : : /* At this point we know we have a real path component. */
1739 : : for(;;) {
1740 : : struct qstr this;
1741 : : long len;
1742 : : int type;
1743 : :
1744 : : err = may_lookup(nd);
1745 [ + + ]: 14388929 : if (err)
1746 : : break;
1747 : :
1748 : 14388905 : len = hash_name(name, &this.hash);
1749 : 14388905 : this.name = name;
1750 : 14388905 : this.len = len;
1751 : :
1752 : : type = LAST_NORM;
1753 [ + + ][ + + ]: 14388905 : if (name[0] == '.') switch (len) {
1754 : : case 2:
1755 [ + - ]: 3314 : if (name[1] == '.') {
1756 : : type = LAST_DOTDOT;
1757 : 1692576 : nd->flags |= LOOKUP_JUMPED;
1758 : : }
1759 : : break;
1760 : : case 1:
1761 : : type = LAST_DOT;
1762 : : }
1763 [ + + ]: 14388905 : if (likely(type == LAST_NORM)) {
1764 : 12732221 : struct dentry *parent = nd->path.dentry;
1765 : 12732221 : nd->flags &= ~LOOKUP_JUMPED;
1766 [ - + ]: 12732221 : if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1767 : 0 : err = parent->d_op->d_hash(parent, &this);
1768 [ # # ]: 0 : if (err < 0)
1769 : : break;
1770 : : }
1771 : : }
1772 : :
1773 : 14395948 : nd->last = this;
1774 : 14395948 : nd->last_type = type;
1775 : :
1776 [ + + ]: 14395948 : if (!name[len])
1777 : 5854069 : return 0;
1778 : : /*
1779 : : * If it wasn't NUL, we know it was '/'. Skip that
1780 : : * slash, and continue until no more slashes.
1781 : : */
1782 : : do {
1783 : 8626811 : len++;
1784 [ + + ]: 8626811 : } while (unlikely(name[len] == '/'));
1785 [ + + ]: 8626761 : if (!name[len])
1786 : : return 0;
1787 : :
1788 : : name += len;
1789 : :
1790 : : err = walk_component(nd, &next, LOOKUP_FOLLOW);
1791 [ + + ]: 8614904 : if (err < 0)
1792 : : return err;
1793 : :
1794 [ + + ]: 8540067 : if (err) {
1795 : : err = nested_symlink(&next, nd);
1796 [ + + ]: 8245 : if (err)
1797 : : return err;
1798 : : }
1799 [ + + ]: 8537609 : if (!d_is_directory(nd->path.dentry)) {
1800 : : err = -ENOTDIR;
1801 : : break;
1802 : : }
1803 : 8537560 : }
1804 : 0 : terminate_walk(nd);
1805 : 73 : return err;
1806 : : }
1807 : :
1808 : 0 : static int path_init(int dfd, const char *name, unsigned int flags,
1809 : : struct nameidata *nd, struct file **fp)
1810 : : {
1811 : : int retval = 0;
1812 : :
1813 : 5713020 : nd->last_type = LAST_ROOT; /* if there are only slashes... */
1814 : 5713020 : nd->flags = flags | LOOKUP_JUMPED;
1815 : 5713020 : nd->depth = 0;
1816 [ - + ]: 5713020 : if (flags & LOOKUP_ROOT) {
1817 : 0 : struct dentry *root = nd->root.dentry;
1818 : 0 : struct inode *inode = root->d_inode;
1819 [ # # ]: 0 : if (*name) {
1820 [ # # ]: 0 : if (!d_is_directory(root))
1821 : : return -ENOTDIR;
1822 : 0 : retval = inode_permission(inode, MAY_EXEC);
1823 [ # # ]: 0 : if (retval)
1824 : : return retval;
1825 : : }
1826 : 0 : nd->path = nd->root;
1827 : 0 : nd->inode = inode;
1828 [ # # ]: 0 : if (flags & LOOKUP_RCU) {
1829 : : rcu_read_lock();
1830 : 0 : nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1831 : 0 : nd->m_seq = read_seqbegin(&mount_lock);
1832 : : } else {
1833 : 0 : path_get(&nd->path);
1834 : : }
1835 : : return 0;
1836 : : }
1837 : :
1838 : 5713020 : nd->root.mnt = NULL;
1839 : :
1840 : 5702860 : nd->m_seq = read_seqbegin(&mount_lock);
1841 [ + + ]: 5702860 : if (*name=='/') {
1842 [ + + ]: 3255500 : if (flags & LOOKUP_RCU) {
1843 : : rcu_read_lock();
1844 : : set_root_rcu(nd);
1845 : : } else {
1846 : : set_root(nd);
1847 : 5 : path_get(&nd->root);
1848 : : }
1849 : 3255512 : nd->path = nd->root;
1850 [ + + ]: 2447360 : } else if (dfd == AT_FDCWD) {
1851 [ + + ]: 2418816 : if (flags & LOOKUP_RCU) {
1852 : 2417978 : struct fs_struct *fs = current->fs;
1853 : : unsigned seq;
1854 : :
1855 : : rcu_read_lock();
1856 : :
1857 : : do {
1858 : : seq = read_seqcount_begin(&fs->seq);
1859 : 2424662 : nd->path = fs->pwd;
1860 : 2424662 : nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1861 [ + + ]: 2430401 : } while (read_seqcount_retry(&fs->seq, seq));
1862 : : } else {
1863 : 838 : get_fs_pwd(current->fs, &nd->path);
1864 : : }
1865 : : } else {
1866 : : /* Caller must check execute permissions on the starting path component */
1867 : 28544 : struct fd f = fdget_raw(dfd);
1868 : : struct dentry *dentry;
1869 : :
1870 [ + ]: 28574 : if (!f.file)
1871 : : return -EBADF;
1872 : :
1873 : 28573 : dentry = f.file->f_path.dentry;
1874 : :
1875 [ + + ]: 5741593 : if (*name) {
1876 [ + + ]: 28570 : if (!d_is_directory(dentry)) {
1877 : : fdput(f);
1878 : : return -ENOTDIR;
1879 : : }
1880 : : }
1881 : :
1882 : 28558 : nd->path = f.file->f_path;
1883 [ + + ]: 28558 : if (flags & LOOKUP_RCU) {
1884 [ - + ]: 28500 : if (f.flags & FDPUT_FPUT)
1885 : 0 : *fp = f.file;
1886 : 28500 : nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1887 : : rcu_read_lock();
1888 : : } else {
1889 : 58 : path_get(&nd->path);
1890 : : fdput(f);
1891 : : }
1892 : : }
1893 : :
1894 : 5692629 : nd->inode = nd->path.dentry->d_inode;
1895 : 5692629 : return 0;
1896 : : }
1897 : :
1898 : : static inline int lookup_last(struct nameidata *nd, struct path *path)
1899 : : {
1900 [ + ][ + + ]: 933925 : if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
[ + + ][ + + ]
1901 : 7007 : nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1902 : :
1903 : 933925 : nd->flags &= ~LOOKUP_PARENT;
1904 : 933925 : return walk_component(nd, path, nd->flags & LOOKUP_FOLLOW);
1905 : : }
1906 : :
1907 : : /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1908 : 0 : static int path_lookupat(int dfd, const char *name,
1909 : : unsigned int flags, struct nameidata *nd)
1910 : : {
1911 : 2621023 : struct file *base = NULL;
1912 : : struct path path;
1913 : : int err;
1914 : :
1915 : : /*
1916 : : * Path walking is largely split up into 2 different synchronisation
1917 : : * schemes, rcu-walk and ref-walk (explained in
1918 : : * Documentation/filesystems/path-lookup.txt). These share much of the
1919 : : * path walk code, but some things particularly setup, cleanup, and
1920 : : * following mounts are sufficiently divergent that functions are
1921 : : * duplicated. Typically there is a function foo(), and its RCU
1922 : : * analogue, foo_rcu().
1923 : : *
1924 : : * -ECHILD is the error number of choice (just to avoid clashes) that
1925 : : * is returned if some aspect of an rcu-walk fails. Such an error must
1926 : : * be handled by restarting a traditional ref-walk (which will always
1927 : : * be able to complete).
1928 : : */
1929 : 2621023 : err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base);
1930 : :
1931 [ + ]: 2580298 : if (unlikely(err))
1932 : : return err;
1933 : :
1934 : 2596978 : current->total_link_count = 0;
1935 : 2596978 : err = link_path_walk(name, nd);
1936 : :
1937 [ + + ][ + + ]: 2631592 : if (!err && !(flags & LOOKUP_PARENT)) {
1938 : : err = lookup_last(nd, &path);
1939 [ + + ]: 915100 : while (err > 0) {
1940 : : void *cookie;
1941 : 6348 : struct path link = path;
1942 : : err = may_follow_link(&link, nd);
1943 [ + - ]: 6348 : if (unlikely(err))
1944 : : break;
1945 : 6348 : nd->flags |= LOOKUP_PARENT;
1946 : : err = follow_link(&link, nd, &cookie);
1947 [ + + ]: 6348 : if (err)
1948 : : break;
1949 : : err = lookup_last(nd, &path);
1950 : : put_link(nd, &link, cookie);
1951 : : }
1952 : : }
1953 : :
1954 [ + + ]: 2612767 : if (!err)
1955 : 2168405 : err = complete_walk(nd);
1956 : :
1957 [ + + ][ + + ]: 5253245 : if (!err && nd->flags & LOOKUP_DIRECTORY) {
1958 [ + + ]: 10723 : if (!d_is_directory(nd->path.dentry)) {
1959 : : path_put(&nd->path);
1960 : : err = -ENOTDIR;
1961 : : }
1962 : : }
1963 : :
1964 [ - + ]: 2632222 : if (base)
1965 : 0 : fput(base);
1966 : :
1967 [ + + ][ + - ]: 2632222 : if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
1968 : : path_put(&nd->root);
1969 : 78889 : nd->root.mnt = NULL;
1970 : : }
1971 : 2632222 : return err;
1972 : : }
1973 : :
1974 : 0 : static int filename_lookup(int dfd, struct filename *name,
1975 : : unsigned int flags, struct nameidata *nd)
1976 : : {
1977 : 2625440 : int retval = path_lookupat(dfd, name->name, flags | LOOKUP_RCU, nd);
1978 [ + + ]: 2627895 : if (unlikely(retval == -ECHILD))
1979 : 687 : retval = path_lookupat(dfd, name->name, flags, nd);
1980 [ - + ]: 2636844 : if (unlikely(retval == -ESTALE))
1981 : 0 : retval = path_lookupat(dfd, name->name,
1982 : : flags | LOOKUP_REVAL, nd);
1983 : :
1984 [ + + ]: 2636844 : if (likely(!retval))
1985 : 2160914 : audit_inode(name, nd->path.dentry, flags & LOOKUP_PARENT);
1986 : 11404 : return retval;
1987 : : }
1988 : :
1989 : : static int do_path_lookup(int dfd, const char *name,
1990 : : unsigned int flags, struct nameidata *nd)
1991 : : {
1992 : 585750 : struct filename filename = { .name = name };
1993 : :
1994 : 585750 : return filename_lookup(dfd, &filename, flags, nd);
1995 : : }
1996 : :
1997 : : /* does lookup, returns the object with parent locked */
1998 : 0 : struct dentry *kern_path_locked(const char *name, struct path *path)
1999 : : {
2000 : : struct nameidata nd;
2001 : : struct dentry *d;
2002 : : int err = do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, &nd);
2003 [ - + ]: 12 : if (err)
2004 : 0 : return ERR_PTR(err);
2005 [ - + ]: 12 : if (nd.last_type != LAST_NORM) {
2006 : : path_put(&nd.path);
2007 : 0 : return ERR_PTR(-EINVAL);
2008 : : }
2009 : 12 : mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2010 : 12 : d = __lookup_hash(&nd.last, nd.path.dentry, 0);
2011 [ - + ]: 24 : if (IS_ERR(d)) {
2012 : 0 : mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2013 : : path_put(&nd.path);
2014 : 0 : return d;
2015 : : }
2016 : 12 : *path = nd.path;
2017 : 12 : return d;
2018 : : }
2019 : :
2020 : 0 : int kern_path(const char *name, unsigned int flags, struct path *path)
2021 : : {
2022 : : struct nameidata nd;
2023 : : int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
2024 [ + + ]: 472907 : if (!res)
2025 : 211585 : *path = nd.path;
2026 : 15248 : return res;
2027 : : }
2028 : :
2029 : : /**
2030 : : * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
2031 : : * @dentry: pointer to dentry of the base directory
2032 : : * @mnt: pointer to vfs mount of the base directory
2033 : : * @name: pointer to file name
2034 : : * @flags: lookup flags
2035 : : * @path: pointer to struct path to fill
2036 : : */
2037 : 0 : int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
2038 : : const char *name, unsigned int flags,
2039 : : struct path *path)
2040 : : {
2041 : : struct nameidata nd;
2042 : : int err;
2043 : 0 : nd.root.dentry = dentry;
2044 : 0 : nd.root.mnt = mnt;
2045 [ # # ]: 0 : BUG_ON(flags & LOOKUP_PARENT);
2046 : : /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
2047 : 0 : err = do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, &nd);
2048 [ # # ]: 0 : if (!err)
2049 : 0 : *path = nd.path;
2050 : 0 : return err;
2051 : : }
2052 : :
2053 : : /*
2054 : : * Restricted form of lookup. Doesn't follow links, single-component only,
2055 : : * needs parent already locked. Doesn't follow mounts.
2056 : : * SMP-safe.
2057 : : */
2058 : 0 : static struct dentry *lookup_hash(struct nameidata *nd)
2059 : : {
2060 : 1225876 : return __lookup_hash(&nd->last, nd->path.dentry, nd->flags);
2061 : : }
2062 : :
2063 : : /**
2064 : : * lookup_one_len - filesystem helper to lookup single pathname component
2065 : : * @name: pathname component to lookup
2066 : : * @base: base directory to lookup from
2067 : : * @len: maximum length @len should be interpreted to
2068 : : *
2069 : : * Note that this routine is purely a helper for filesystem usage and should
2070 : : * not be called by generic code. Also note that by using this function the
2071 : : * nameidata argument is passed to the filesystem methods and a filesystem
2072 : : * using this helper needs to be prepared for that.
2073 : : */
2074 : 0 : struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
2075 : : {
2076 : : struct qstr this;
2077 : : unsigned int c;
2078 : : int err;
2079 : :
2080 [ - + ][ # # ]: 149 : WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
[ # # ]
2081 : :
2082 : 149 : this.name = name;
2083 : 149 : this.len = len;
2084 : 149 : this.hash = full_name_hash(name, len);
2085 [ + - ]: 149 : if (!len)
2086 : : return ERR_PTR(-EACCES);
2087 : :
2088 [ - + ]: 149 : if (unlikely(name[0] == '.')) {
2089 [ # # ][ # # ]: 0 : if (len < 2 || (len == 2 && name[1] == '.'))
[ # # ]
2090 : : return ERR_PTR(-EACCES);
2091 : : }
2092 : :
2093 [ + + ]: 2374 : while (len--) {
2094 : 2225 : c = *(const unsigned char *)name++;
2095 [ + - ]: 2374 : if (c == '/' || c == '\0')
2096 : : return ERR_PTR(-EACCES);
2097 : : }
2098 : : /*
2099 : : * See if the low-level filesystem might want
2100 : : * to use its own hash..
2101 : : */
2102 [ - + ]: 149 : if (base->d_flags & DCACHE_OP_HASH) {
2103 : 0 : int err = base->d_op->d_hash(base, &this);
2104 [ # # ]: 0 : if (err < 0)
2105 : 0 : return ERR_PTR(err);
2106 : : }
2107 : :
2108 : 149 : err = inode_permission(base->d_inode, MAY_EXEC);
2109 [ - + ]: 298 : if (err)
2110 : 0 : return ERR_PTR(err);
2111 : :
2112 : 149 : return __lookup_hash(&this, base, 0);
2113 : : }
2114 : :
2115 : 0 : int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
2116 : : struct path *path, int *empty)
2117 : : {
2118 : : struct nameidata nd;
2119 : 472093 : struct filename *tmp = getname_flags(name, flags, empty);
2120 : : int err = PTR_ERR(tmp);
2121 [ + + ]: 472147 : if (!IS_ERR(tmp)) {
2122 : :
2123 [ - + ]: 472064 : BUG_ON(flags & LOOKUP_PARENT);
2124 : :
2125 : 472064 : err = filename_lookup(dfd, tmp, flags, &nd);
2126 : 472029 : putname(tmp);
2127 [ + + ]: 472068 : if (!err)
2128 : 258546 : *path = nd.path;
2129 : : }
2130 : 58 : return err;
2131 : : }
2132 : :
2133 : 0 : int user_path_at(int dfd, const char __user *name, unsigned flags,
2134 : : struct path *path)
2135 : : {
2136 : 430501 : return user_path_at_empty(dfd, name, flags, path, NULL);
2137 : : }
2138 : :
2139 : : /*
2140 : : * NB: most callers don't do anything directly with the reference to the
2141 : : * to struct filename, but the nd->last pointer points into the name string
2142 : : * allocated by getname. So we must hold the reference to it until all
2143 : : * path-walking is complete.
2144 : : */
2145 : : static struct filename *
2146 : 0 : user_path_parent(int dfd, const char __user *path, struct nameidata *nd,
2147 : : unsigned int flags)
2148 : : {
2149 : : struct filename *s = getname(path);
2150 : : int error;
2151 : :
2152 : : /* only LOOKUP_REVAL is allowed in extra flags */
2153 : 1572466 : flags &= LOOKUP_REVAL;
2154 : :
2155 [ + + ]: 1572466 : if (IS_ERR(s))
2156 : : return s;
2157 : :
2158 : 1572423 : error = filename_lookup(dfd, s, flags | LOOKUP_PARENT, nd);
2159 [ + + ]: 1572828 : if (error) {
2160 : 17 : putname(s);
2161 : 17 : return ERR_PTR(error);
2162 : : }
2163 : :
2164 : : return s;
2165 : : }
2166 : :
2167 : : /**
2168 : : * mountpoint_last - look up last component for umount
2169 : : * @nd: pathwalk nameidata - currently pointing at parent directory of "last"
2170 : : * @path: pointer to container for result
2171 : : *
2172 : : * This is a special lookup_last function just for umount. In this case, we
2173 : : * need to resolve the path without doing any revalidation.
2174 : : *
2175 : : * The nameidata should be the result of doing a LOOKUP_PARENT pathwalk. Since
2176 : : * mountpoints are always pinned in the dcache, their ancestors are too. Thus,
2177 : : * in almost all cases, this lookup will be served out of the dcache. The only
2178 : : * cases where it won't are if nd->last refers to a symlink or the path is
2179 : : * bogus and it doesn't exist.
2180 : : *
2181 : : * Returns:
2182 : : * -error: if there was an error during lookup. This includes -ENOENT if the
2183 : : * lookup found a negative dentry. The nd->path reference will also be
2184 : : * put in this case.
2185 : : *
2186 : : * 0: if we successfully resolved nd->path and found it to not to be a
2187 : : * symlink that needs to be followed. "path" will also be populated.
2188 : : * The nd->path reference will also be put.
2189 : : *
2190 : : * 1: if we successfully resolved nd->last and found it to be a symlink
2191 : : * that needs to be followed. "path" will be populated with the path
2192 : : * to the link, and nd->path will *not* be put.
2193 : : */
2194 : : static int
2195 : 0 : mountpoint_last(struct nameidata *nd, struct path *path)
2196 : : {
2197 : : int error = 0;
2198 : : struct dentry *dentry;
2199 : 3068 : struct dentry *dir = nd->path.dentry;
2200 : :
2201 : : /* If we're in rcuwalk, drop out of it to handle last component */
2202 [ + + ]: 3068 : if (nd->flags & LOOKUP_RCU) {
2203 [ + - ]: 3030 : if (unlazy_walk(nd, NULL)) {
2204 : : error = -ECHILD;
2205 : : goto out;
2206 : : }
2207 : : }
2208 : :
2209 : 3068 : nd->flags &= ~LOOKUP_PARENT;
2210 : :
2211 [ - + ]: 3068 : if (unlikely(nd->last_type != LAST_NORM)) {
2212 : : error = handle_dots(nd, nd->last_type);
2213 [ # # ]: 0 : if (error)
2214 : : goto out;
2215 : 0 : dentry = dget(nd->path.dentry);
2216 : 0 : goto done;
2217 : : }
2218 : :
2219 : 3068 : mutex_lock(&dir->d_inode->i_mutex);
2220 : 3068 : dentry = d_lookup(dir, &nd->last);
2221 [ + + ]: 3068 : if (!dentry) {
2222 : : /*
2223 : : * No cached dentry. Mounted dentries are pinned in the cache,
2224 : : * so that means that this dentry is probably a symlink or the
2225 : : * path doesn't actually point to a mounted dentry.
2226 : : */
2227 : 1 : dentry = d_alloc(dir, &nd->last);
2228 [ - + ]: 1 : if (!dentry) {
2229 : : error = -ENOMEM;
2230 : 0 : mutex_unlock(&dir->d_inode->i_mutex);
2231 : 0 : goto out;
2232 : : }
2233 : 1 : dentry = lookup_real(dir->d_inode, dentry, nd->flags);
2234 : : error = PTR_ERR(dentry);
2235 [ - + ]: 1 : if (IS_ERR(dentry)) {
2236 : 0 : mutex_unlock(&dir->d_inode->i_mutex);
2237 : 0 : goto out;
2238 : : }
2239 : : }
2240 : 3068 : mutex_unlock(&dir->d_inode->i_mutex);
2241 : :
2242 : : done:
2243 [ + + ]: 3068 : if (!dentry->d_inode) {
2244 : : error = -ENOENT;
2245 : 1 : dput(dentry);
2246 : 1 : goto out;
2247 : : }
2248 : 3067 : path->dentry = dentry;
2249 : 3067 : path->mnt = mntget(nd->path.mnt);
2250 [ + - ]: 3067 : if (should_follow_link(dentry, nd->flags & LOOKUP_FOLLOW))
2251 : : return 1;
2252 : 3067 : follow_mount(path);
2253 : : error = 0;
2254 : : out:
2255 : 3068 : terminate_walk(nd);
2256 : 3068 : return error;
2257 : : }
2258 : :
2259 : : /**
2260 : : * path_mountpoint - look up a path to be umounted
2261 : : * @dfd: directory file descriptor to start walk from
2262 : : * @name: full pathname to walk
2263 : : * @path: pointer to container for result
2264 : : * @flags: lookup flags
2265 : : *
2266 : : * Look up the given name, but don't attempt to revalidate the last component.
2267 : : * Returns 0 and "path" will be valid on success; Returns error otherwise.
2268 : : */
2269 : : static int
2270 : 0 : path_mountpoint(int dfd, const char *name, struct path *path, unsigned int flags)
2271 : : {
2272 : 3070 : struct file *base = NULL;
2273 : : struct nameidata nd;
2274 : : int err;
2275 : :
2276 : 3070 : err = path_init(dfd, name, flags | LOOKUP_PARENT, &nd, &base);
2277 [ + - ]: 3070 : if (unlikely(err))
2278 : : return err;
2279 : :
2280 : 3070 : current->total_link_count = 0;
2281 : 3070 : err = link_path_walk(name, &nd);
2282 [ + + ]: 3070 : if (err)
2283 : : goto out;
2284 : :
2285 : 3068 : err = mountpoint_last(&nd, path);
2286 [ - + ]: 3068 : while (err > 0) {
2287 : : void *cookie;
2288 : 0 : struct path link = *path;
2289 : : err = may_follow_link(&link, &nd);
2290 [ # # ]: 0 : if (unlikely(err))
2291 : : break;
2292 : 0 : nd.flags |= LOOKUP_PARENT;
2293 : : err = follow_link(&link, &nd, &cookie);
2294 [ # # ]: 0 : if (err)
2295 : : break;
2296 : 0 : err = mountpoint_last(&nd, path);
2297 : : put_link(&nd, &link, cookie);
2298 : : }
2299 : : out:
2300 [ - + ]: 3070 : if (base)
2301 : 0 : fput(base);
2302 : :
2303 [ + + ][ + - ]: 6140 : if (nd.root.mnt && !(nd.flags & LOOKUP_ROOT))
2304 : : path_put(&nd.root);
2305 : :
2306 : 3070 : return err;
2307 : : }
2308 : :
2309 : : static int
2310 : 0 : filename_mountpoint(int dfd, struct filename *s, struct path *path,
2311 : : unsigned int flags)
2312 : : {
2313 : 3070 : int error = path_mountpoint(dfd, s->name, path, flags | LOOKUP_RCU);
2314 [ - + ]: 3070 : if (unlikely(error == -ECHILD))
2315 : 0 : error = path_mountpoint(dfd, s->name, path, flags);
2316 [ - + ]: 3070 : if (unlikely(error == -ESTALE))
2317 : 0 : error = path_mountpoint(dfd, s->name, path, flags | LOOKUP_REVAL);
2318 [ + + ]: 3070 : if (likely(!error))
2319 : 3067 : audit_inode(s, path->dentry, 0);
2320 : 0 : return error;
2321 : : }
2322 : :
2323 : : /**
2324 : : * user_path_mountpoint_at - lookup a path from userland in order to umount it
2325 : : * @dfd: directory file descriptor
2326 : : * @name: pathname from userland
2327 : : * @flags: lookup flags
2328 : : * @path: pointer to container to hold result
2329 : : *
2330 : : * A umount is a special case for path walking. We're not actually interested
2331 : : * in the inode in this situation, and ESTALE errors can be a problem. We
2332 : : * simply want track down the dentry and vfsmount attached at the mountpoint
2333 : : * and avoid revalidating the last component.
2334 : : *
2335 : : * Returns 0 and populates "path" on success.
2336 : : */
2337 : : int
2338 : 0 : user_path_mountpoint_at(int dfd, const char __user *name, unsigned int flags,
2339 : : struct path *path)
2340 : : {
2341 : : struct filename *s = getname(name);
2342 : : int error;
2343 [ + + ]: 6144 : if (IS_ERR(s))
2344 : 2 : return PTR_ERR(s);
2345 : 3070 : error = filename_mountpoint(dfd, s, path, flags);
2346 : 3070 : putname(s);
2347 : 3070 : return error;
2348 : : }
2349 : :
2350 : : int
2351 : 0 : kern_path_mountpoint(int dfd, const char *name, struct path *path,
2352 : : unsigned int flags)
2353 : : {
2354 : 0 : struct filename s = {.name = name};
2355 : 0 : return filename_mountpoint(dfd, &s, path, flags);
2356 : : }
2357 : : EXPORT_SYMBOL(kern_path_mountpoint);
2358 : :
2359 : : /*
2360 : : * It's inline, so penalty for filesystems that don't use sticky bit is
2361 : : * minimal.
2362 : : */
2363 : : static inline int check_sticky(struct inode *dir, struct inode *inode)
2364 : : {
2365 : 431168 : kuid_t fsuid = current_fsuid();
2366 : :
2367 [ + + ]: 431168 : if (!(dir->i_mode & S_ISVTX))
2368 : : return 0;
2369 [ + + ]: 373 : if (uid_eq(inode->i_uid, fsuid))
2370 : : return 0;
2371 [ + + ]: 95 : if (uid_eq(dir->i_uid, fsuid))
2372 : : return 0;
2373 : 49 : return !inode_capable(inode, CAP_FOWNER);
2374 : : }
2375 : :
2376 : : /*
2377 : : * Check whether we can remove a link victim from directory dir, check
2378 : : * whether the type of victim is right.
2379 : : * 1. We can't do it if dir is read-only (done in permission())
2380 : : * 2. We should have write and exec permissions on dir
2381 : : * 3. We can't remove anything from append-only dir
2382 : : * 4. We can't do anything with immutable dir (done in permission())
2383 : : * 5. If the sticky bit on dir is set we should either
2384 : : * a. be owner of dir, or
2385 : : * b. be owner of victim, or
2386 : : * c. have CAP_FOWNER capability
2387 : : * 6. If the victim is append-only or immutable we can't do antyhing with
2388 : : * links pointing to it.
2389 : : * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
2390 : : * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
2391 : : * 9. We can't remove a root or mountpoint.
2392 : : * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
2393 : : * nfs_async_unlink().
2394 : : */
2395 : 0 : static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
2396 : : {
2397 : 431176 : struct inode *inode = victim->d_inode;
2398 : : int error;
2399 : :
2400 [ + + ]: 431176 : if (d_is_negative(victim))
2401 : : return -ENOENT;
2402 [ - + ]: 431174 : BUG_ON(!inode);
2403 : :
2404 [ - + ]: 431174 : BUG_ON(victim->d_parent->d_inode != dir);
2405 : : audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
2406 : :
2407 : 431174 : error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
2408 [ + + ]: 431183 : if (error)
2409 : : return error;
2410 [ + ]: 431163 : if (IS_APPEND(dir))
2411 : : return -EPERM;
2412 : :
2413 [ + + ]: 431168 : if (check_sticky(dir, inode) || IS_APPEND(inode) ||
2414 [ + + ]: 431164 : IS_IMMUTABLE(inode) || IS_SWAPFILE(inode))
2415 : : return -EPERM;
2416 [ + + ]: 431161 : if (isdir) {
2417 [ + + ][ + ]: 35515 : if (!d_is_directory(victim) && !d_is_autodir(victim))
2418 : : return -ENOTDIR;
2419 [ + - ]: 35380 : if (IS_ROOT(victim))
2420 : : return -EBUSY;
2421 [ + + ][ + - ]: 395646 : } else if (d_is_directory(victim) || d_is_autodir(victim))
2422 : : return -EISDIR;
2423 [ + - ]: 430181 : if (IS_DEADDIR(dir))
2424 : : return -ENOENT;
2425 [ + + ]: 430181 : if (victim->d_flags & DCACHE_NFSFS_RENAMED)
2426 : : return -EBUSY;
2427 : 430170 : return 0;
2428 : : }
2429 : :
2430 : : /* Check whether we can create an object with dentry child in directory
2431 : : * dir.
2432 : : * 1. We can't do it if child already exists (open has special treatment for
2433 : : * this case, but since we are inlined it's OK)
2434 : : * 2. We can't do it if dir is read-only (done in permission())
2435 : : * 3. We should have write and exec permissions on dir
2436 : : * 4. We can't do it if dir is immutable (done in permission())
2437 : : */
2438 : : static inline int may_create(struct inode *dir, struct dentry *child)
2439 : : {
2440 : : audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
2441 [ + - ][ + - ]: 277944 : if (child->d_inode)
[ + - ][ + + ]
[ + - ][ + - ]
2442 : : return -EEXIST;
2443 [ + - ][ + - ]: 277841 : if (IS_DEADDIR(dir))
[ + - ][ + ]
[ + - ][ + + ]
2444 : : return -ENOENT;
2445 : 277909 : return inode_permission(dir, MAY_WRITE | MAY_EXEC);
2446 : : }
2447 : :
2448 : : /*
2449 : : * p1 and p2 should be directories on the same fs.
2450 : : */
2451 : 0 : struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
2452 : : {
2453 : : struct dentry *p;
2454 : :
2455 [ + + ]: 628009 : if (p1 == p2) {
2456 : 627973 : mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2457 : 627973 : return NULL;
2458 : : }
2459 : :
2460 : 36 : mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
2461 : :
2462 : 36 : p = d_ancestor(p2, p1);
2463 [ + + ]: 36 : if (p) {
2464 : 35 : mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
2465 : 35 : mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
2466 : 35 : return p;
2467 : : }
2468 : :
2469 : 1 : p = d_ancestor(p1, p2);
2470 [ - + ]: 1 : if (p) {
2471 : 0 : mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2472 : 0 : mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
2473 : 0 : return p;
2474 : : }
2475 : :
2476 : 1 : mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2477 : 1 : mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
2478 : 1 : return NULL;
2479 : : }
2480 : :
2481 : 0 : void unlock_rename(struct dentry *p1, struct dentry *p2)
2482 : : {
2483 : 628009 : mutex_unlock(&p1->d_inode->i_mutex);
2484 [ + + ]: 628009 : if (p1 != p2) {
2485 : 36 : mutex_unlock(&p2->d_inode->i_mutex);
2486 : 36 : mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
2487 : : }
2488 : 0 : }
2489 : :
2490 : 0 : int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2491 : : bool want_excl)
2492 : : {
2493 : : int error = may_create(dir, dentry);
2494 [ + - ]: 186008 : if (error)
2495 : : return error;
2496 : :
2497 [ + ]: 186008 : if (!dir->i_op->create)
2498 : : return -EACCES; /* shouldn't it be ENOSYS? */
2499 : 186019 : mode &= S_IALLUGO;
2500 : 186019 : mode |= S_IFREG;
2501 : 186019 : error = security_inode_create(dir, dentry, mode);
2502 [ + ]: 185982 : if (error)
2503 : : return error;
2504 : 185999 : error = dir->i_op->create(dir, dentry, mode, want_excl);
2505 [ + + ]: 185956 : if (!error)
2506 : : fsnotify_create(dir, dentry);
2507 : 185947 : return error;
2508 : : }
2509 : :
2510 : 0 : static int may_open(struct path *path, int acc_mode, int flag)
2511 : : {
2512 : 2463467 : struct dentry *dentry = path->dentry;
2513 : 2463467 : struct inode *inode = dentry->d_inode;
2514 : : int error;
2515 : :
2516 : : /* O_PATH? */
2517 [ + ]: 2463467 : if (!acc_mode)
2518 : : return 0;
2519 : :
2520 [ + ]: 2463719 : if (!inode)
2521 : : return -ENOENT;
2522 : :
2523 [ + + + + : 2463746 : switch (inode->i_mode & S_IFMT) {
- ]
2524 : : case S_IFLNK:
2525 : : return -ELOOP;
2526 : : case S_IFDIR:
2527 [ + + ]: 35417 : if (acc_mode & MAY_WRITE)
2528 : : return -EISDIR;
2529 : : break;
2530 : : case S_IFBLK:
2531 : : case S_IFCHR:
2532 [ + + ]: 17181 : if (path->mnt->mnt_flags & MNT_NODEV)
2533 : : return -EACCES;
2534 : : /*FALLTHRU*/
2535 : : case S_IFIFO:
2536 : : case S_IFSOCK:
2537 : 357658 : flag &= ~O_TRUNC;
2538 : 357658 : break;
2539 : : }
2540 : :
2541 : 2463742 : error = inode_permission(inode, acc_mode);
2542 [ + + ]: 2463662 : if (error)
2543 : : return error;
2544 : :
2545 : : /*
2546 : : * An append-only file must be opened in append mode for writing.
2547 : : */
2548 [ + + ]: 2463600 : if (IS_APPEND(inode)) {
2549 [ + + ][ + ]: 108 : if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
2550 : : return -EPERM;
2551 [ + - ]: 165 : if (flag & O_TRUNC)
2552 : : return -EPERM;
2553 : : }
2554 : :
2555 : : /* O_NOATIME can only be set by the owner or superuser */
2556 [ - + ][ # # ]: 2463657 : if (flag & O_NOATIME && !inode_owner_or_capable(inode))
2557 : : return -EPERM;
2558 : :
2559 : : return 0;
2560 : : }
2561 : :
2562 : 0 : static int handle_truncate(struct file *filp)
2563 : : {
2564 : 3513 : struct path *path = &filp->f_path;
2565 : 3513 : struct inode *inode = path->dentry->d_inode;
2566 : : int error = get_write_access(inode);
2567 [ + - ]: 3513 : if (error)
2568 : : return error;
2569 : : /*
2570 : : * Refuse to truncate files with mandatory locks held on them.
2571 : : */
2572 : : error = locks_verify_locked(inode);
2573 [ + - ]: 3513 : if (!error)
2574 : 3513 : error = security_path_truncate(path);
2575 [ + - ]: 3513 : if (!error) {
2576 : 3513 : error = do_truncate(path->dentry, 0,
2577 : : ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
2578 : : filp);
2579 : : }
2580 : : put_write_access(inode);
2581 : 3513 : return error;
2582 : : }
2583 : :
2584 : : static inline int open_to_namei_flags(int flag)
2585 : : {
2586 [ # # ]: 0 : if ((flag & O_ACCMODE) == 3)
2587 : 0 : flag--;
2588 : : return flag;
2589 : : }
2590 : :
2591 : 0 : static int may_o_create(struct path *dir, struct dentry *dentry, umode_t mode)
2592 : : {
2593 : 0 : int error = security_path_mknod(dir, dentry, mode, 0);
2594 [ # # ]: 0 : if (error)
2595 : : return error;
2596 : :
2597 : 0 : error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
2598 [ # # ]: 0 : if (error)
2599 : : return error;
2600 : :
2601 : 0 : return security_inode_create(dir->dentry->d_inode, dentry, mode);
2602 : : }
2603 : :
2604 : : /*
2605 : : * Attempt to atomically look up, create and open a file from a negative
2606 : : * dentry.
2607 : : *
2608 : : * Returns 0 if successful. The file will have been created and attached to
2609 : : * @file by the filesystem calling finish_open().
2610 : : *
2611 : : * Returns 1 if the file was looked up only or didn't need creating. The
2612 : : * caller will need to perform the open themselves. @path will have been
2613 : : * updated to point to the new dentry. This may be negative.
2614 : : *
2615 : : * Returns an error code otherwise.
2616 : : */
2617 : 0 : static int atomic_open(struct nameidata *nd, struct dentry *dentry,
2618 : : struct path *path, struct file *file,
2619 : : const struct open_flags *op,
2620 : : bool got_write, bool need_lookup,
2621 : : int *opened)
2622 : : {
2623 : 0 : struct inode *dir = nd->path.dentry->d_inode;
2624 : 0 : unsigned open_flag = open_to_namei_flags(op->open_flag);
2625 : : umode_t mode;
2626 : : int error;
2627 : : int acc_mode;
2628 : : int create_error = 0;
2629 : : struct dentry *const DENTRY_NOT_SET = (void *) -1UL;
2630 : : bool excl;
2631 : :
2632 [ # # ]: 0 : BUG_ON(dentry->d_inode);
2633 : :
2634 : : /* Don't create child dentry for a dead directory. */
2635 [ # # ]: 0 : if (unlikely(IS_DEADDIR(dir))) {
2636 : : error = -ENOENT;
2637 : : goto out;
2638 : : }
2639 : :
2640 : 0 : mode = op->mode;
2641 [ # # ][ # # ]: 0 : if ((open_flag & O_CREAT) && !IS_POSIXACL(dir))
2642 : 0 : mode &= ~current_umask();
2643 : :
2644 : 0 : excl = (open_flag & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT);
2645 [ # # ]: 0 : if (excl)
2646 : 0 : open_flag &= ~O_TRUNC;
2647 : :
2648 : : /*
2649 : : * Checking write permission is tricky, bacuse we don't know if we are
2650 : : * going to actually need it: O_CREAT opens should work as long as the
2651 : : * file exists. But checking existence breaks atomicity. The trick is
2652 : : * to check access and if not granted clear O_CREAT from the flags.
2653 : : *
2654 : : * Another problem is returing the "right" error value (e.g. for an
2655 : : * O_EXCL open we want to return EEXIST not EROFS).
2656 : : */
2657 [ # # ]: 0 : if (((open_flag & (O_CREAT | O_TRUNC)) ||
2658 [ # # ]: 0 : (open_flag & O_ACCMODE) != O_RDONLY) && unlikely(!got_write)) {
2659 [ # # ]: 0 : if (!(open_flag & O_CREAT)) {
2660 : : /*
2661 : : * No O_CREATE -> atomicity not a requirement -> fall
2662 : : * back to lookup + open
2663 : : */
2664 : : goto no_open;
2665 [ # # ]: 0 : } else if (open_flag & (O_EXCL | O_TRUNC)) {
2666 : : /* Fall back and fail with the right error */
2667 : : create_error = -EROFS;
2668 : : goto no_open;
2669 : : } else {
2670 : : /* No side effects, safe to clear O_CREAT */
2671 : : create_error = -EROFS;
2672 : 0 : open_flag &= ~O_CREAT;
2673 : : }
2674 : : }
2675 : :
2676 [ # # ]: 0 : if (open_flag & O_CREAT) {
2677 : 0 : error = may_o_create(&nd->path, dentry, mode);
2678 [ # # ]: 0 : if (error) {
2679 : : create_error = error;
2680 [ # # ]: 0 : if (open_flag & O_EXCL)
2681 : : goto no_open;
2682 : 0 : open_flag &= ~O_CREAT;
2683 : : }
2684 : : }
2685 : :
2686 [ # # ]: 0 : if (nd->flags & LOOKUP_DIRECTORY)
2687 : 0 : open_flag |= O_DIRECTORY;
2688 : :
2689 : 0 : file->f_path.dentry = DENTRY_NOT_SET;
2690 : 0 : file->f_path.mnt = nd->path.mnt;
2691 : 0 : error = dir->i_op->atomic_open(dir, dentry, file, open_flag, mode,
2692 : : opened);
2693 [ # # ]: 0 : if (error < 0) {
2694 [ # # ]: 0 : if (create_error && error == -ENOENT)
2695 : : error = create_error;
2696 : : goto out;
2697 : : }
2698 : :
2699 [ # # ]: 0 : if (error) { /* returned 1, that is */
2700 [ # # ][ # # ]: 0 : if (WARN_ON(file->f_path.dentry == DENTRY_NOT_SET)) {
2701 : : error = -EIO;
2702 : : goto out;
2703 : : }
2704 [ # # ]: 0 : if (file->f_path.dentry) {
2705 : 0 : dput(dentry);
2706 : 0 : dentry = file->f_path.dentry;
2707 : : }
2708 [ # # ]: 0 : if (*opened & FILE_CREATED)
2709 : : fsnotify_create(dir, dentry);
2710 [ # # ]: 0 : if (!dentry->d_inode) {
2711 [ # # ]: 0 : WARN_ON(*opened & FILE_CREATED);
2712 [ # # ]: 0 : if (create_error) {
2713 : : error = create_error;
2714 : : goto out;
2715 : : }
2716 : : } else {
2717 [ # # ][ # # ]: 0 : if (excl && !(*opened & FILE_CREATED)) {
2718 : : error = -EEXIST;
2719 : : goto out;
2720 : : }
2721 : : }
2722 : : goto looked_up;
2723 : : }
2724 : :
2725 : : /*
2726 : : * We didn't have the inode before the open, so check open permission
2727 : : * here.
2728 : : */
2729 : 0 : acc_mode = op->acc_mode;
2730 [ # # ]: 0 : if (*opened & FILE_CREATED) {
2731 [ # # ]: 0 : WARN_ON(!(open_flag & O_CREAT));
2732 : : fsnotify_create(dir, dentry);
2733 : : acc_mode = MAY_OPEN;
2734 : : }
2735 : 0 : error = may_open(&file->f_path, acc_mode, open_flag);
2736 [ # # ]: 0 : if (error)
2737 : 0 : fput(file);
2738 : :
2739 : : out:
2740 : 0 : dput(dentry);
2741 : 0 : return error;
2742 : :
2743 : : no_open:
2744 [ # # ]: 0 : if (need_lookup) {
2745 : 0 : dentry = lookup_real(dir, dentry, nd->flags);
2746 [ # # ]: 0 : if (IS_ERR(dentry))
2747 : 0 : return PTR_ERR(dentry);
2748 : :
2749 [ # # ]: 0 : if (create_error) {
2750 : 0 : int open_flag = op->open_flag;
2751 : :
2752 : : error = create_error;
2753 [ # # ]: 0 : if ((open_flag & O_EXCL)) {
2754 [ # # ]: 0 : if (!dentry->d_inode)
2755 : : goto out;
2756 [ # # ]: 0 : } else if (!dentry->d_inode) {
2757 : : goto out;
2758 [ # # ][ # # ]: 0 : } else if ((open_flag & O_TRUNC) &&
2759 : 0 : S_ISREG(dentry->d_inode->i_mode)) {
2760 : : goto out;
2761 : : }
2762 : : /* will fail later, go on to get the right error */
2763 : : }
2764 : : }
2765 : : looked_up:
2766 : 0 : path->dentry = dentry;
2767 : 0 : path->mnt = nd->path.mnt;
2768 : 0 : return 1;
2769 : : }
2770 : :
2771 : : /*
2772 : : * Look up and maybe create and open the last component.
2773 : : *
2774 : : * Must be called with i_mutex held on parent.
2775 : : *
2776 : : * Returns 0 if the file was successfully atomically created (if necessary) and
2777 : : * opened. In this case the file will be returned attached to @file.
2778 : : *
2779 : : * Returns 1 if the file was not completely opened at this time, though lookups
2780 : : * and creations will have been performed and the dentry returned in @path will
2781 : : * be positive upon return if O_CREAT was specified. If O_CREAT wasn't
2782 : : * specified then a negative dentry may be returned.
2783 : : *
2784 : : * An error code is returned otherwise.
2785 : : *
2786 : : * FILE_CREATE will be set in @*opened if the dentry was created and will be
2787 : : * cleared otherwise prior to returning.
2788 : : */
2789 : 0 : static int lookup_open(struct nameidata *nd, struct path *path,
2790 : : struct file *file,
2791 : : const struct open_flags *op,
2792 : : bool got_write, int *opened)
2793 : : {
2794 : 2361546 : struct dentry *dir = nd->path.dentry;
2795 : 2361546 : struct inode *dir_inode = dir->d_inode;
2796 : : struct dentry *dentry;
2797 : : int error;
2798 : : bool need_lookup;
2799 : :
2800 : 2361546 : *opened &= ~FILE_CREATED;
2801 : 2361546 : dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup);
2802 [ - + ]: 2361720 : if (IS_ERR(dentry))
2803 : 0 : return PTR_ERR(dentry);
2804 : :
2805 : : /* Cached positive dentry: will open in f_op->open */
2806 [ + + ][ + ]: 2361720 : if (!need_lookup && dentry->d_inode)
2807 : : goto out_no_open;
2808 : :
2809 [ + ][ - + ]: 3105572 : if ((nd->flags & LOOKUP_OPEN) && dir_inode->i_op->atomic_open) {
2810 : 0 : return atomic_open(nd, dentry, path, file, op, got_write,
2811 : : need_lookup, opened);
2812 : : }
2813 : :
2814 [ + + ]: 744026 : if (need_lookup) {
2815 [ - + ]: 577031 : BUG_ON(dentry->d_inode);
2816 : :
2817 : 577031 : dentry = lookup_real(dir_inode, dentry, nd->flags);
2818 [ + + ]: 577183 : if (IS_ERR(dentry))
2819 : 54 : return PTR_ERR(dentry);
2820 : : }
2821 : :
2822 : : /* Negative dentry, just create the file */
2823 [ + + ][ + + ]: 744124 : if (!dentry->d_inode && (op->open_flag & O_CREAT)) {
2824 : 185935 : umode_t mode = op->mode;
2825 [ + + ]: 185935 : if (!IS_POSIXACL(dir->d_inode))
2826 : 185493 : mode &= ~current_umask();
2827 : : /*
2828 : : * This write is needed to ensure that a
2829 : : * rw->ro transition does not occur between
2830 : : * the time when the file is created and when
2831 : : * a permanent write count is taken through
2832 : : * the 'struct file' in finish_open().
2833 : : */
2834 [ + ]: 185878 : if (!got_write) {
2835 : : error = -EROFS;
2836 : : goto out_dput;
2837 : : }
2838 : 185951 : *opened |= FILE_CREATED;
2839 : 185951 : error = security_path_mknod(&nd->path, dentry, mode, 0);
2840 [ + ]: 185965 : if (error)
2841 : : goto out_dput;
2842 : 185972 : error = vfs_create(dir->d_inode, dentry, mode,
2843 : 185972 : nd->flags & LOOKUP_EXCL);
2844 [ + ]: 185937 : if (error)
2845 : : goto out_dput;
2846 : : }
2847 : : out_no_open:
2848 : 2361597 : path->dentry = dentry;
2849 : 2361597 : path->mnt = nd->path.mnt;
2850 : 2361597 : return 1;
2851 : :
2852 : : out_dput:
2853 : 0 : dput(dentry);
2854 : 2 : return error;
2855 : : }
2856 : :
2857 : : /*
2858 : : * Handle the last step of open()
2859 : : */
2860 : 0 : static int do_last(struct nameidata *nd, struct path *path,
2861 : 0 : struct file *file, const struct open_flags *op,
2862 : : int *opened, struct filename *name)
2863 : : {
2864 : 3160147 : struct dentry *dir = nd->path.dentry;
2865 : 3160147 : int open_flag = op->open_flag;
2866 : 3160147 : bool will_truncate = (open_flag & O_TRUNC) != 0;
2867 : : bool got_write = false;
2868 : 3160147 : int acc_mode = op->acc_mode;
2869 : : struct inode *inode;
2870 : : bool symlink_ok = false;
2871 : : struct path save_parent = { .dentry = NULL, .mnt = NULL };
2872 : : bool retried = false;
2873 : : int error;
2874 : :
2875 : 3160147 : nd->flags &= ~LOOKUP_PARENT;
2876 : 3160147 : nd->flags |= op->intent;
2877 : :
2878 [ + + ]: 3160147 : if (nd->last_type != LAST_NORM) {
2879 : : error = handle_dots(nd, nd->last_type);
2880 [ + + ]: 2005 : if (error)
2881 : : return error;
2882 : : goto finish_open;
2883 : : }
2884 : :
2885 [ + + ]: 3158142 : if (!(open_flag & O_CREAT)) {
2886 [ + + ]: 1354609 : if (nd->last.name[nd->last.len])
2887 : 223 : nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2888 [ - + ][ # # ]: 1354609 : if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
2889 : : symlink_ok = true;
2890 : : /* we _can_ be in RCU mode here */
2891 : 1354609 : error = lookup_fast(nd, path, &inode);
2892 [ + + ]: 1354602 : if (likely(!error))
2893 : : goto finish_lookup;
2894 : :
2895 [ + - ]: 558179 : if (error < 0)
2896 : : goto out;
2897 : :
2898 [ - + ]: 558179 : BUG_ON(nd->inode != dir->d_inode);
2899 : : } else {
2900 : : /* create side of things */
2901 : : /*
2902 : : * This will *only* deal with leaving RCU mode - LOOKUP_JUMPED
2903 : : * has been cleared when we got to the last component we are
2904 : : * about to look up
2905 : : */
2906 : 1803533 : error = complete_walk(nd);
2907 [ + + ]: 1803410 : if (error)
2908 : : return error;
2909 : :
2910 : : audit_inode(name, dir, LOOKUP_PARENT);
2911 : : error = -EISDIR;
2912 : : /* trailing slashes? */
2913 [ + ]: 1803302 : if (nd->last.name[nd->last.len])
2914 : : goto out;
2915 : : }
2916 : :
2917 : : retry_lookup:
2918 [ + + ]: 2361606 : if (op->open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) {
2919 : 2335445 : error = mnt_want_write(nd->path.mnt);
2920 [ + + ]: 2335521 : if (!error)
2921 : : got_write = true;
2922 : : /*
2923 : : * do _not_ fail yet - we might not need that or fail with
2924 : : * a different error; let lookup_open() decide; we'll be
2925 : : * dropping this one anyway.
2926 : : */
2927 : : }
2928 : 2361682 : mutex_lock(&dir->d_inode->i_mutex);
2929 : 2361529 : error = lookup_open(nd, path, file, op, got_write, opened);
2930 : 2361652 : mutex_unlock(&dir->d_inode->i_mutex);
2931 : :
2932 [ + + ]: 2361512 : if (error <= 0) {
2933 [ - + ]: 56 : if (error)
2934 : : goto out;
2935 : :
2936 [ # # ][ # # ]: 0 : if ((*opened & FILE_CREATED) ||
2937 : 0 : !S_ISREG(file_inode(file)->i_mode))
2938 : : will_truncate = false;
2939 : :
2940 : 0 : audit_inode(name, file->f_path.dentry, 0);
2941 : : goto opened;
2942 : : }
2943 : :
2944 [ + + ]: 2361456 : if (*opened & FILE_CREATED) {
2945 : : /* Don't check for write permission, don't truncate */
2946 : 185765 : open_flag &= ~O_TRUNC;
2947 : : will_truncate = false;
2948 : : acc_mode = MAY_OPEN;
2949 : : path_to_nameidata(path, nd);
2950 : : goto finish_open_created;
2951 : : }
2952 : :
2953 : : /*
2954 : : * create/update audit record if it already exists.
2955 : : */
2956 [ + + ]: 2175691 : if (d_is_positive(path->dentry))
2957 : : audit_inode(name, path->dentry, 0);
2958 : :
2959 : : /*
2960 : : * If atomic_open() acquired write access it is dropped now due to
2961 : : * possible mount and symlink following (this might be optimized away if
2962 : : * necessary...)
2963 : : */
2964 [ + + ]: 2175690 : if (got_write) {
2965 : 2149582 : mnt_drop_write(nd->path.mnt);
2966 : : got_write = false;
2967 : : }
2968 : :
2969 : : error = -EEXIST;
2970 [ + + ]: 2175690 : if ((open_flag & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT))
2971 : : goto exit_dput;
2972 : :
2973 : 2175680 : error = follow_managed(path, nd->flags);
2974 [ + - ]: 2175681 : if (error < 0)
2975 : : goto exit_dput;
2976 : :
2977 [ - + ]: 2175681 : if (error)
2978 : 0 : nd->flags |= LOOKUP_JUMPED;
2979 : :
2980 [ - + ]: 2175681 : BUG_ON(nd->flags & LOOKUP_RCU);
2981 : 2175681 : inode = path->dentry->d_inode;
2982 : : finish_lookup:
2983 : : /* we _can_ be in RCU mode here */
2984 : : error = -ENOENT;
2985 [ + + ]: 2972104 : if (d_is_negative(path->dentry)) {
2986 : : path_to_nameidata(path, nd);
2987 : : goto out;
2988 : : }
2989 : :
2990 [ + + ]: 2396795 : if (should_follow_link(path->dentry, !symlink_ok)) {
2991 [ + + ]: 120690 : if (nd->flags & LOOKUP_RCU) {
2992 [ + ]: 120053 : if (unlikely(unlazy_walk(nd, path->dentry))) {
2993 : : error = -ECHILD;
2994 : : goto out;
2995 : : }
2996 : : }
2997 [ - + ]: 120694 : BUG_ON(inode != path->dentry->d_inode);
2998 : : return 1;
2999 : : }
3000 : :
3001 [ + + ][ + + ]: 2276105 : if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
3002 : : path_to_nameidata(path, nd);
3003 : : } else {
3004 : 1807647 : save_parent.dentry = nd->path.dentry;
3005 : 1807647 : save_parent.mnt = mntget(path->mnt);
3006 : 1807647 : nd->path.dentry = path->dentry;
3007 : :
3008 : : }
3009 : 2276106 : nd->inode = inode;
3010 : : /* Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... */
3011 : : finish_open:
3012 : 2277902 : error = complete_walk(nd);
3013 [ + + ]: 2277807 : if (error) {
3014 : : path_put(&save_parent);
3015 : 4 : return error;
3016 : : }
3017 : 2277803 : audit_inode(name, nd->path.dentry, 0);
3018 : : error = -EISDIR;
3019 [ + + ][ + + ]: 5437955 : if ((open_flag & O_CREAT) &&
3020 [ + - ]: 1617326 : (d_is_directory(nd->path.dentry) || d_is_autodir(nd->path.dentry)))
3021 : : goto out;
3022 : : error = -ENOTDIR;
3023 [ + + ][ + + ]: 2277697 : if ((nd->flags & LOOKUP_DIRECTORY) && !d_is_directory(nd->path.dentry))
3024 : : goto out;
3025 [ + + ]: 2277681 : if (!S_ISREG(nd->inode->i_mode))
3026 : : will_truncate = false;
3027 : :
3028 [ + + ]: 2277681 : if (will_truncate) {
3029 : 3517 : error = mnt_want_write(nd->path.mnt);
3030 [ + - ]: 3517 : if (error)
3031 : : goto out;
3032 : : got_write = true;
3033 : : }
3034 : : finish_open_created:
3035 : 2463604 : error = may_open(&nd->path, acc_mode, open_flag);
3036 [ + + ]: 2463702 : if (error)
3037 : : goto out;
3038 : 2463541 : file->f_path.mnt = nd->path.mnt;
3039 : 2463541 : error = finish_open(file, nd->path.dentry, NULL, opened);
3040 [ + + ]: 2463566 : if (error) {
3041 [ + - ]: 41 : if (error == -EOPENSTALE)
3042 : : goto stale_open;
3043 : : goto out;
3044 : : }
3045 : : opened:
3046 : 2463525 : error = open_check_o_direct(file);
3047 [ + ]: 2463362 : if (error)
3048 : : goto exit_fput;
3049 : : error = ima_file_check(file, op->acc_mode);
3050 : : if (error)
3051 : : goto exit_fput;
3052 : :
3053 [ + + ]: 2463409 : if (will_truncate) {
3054 : 3513 : error = handle_truncate(file);
3055 [ + - ]: 3513 : if (error)
3056 : : goto exit_fput;
3057 : : }
3058 : : out:
3059 [ + + ]: 3038989 : if (got_write)
3060 : 189353 : mnt_drop_write(nd->path.mnt);
3061 : : path_put(&save_parent);
3062 : 3039028 : terminate_walk(nd);
3063 : 3039137 : return error;
3064 : :
3065 : : exit_dput:
3066 : 10 : path_put_conditional(path, nd);
3067 : 10 : goto out;
3068 : : exit_fput:
3069 : 0 : fput(file);
3070 : 2 : goto out;
3071 : :
3072 : : stale_open:
3073 : : /* If no saved parent or already retried then can't retry */
3074 [ # # ][ # # ]: 0 : if (!save_parent.dentry || retried)
3075 : : goto out;
3076 : :
3077 [ # # ]: 0 : BUG_ON(save_parent.dentry != dir);
3078 : : path_put(&nd->path);
3079 : 0 : nd->path = save_parent;
3080 : 0 : nd->inode = dir->d_inode;
3081 : : save_parent.mnt = NULL;
3082 : : save_parent.dentry = NULL;
3083 [ # # ]: 0 : if (got_write) {
3084 : 0 : mnt_drop_write(nd->path.mnt);
3085 : : got_write = false;
3086 : : }
3087 : : retried = true;
3088 : : goto retry_lookup;
3089 : : }
3090 : :
3091 : 0 : static int do_tmpfile(int dfd, struct filename *pathname,
3092 : : struct nameidata *nd, int flags,
3093 : : const struct open_flags *op,
3094 : 0 : struct file *file, int *opened)
3095 : : {
3096 : : static const struct qstr name = QSTR_INIT("/", 1);
3097 : : struct dentry *dentry, *child;
3098 : : struct inode *dir;
3099 : 0 : int error = path_lookupat(dfd, pathname->name,
3100 : 0 : flags | LOOKUP_DIRECTORY, nd);
3101 [ # # ]: 0 : if (unlikely(error))
3102 : : return error;
3103 : 0 : error = mnt_want_write(nd->path.mnt);
3104 [ # # ]: 0 : if (unlikely(error))
3105 : : goto out;
3106 : : /* we want directory to be writable */
3107 : 0 : error = inode_permission(nd->inode, MAY_WRITE | MAY_EXEC);
3108 [ # # ]: 0 : if (error)
3109 : : goto out2;
3110 : 0 : dentry = nd->path.dentry;
3111 : 0 : dir = dentry->d_inode;
3112 [ # # ]: 0 : if (!dir->i_op->tmpfile) {
3113 : : error = -EOPNOTSUPP;
3114 : : goto out2;
3115 : : }
3116 : 0 : child = d_alloc(dentry, &name);
3117 [ # # ]: 0 : if (unlikely(!child)) {
3118 : : error = -ENOMEM;
3119 : : goto out2;
3120 : : }
3121 : 0 : nd->flags &= ~LOOKUP_DIRECTORY;
3122 : 0 : nd->flags |= op->intent;
3123 : 0 : dput(nd->path.dentry);
3124 : 0 : nd->path.dentry = child;
3125 : 0 : error = dir->i_op->tmpfile(dir, nd->path.dentry, op->mode);
3126 [ # # ]: 0 : if (error)
3127 : : goto out2;
3128 : 0 : audit_inode(pathname, nd->path.dentry, 0);
3129 : 0 : error = may_open(&nd->path, op->acc_mode, op->open_flag);
3130 [ # # ]: 0 : if (error)
3131 : : goto out2;
3132 : 0 : file->f_path.mnt = nd->path.mnt;
3133 : 0 : error = finish_open(file, nd->path.dentry, NULL, opened);
3134 [ # # ]: 0 : if (error)
3135 : : goto out2;
3136 : 0 : error = open_check_o_direct(file);
3137 [ # # ]: 0 : if (error) {
3138 : 0 : fput(file);
3139 [ # # ]: 0 : } else if (!(op->open_flag & O_EXCL)) {
3140 : : struct inode *inode = file_inode(file);
3141 : : spin_lock(&inode->i_lock);
3142 : 0 : inode->i_state |= I_LINKABLE;
3143 : : spin_unlock(&inode->i_lock);
3144 : : }
3145 : : out2:
3146 : 0 : mnt_drop_write(nd->path.mnt);
3147 : : out:
3148 : : path_put(&nd->path);
3149 : 0 : return error;
3150 : : }
3151 : :
3152 : 0 : static struct file *path_openat(int dfd, struct filename *pathname,
3153 : : struct nameidata *nd, const struct open_flags *op, int flags)
3154 : : {
3155 : 3096191 : struct file *base = NULL;
3156 : : struct file *file;
3157 : : struct path path;
3158 : 3096191 : int opened = 0;
3159 : : int error;
3160 : :
3161 : 3096191 : file = get_empty_filp();
3162 [ + ]: 3096280 : if (IS_ERR(file))
3163 : : return file;
3164 : :
3165 : 3096331 : file->f_flags = op->open_flag;
3166 : :
3167 [ - + ]: 3096331 : if (unlikely(file->f_flags & __O_TMPFILE)) {
3168 : 0 : error = do_tmpfile(dfd, pathname, nd, flags, op, file, &opened);
3169 : 0 : goto out;
3170 : : }
3171 : :
3172 : 3096331 : error = path_init(dfd, pathname->name, flags | LOOKUP_PARENT, nd, &base);
3173 [ + ]: 3095957 : if (unlikely(error))
3174 : : goto out;
3175 : :
3176 : 3095967 : current->total_link_count = 0;
3177 : 3095967 : error = link_path_walk(pathname->name, nd);
3178 [ + + ]: 3096375 : if (unlikely(error))
3179 : : goto out;
3180 : :
3181 : 3039671 : error = do_last(nd, &path, file, op, &opened, pathname);
3182 [ + + ]: 3160040 : while (unlikely(error > 0)) { /* trailing symlink */
3183 : 120693 : struct path link = path;
3184 : : void *cookie;
3185 [ + + ]: 120693 : if (!(nd->flags & LOOKUP_FOLLOW)) {
3186 : 2 : path_put_conditional(&path, nd);
3187 : : path_put(&nd->path);
3188 : : error = -ELOOP;
3189 : 199 : break;
3190 : : }
3191 : : error = may_follow_link(&link, nd);
3192 [ + + ]: 120691 : if (unlikely(error))
3193 : : break;
3194 : 120499 : nd->flags |= LOOKUP_PARENT;
3195 : 120499 : nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
3196 : : error = follow_link(&link, nd, &cookie);
3197 [ + + ]: 120499 : if (unlikely(error))
3198 : : break;
3199 : 120496 : error = do_last(nd, &path, file, op, &opened, pathname);
3200 : : put_link(nd, &link, cookie);
3201 : : }
3202 : : out:
3203 [ + + ][ + + ]: 3096240 : if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
3204 : : path_put(&nd->root);
3205 [ - + ]: 6192349 : if (base)
3206 : 0 : fput(base);
3207 [ + + ]: 6192349 : if (!(opened & FILE_OPENED)) {
3208 [ - + ]: 632785 : BUG_ON(!error);
3209 : 632785 : put_filp(file);
3210 : : }
3211 [ + + ]: 3096157 : if (unlikely(error)) {
3212 [ - + ]: 632786 : if (error == -EOPENSTALE) {
3213 [ # # ]: 0 : if (flags & LOOKUP_RCU)
3214 : : error = -ECHILD;
3215 : : else
3216 : : error = -ESTALE;
3217 : : }
3218 : : file = ERR_PTR(error);
3219 : : }
3220 : 3096157 : return file;
3221 : : }
3222 : :
3223 : 0 : struct file *do_filp_open(int dfd, struct filename *pathname,
3224 : : const struct open_flags *op)
3225 : : {
3226 : : struct nameidata nd;
3227 : 3095989 : int flags = op->lookup_flags;
3228 : : struct file *filp;
3229 : :
3230 : 3095989 : filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
3231 [ + + ]: 3096004 : if (unlikely(filp == ERR_PTR(-ECHILD)))
3232 : 214 : filp = path_openat(dfd, pathname, &nd, op, flags);
3233 [ - + ]: 3096132 : if (unlikely(filp == ERR_PTR(-ESTALE)))
3234 : 0 : filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
3235 : 3096132 : return filp;
3236 : : }
3237 : :
3238 : 0 : struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
3239 : : const char *name, const struct open_flags *op)
3240 : : {
3241 : : struct nameidata nd;
3242 : : struct file *file;
3243 : 0 : struct filename filename = { .name = name };
3244 : 0 : int flags = op->lookup_flags | LOOKUP_ROOT;
3245 : :
3246 : 0 : nd.root.mnt = mnt;
3247 : 0 : nd.root.dentry = dentry;
3248 : :
3249 [ # # ][ # # ]: 0 : if (d_is_symlink(dentry) && op->intent & LOOKUP_OPEN)
3250 : : return ERR_PTR(-ELOOP);
3251 : :
3252 : 0 : file = path_openat(-1, &filename, &nd, op, flags | LOOKUP_RCU);
3253 [ # # ]: 0 : if (unlikely(file == ERR_PTR(-ECHILD)))
3254 : 0 : file = path_openat(-1, &filename, &nd, op, flags);
3255 [ # # ]: 0 : if (unlikely(file == ERR_PTR(-ESTALE)))
3256 : 0 : file = path_openat(-1, &filename, &nd, op, flags | LOOKUP_REVAL);
3257 : 0 : return file;
3258 : : }
3259 : :
3260 : 0 : struct dentry *kern_path_create(int dfd, const char *pathname,
3261 : : struct path *path, unsigned int lookup_flags)
3262 : : {
3263 : : struct dentry *dentry = ERR_PTR(-EEXIST);
3264 : : struct nameidata nd;
3265 : : int err2;
3266 : : int error;
3267 : 128079 : bool is_dir = (lookup_flags & LOOKUP_DIRECTORY);
3268 : :
3269 : : /*
3270 : : * Note that only LOOKUP_REVAL and LOOKUP_DIRECTORY matter here. Any
3271 : : * other flags passed in are ignored!
3272 : : */
3273 : 128079 : lookup_flags &= LOOKUP_REVAL;
3274 : :
3275 : 128079 : error = do_path_lookup(dfd, pathname, LOOKUP_PARENT|lookup_flags, &nd);
3276 [ + + ]: 128068 : if (error)
3277 : 21 : return ERR_PTR(error);
3278 : :
3279 : : /*
3280 : : * Yucky last component or no last component at all?
3281 : : * (foo/., foo/.., /////)
3282 : : */
3283 [ + ]: 128047 : if (nd.last_type != LAST_NORM)
3284 : : goto out;
3285 : 128055 : nd.flags &= ~LOOKUP_PARENT;
3286 : 128055 : nd.flags |= LOOKUP_CREATE | LOOKUP_EXCL;
3287 : :
3288 : : /* don't fail immediately if it's r/o, at least try to report other errors */
3289 : 128055 : err2 = mnt_want_write(nd.path.mnt);
3290 : : /*
3291 : : * Do the final lookup.
3292 : : */
3293 : 127933 : mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3294 : : dentry = lookup_hash(&nd);
3295 [ + + ]: 128129 : if (IS_ERR(dentry))
3296 : : goto unlock;
3297 : :
3298 : : error = -EEXIST;
3299 [ + + ]: 128121 : if (d_is_positive(dentry))
3300 : : goto fail;
3301 : :
3302 : : /*
3303 : : * Special case - lookup gave negative, but... we had foo/bar/
3304 : : * From the vfs_mknod() POV we just have a negative dentry -
3305 : : * all is fine. Let's be bastards - you had / on the end, you've
3306 : : * been asking for (non-existent) directory. -ENOENT for you.
3307 : : */
3308 [ + + ][ + + ]: 91704 : if (unlikely(!is_dir && nd.last.name[nd.last.len])) {
3309 : : error = -ENOENT;
3310 : : goto fail;
3311 : : }
3312 [ + - ]: 91701 : if (unlikely(err2)) {
3313 : : error = err2;
3314 : : goto fail;
3315 : : }
3316 : 91701 : *path = nd.path;
3317 : 91701 : return dentry;
3318 : : fail:
3319 : 36420 : dput(dentry);
3320 : : dentry = ERR_PTR(error);
3321 : : unlock:
3322 : 36421 : mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3323 [ + - ]: 36413 : if (!err2)
3324 : 36413 : mnt_drop_write(nd.path.mnt);
3325 : : out:
3326 : : path_put(&nd.path);
3327 : 36412 : return dentry;
3328 : : }
3329 : : EXPORT_SYMBOL(kern_path_create);
3330 : :
3331 : 0 : void done_path_create(struct path *path, struct dentry *dentry)
3332 : : {
3333 : 91605 : dput(dentry);
3334 : 91736 : mutex_unlock(&path->dentry->d_inode->i_mutex);
3335 : 91712 : mnt_drop_write(path->mnt);
3336 : : path_put(path);
3337 : 91702 : }
3338 : : EXPORT_SYMBOL(done_path_create);
3339 : :
3340 : 0 : struct dentry *user_path_create(int dfd, const char __user *pathname,
3341 : : struct path *path, unsigned int lookup_flags)
3342 : : {
3343 : : struct filename *tmp = getname(pathname);
3344 : : struct dentry *res;
3345 [ + + ]: 81245 : if (IS_ERR(tmp))
3346 : : return ERR_CAST(tmp);
3347 : 81219 : res = kern_path_create(dfd, tmp->name, path, lookup_flags);
3348 : 81242 : putname(tmp);
3349 : 81262 : return res;
3350 : : }
3351 : : EXPORT_SYMBOL(user_path_create);
3352 : :
3353 : 0 : int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
3354 : : {
3355 : : int error = may_create(dir, dentry);
3356 : :
3357 [ + - ]: 46904 : if (error)
3358 : : return error;
3359 : :
3360 [ + + ][ + - ]: 46904 : if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
3361 : : return -EPERM;
3362 : :
3363 [ + - ]: 46904 : if (!dir->i_op->mknod)
3364 : : return -EPERM;
3365 : :
3366 : : error = devcgroup_inode_mknod(mode, dev);
3367 : : if (error)
3368 : : return error;
3369 : :
3370 : 46904 : error = security_inode_mknod(dir, dentry, mode, dev);
3371 [ + - ]: 46904 : if (error)
3372 : : return error;
3373 : :
3374 : 46904 : error = dir->i_op->mknod(dir, dentry, mode, dev);
3375 [ + - ]: 46904 : if (!error)
3376 : : fsnotify_create(dir, dentry);
3377 : 46904 : return error;
3378 : : }
3379 : :
3380 : 0 : static int may_mknod(umode_t mode)
3381 : : {
3382 [ - + + ]: 54 : switch (mode & S_IFMT) {
3383 : : case S_IFREG:
3384 : : case S_IFCHR:
3385 : : case S_IFBLK:
3386 : : case S_IFIFO:
3387 : : case S_IFSOCK:
3388 : : case 0: /* zero mode translates to S_IFREG */
3389 : : return 0;
3390 : : case S_IFDIR:
3391 : 0 : return -EPERM;
3392 : : default:
3393 : 1 : return -EINVAL;
3394 : : }
3395 : : }
3396 : :
3397 : 0 : SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
3398 : : unsigned, dev)
3399 : : {
3400 : : struct dentry *dentry;
3401 : : struct path path;
3402 : : int error;
3403 : : unsigned int lookup_flags = 0;
3404 : :
3405 : 54 : error = may_mknod(mode);
3406 [ + + ]: 54 : if (error)
3407 : : return error;
3408 : : retry:
3409 : 53 : dentry = user_path_create(dfd, filename, &path, lookup_flags);
3410 [ + + ]: 53 : if (IS_ERR(dentry))
3411 : : return PTR_ERR(dentry);
3412 : :
3413 [ + - ]: 42 : if (!IS_POSIXACL(path.dentry->d_inode))
3414 : 42 : mode &= ~current_umask();
3415 : 42 : error = security_path_mknod(&path, dentry, mode, dev);
3416 [ + - ]: 42 : if (error)
3417 : : goto out;
3418 [ + + + - ]: 42 : switch (mode & S_IFMT) {
3419 : : case 0: case S_IFREG:
3420 : 7 : error = vfs_create(path.dentry->d_inode,dentry,mode,true);
3421 : : break;
3422 : : case S_IFCHR: case S_IFBLK:
3423 : 5 : error = vfs_mknod(path.dentry->d_inode,dentry,mode,
3424 : : new_decode_dev(dev));
3425 : : break;
3426 : : case S_IFIFO: case S_IFSOCK:
3427 : 30 : error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
3428 : : break;
3429 : : }
3430 : : out:
3431 : 42 : done_path_create(&path, dentry);
3432 [ - + ]: 42 : if (retry_estale(error, lookup_flags)) {
3433 : : lookup_flags |= LOOKUP_REVAL;
3434 : : goto retry;
3435 : : }
3436 : : return error;
3437 : : }
3438 : :
3439 : 0 : SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev)
3440 : : {
3441 : 49 : return sys_mknodat(AT_FDCWD, filename, mode, dev);
3442 : : }
3443 : :
3444 : 0 : int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
3445 : : {
3446 : : int error = may_create(dir, dentry);
3447 : 35204 : unsigned max_links = dir->i_sb->s_max_links;
3448 : :
3449 [ + - ]: 35204 : if (error)
3450 : : return error;
3451 : :
3452 [ + ]: 35204 : if (!dir->i_op->mkdir)
3453 : : return -EPERM;
3454 : :
3455 : 35205 : mode &= (S_IRWXUGO|S_ISVTX);
3456 : 35205 : error = security_inode_mkdir(dir, dentry, mode);
3457 [ + + ]: 35109 : if (error)
3458 : : return error;
3459 : :
3460 [ - + ][ # # ]: 35092 : if (max_links && dir->i_nlink >= max_links)
3461 : : return -EMLINK;
3462 : :
3463 : 35092 : error = dir->i_op->mkdir(dir, dentry, mode);
3464 [ + ]: 35104 : if (!error)
3465 : : fsnotify_mkdir(dir, dentry);
3466 : 35121 : return error;
3467 : : }
3468 : :
3469 : 70617 : SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
3470 : : {
3471 : : struct dentry *dentry;
3472 : : struct path path;
3473 : : int error;
3474 : : unsigned int lookup_flags = LOOKUP_DIRECTORY;
3475 : :
3476 : : retry:
3477 : 70636 : dentry = user_path_create(dfd, pathname, &path, lookup_flags);
3478 [ + + ]: 71156 : if (IS_ERR(dentry))
3479 : : return PTR_ERR(dentry);
3480 : :
3481 [ + ]: 35015 : if (!IS_POSIXACL(path.dentry->d_inode))
3482 : 35126 : mode &= ~current_umask();
3483 : 34905 : error = security_path_mkdir(&path, dentry, mode);
3484 [ + ]: 35170 : if (!error)
3485 : 35200 : error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
3486 : 35089 : done_path_create(&path, dentry);
3487 [ + + ]: 35196 : if (retry_estale(error, lookup_flags)) {
3488 : : lookup_flags |= LOOKUP_REVAL;
3489 : : goto retry;
3490 : : }
3491 : : return error;
3492 : : }
3493 : :
3494 : 0 : SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
3495 : : {
3496 : 70500 : return sys_mkdirat(AT_FDCWD, pathname, mode);
3497 : : }
3498 : :
3499 : : /*
3500 : : * The dentry_unhash() helper will try to drop the dentry early: we
3501 : : * should have a usage count of 1 if we're the only user of this
3502 : : * dentry, and if that is true (possibly after pruning the dcache),
3503 : : * then we drop the dentry now.
3504 : : *
3505 : : * A low-level filesystem can, if it choses, legally
3506 : : * do a
3507 : : *
3508 : : * if (!d_unhashed(dentry))
3509 : : * return -EBUSY;
3510 : : *
3511 : : * if it cannot handle the case of removing a directory
3512 : : * that is still in use by something else..
3513 : : */
3514 : 0 : void dentry_unhash(struct dentry *dentry)
3515 : : {
3516 : 0 : shrink_dcache_parent(dentry);
3517 : : spin_lock(&dentry->d_lock);
3518 [ # # ]: 0 : if (dentry->d_lockref.count == 1)
3519 : 0 : __d_drop(dentry);
3520 : : spin_unlock(&dentry->d_lock);
3521 : 0 : }
3522 : :
3523 : 0 : int vfs_rmdir(struct inode *dir, struct dentry *dentry)
3524 : : {
3525 : 35484 : int error = may_delete(dir, dentry, 1);
3526 : :
3527 [ + + ]: 35487 : if (error)
3528 : : return error;
3529 : :
3530 [ + ]: 35353 : if (!dir->i_op->rmdir)
3531 : : return -EPERM;
3532 : :
3533 : : dget(dentry);
3534 : 35356 : mutex_lock(&dentry->d_inode->i_mutex);
3535 : :
3536 : : error = -EBUSY;
3537 [ + ]: 35343 : if (d_mountpoint(dentry))
3538 : : goto out;
3539 : :
3540 : 35345 : error = security_inode_rmdir(dir, dentry);
3541 [ + ]: 35350 : if (error)
3542 : : goto out;
3543 : :
3544 : 35354 : shrink_dcache_parent(dentry);
3545 : 35349 : error = dir->i_op->rmdir(dir, dentry);
3546 [ + + ]: 35356 : if (error)
3547 : : goto out;
3548 : :
3549 : 35194 : dentry->d_inode->i_flags |= S_DEAD;
3550 : : dont_mount(dentry);
3551 : :
3552 : : out:
3553 : 35350 : mutex_unlock(&dentry->d_inode->i_mutex);
3554 : 35358 : dput(dentry);
3555 [ + + ]: 35358 : if (!error)
3556 : 35194 : d_delete(dentry);
3557 : 35358 : return error;
3558 : : }
3559 : :
3560 : 67965 : static long do_rmdir(int dfd, const char __user *pathname)
3561 : : {
3562 : : int error = 0;
3563 : : struct filename *name;
3564 : : struct dentry *dentry;
3565 : : struct nameidata nd;
3566 : : unsigned int lookup_flags = 0;
3567 : : retry:
3568 : 67969 : name = user_path_parent(dfd, pathname, &nd, lookup_flags);
3569 [ + + ]: 67952 : if (IS_ERR(name))
3570 : 10 : return PTR_ERR(name);
3571 : :
3572 [ + - + ]: 67942 : switch(nd.last_type) {
3573 : : case LAST_DOTDOT:
3574 : : error = -ENOTEMPTY;
3575 : : goto exit1;
3576 : : case LAST_DOT:
3577 : : error = -EINVAL;
3578 : 1 : goto exit1;
3579 : : case LAST_ROOT:
3580 : : error = -EBUSY;
3581 : 0 : goto exit1;
3582 : : }
3583 : :
3584 : 67945 : nd.flags &= ~LOOKUP_PARENT;
3585 : 67945 : error = mnt_want_write(nd.path.mnt);
3586 [ + ]: 67839 : if (error)
3587 : : goto exit1;
3588 : :
3589 : 67881 : mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3590 : : dentry = lookup_hash(&nd);
3591 : : error = PTR_ERR(dentry);
3592 [ + - ]: 68019 : if (IS_ERR(dentry))
3593 : : goto exit2;
3594 [ + + ]: 68019 : if (!dentry->d_inode) {
3595 : : error = -ENOENT;
3596 : : goto exit3;
3597 : : }
3598 : 35486 : error = security_path_rmdir(&nd.path, dentry);
3599 [ + ]: 35478 : if (error)
3600 : : goto exit3;
3601 : 35482 : error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
3602 : : exit3:
3603 : 68015 : dput(dentry);
3604 : : exit2:
3605 : 68020 : mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3606 : 67913 : mnt_drop_write(nd.path.mnt);
3607 : : exit1:
3608 : : path_put(&nd.path);
3609 : 67978 : putname(name);
3610 [ + + ]: 67976 : if (retry_estale(error, lookup_flags)) {
3611 : : lookup_flags |= LOOKUP_REVAL;
3612 : : goto retry;
3613 : : }
3614 : : return error;
3615 : : }
3616 : :
3617 : 0 : SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
3618 : : {
3619 : 62074 : return do_rmdir(AT_FDCWD, pathname);
3620 : : }
3621 : :
3622 : : /**
3623 : : * vfs_unlink - unlink a filesystem object
3624 : : * @dir: parent directory
3625 : : * @dentry: victim
3626 : : * @delegated_inode: returns victim inode, if the inode is delegated.
3627 : : *
3628 : : * The caller must hold dir->i_mutex.
3629 : : *
3630 : : * If vfs_unlink discovers a delegation, it will return -EWOULDBLOCK and
3631 : : * return a reference to the inode in delegated_inode. The caller
3632 : : * should then break the delegation on that inode and retry. Because
3633 : : * breaking a delegation may take a long time, the caller should drop
3634 : : * dir->i_mutex before doing so.
3635 : : *
3636 : : * Alternatively, a caller may pass NULL for delegated_inode. This may
3637 : : * be appropriate for callers that expect the underlying filesystem not
3638 : : * to be NFS exported.
3639 : : */
3640 : 0 : int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)
3641 : : {
3642 : 89768 : struct inode *target = dentry->d_inode;
3643 : 89768 : int error = may_delete(dir, dentry, 0);
3644 : :
3645 [ + + ]: 89768 : if (error)
3646 : : return error;
3647 : :
3648 [ + - ]: 88901 : if (!dir->i_op->unlink)
3649 : : return -EPERM;
3650 : :
3651 : 88901 : mutex_lock(&target->i_mutex);
3652 [ + ]: 88901 : if (d_mountpoint(dentry))
3653 : : error = -EBUSY;
3654 : : else {
3655 : 88902 : error = security_inode_unlink(dir, dentry);
3656 [ + - ]: 88901 : if (!error) {
3657 : : error = try_break_deleg(target, delegated_inode);
3658 [ + - ]: 88901 : if (error)
3659 : : goto out;
3660 : 88901 : error = dir->i_op->unlink(dir, dentry);
3661 [ + - ]: 88902 : if (!error)
3662 : : dont_mount(dentry);
3663 : : }
3664 : : }
3665 : : out:
3666 : 88901 : mutex_unlock(&target->i_mutex);
3667 : :
3668 : : /* We don't d_delete() NFS sillyrenamed files--they still exist. */
3669 [ + - ][ + - ]: 88902 : if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
3670 : : fsnotify_link_count(target);
3671 : 88902 : d_delete(dentry);
3672 : : }
3673 : :
3674 : 88902 : return error;
3675 : : }
3676 : :
3677 : : /*
3678 : : * Make sure that the actual truncation of the file will occur outside its
3679 : : * directory's i_mutex. Truncate can take a long time if there is a lot of
3680 : : * writeout happening, and we don't want to prevent access to the directory
3681 : : * while waiting on the I/O.
3682 : : */
3683 : 0 : static long do_unlinkat(int dfd, const char __user *pathname)
3684 : : {
3685 : : int error;
3686 : : struct filename *name;
3687 : : struct dentry *dentry;
3688 : : struct nameidata nd;
3689 : : struct inode *inode = NULL;
3690 : 248919 : struct inode *delegated_inode = NULL;
3691 : : unsigned int lookup_flags = 0;
3692 : : retry:
3693 : 248919 : name = user_path_parent(dfd, pathname, &nd, lookup_flags);
3694 [ + + ]: 248926 : if (IS_ERR(name))
3695 : 45 : return PTR_ERR(name);
3696 : :
3697 : : error = -EISDIR;
3698 [ + + ]: 248881 : if (nd.last_type != LAST_NORM)
3699 : : goto exit1;
3700 : :
3701 : 248875 : nd.flags &= ~LOOKUP_PARENT;
3702 : 248875 : error = mnt_want_write(nd.path.mnt);
3703 [ + ]: 248878 : if (error)
3704 : : goto exit1;
3705 : : retry_deleg:
3706 : 248882 : mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3707 : : dentry = lookup_hash(&nd);
3708 : : error = PTR_ERR(dentry);
3709 [ + - ]: 248884 : if (!IS_ERR(dentry)) {
3710 : : /* Why not before? Because we want correct error value */
3711 [ + ]: 248884 : if (nd.last.name[nd.last.len])
3712 : : goto slashes;
3713 : 248885 : inode = dentry->d_inode;
3714 [ + + ]: 248885 : if (d_is_negative(dentry))
3715 : : goto slashes;
3716 : 89729 : ihold(inode);
3717 : 89729 : error = security_path_unlink(&nd.path, dentry);
3718 [ + ]: 89728 : if (error)
3719 : : goto exit2;
3720 : 89729 : error = vfs_unlink(nd.path.dentry->d_inode, dentry, &delegated_inode);
3721 : : exit2:
3722 : 248883 : dput(dentry);
3723 : : }
3724 : 248885 : mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3725 [ + + ]: 248885 : if (inode)
3726 : 89729 : iput(inode); /* truncate the inode here */
3727 : : inode = NULL;
3728 [ - + ]: 248884 : if (delegated_inode) {
3729 : : error = break_deleg_wait(&delegated_inode);
3730 [ # # ]: 0 : if (!error)
3731 : : goto retry_deleg;
3732 : : }
3733 : 248884 : mnt_drop_write(nd.path.mnt);
3734 : : exit1:
3735 : : path_put(&nd.path);
3736 : 248883 : putname(name);
3737 [ - + ]: 248885 : if (retry_estale(error, lookup_flags)) {
3738 : : lookup_flags |= LOOKUP_REVAL;
3739 : : inode = NULL;
3740 : : goto retry;
3741 : : }
3742 : : return error;
3743 : :
3744 : : slashes:
3745 [ + - ]: 159155 : if (d_is_negative(dentry))
3746 : : error = -ENOENT;
3747 [ # # ][ # # ]: 0 : else if (d_is_directory(dentry) || d_is_autodir(dentry))
3748 : : error = -EISDIR;
3749 : : else
3750 : : error = -ENOTDIR;
3751 : : goto exit2;
3752 : : }
3753 : :
3754 : 0 : SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
3755 : : {
3756 [ + ]: 16886 : if ((flag & ~AT_REMOVEDIR) != 0)
3757 : : return -EINVAL;
3758 : :
3759 [ + + ]: 16888 : if (flag & AT_REMOVEDIR)
3760 : 5864 : return do_rmdir(dfd, pathname);
3761 : :
3762 : 11024 : return do_unlinkat(dfd, pathname);
3763 : : }
3764 : :
3765 : 0 : SYSCALL_DEFINE1(unlink, const char __user *, pathname)
3766 : : {
3767 : 237898 : return do_unlinkat(AT_FDCWD, pathname);
3768 : : }
3769 : :
3770 : 0 : int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
3771 : : {
3772 : : int error = may_create(dir, dentry);
3773 : :
3774 [ + - ]: 4288 : if (error)
3775 : : return error;
3776 : :
3777 [ + - ]: 4288 : if (!dir->i_op->symlink)
3778 : : return -EPERM;
3779 : :
3780 : 4288 : error = security_inode_symlink(dir, dentry, oldname);
3781 [ + - ]: 4288 : if (error)
3782 : : return error;
3783 : :
3784 : 4288 : error = dir->i_op->symlink(dir, dentry, oldname);
3785 [ + - ]: 4288 : if (!error)
3786 : : fsnotify_create(dir, dentry);
3787 : 4288 : return error;
3788 : : }
3789 : :
3790 : 0 : SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
3791 : : int, newdfd, const char __user *, newname)
3792 : : {
3793 : : int error;
3794 : : struct filename *from;
3795 : : struct dentry *dentry;
3796 : : struct path path;
3797 : : unsigned int lookup_flags = 0;
3798 : :
3799 : 4493 : from = getname(oldname);
3800 [ - + ]: 4493 : if (IS_ERR(from))
3801 : : return PTR_ERR(from);
3802 : : retry:
3803 : 4493 : dentry = user_path_create(newdfd, newname, &path, lookup_flags);
3804 : : error = PTR_ERR(dentry);
3805 [ + + ]: 4493 : if (IS_ERR(dentry))
3806 : : goto out_putname;
3807 : :
3808 : 4288 : error = security_path_symlink(&path, dentry, from->name);
3809 [ + - ]: 4288 : if (!error)
3810 : 4288 : error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
3811 : 4288 : done_path_create(&path, dentry);
3812 [ - + ]: 4288 : if (retry_estale(error, lookup_flags)) {
3813 : : lookup_flags |= LOOKUP_REVAL;
3814 : : goto retry;
3815 : : }
3816 : : out_putname:
3817 : 4493 : putname(from);
3818 : : return error;
3819 : : }
3820 : :
3821 : 0 : SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
3822 : : {
3823 : 4483 : return sys_symlinkat(oldname, AT_FDCWD, newname);
3824 : : }
3825 : :
3826 : : /**
3827 : : * vfs_link - create a new link
3828 : : * @old_dentry: object to be linked
3829 : : * @dir: new parent
3830 : : * @new_dentry: where to create the new link
3831 : : * @delegated_inode: returns inode needing a delegation break
3832 : : *
3833 : : * The caller must hold dir->i_mutex
3834 : : *
3835 : : * If vfs_link discovers a delegation on the to-be-linked file in need
3836 : : * of breaking, it will return -EWOULDBLOCK and return a reference to the
3837 : : * inode in delegated_inode. The caller should then break the delegation
3838 : : * and retry. Because breaking a delegation may take a long time, the
3839 : : * caller should drop the i_mutex before doing so.
3840 : : *
3841 : : * Alternatively, a caller may pass NULL for delegated_inode. This may
3842 : : * be appropriate for callers that expect the underlying filesystem not
3843 : : * to be NFS exported.
3844 : : */
3845 : 0 : int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)
3846 : : {
3847 : 5290 : struct inode *inode = old_dentry->d_inode;
3848 : 5290 : unsigned max_links = dir->i_sb->s_max_links;
3849 : : int error;
3850 : :
3851 [ + - ]: 5290 : if (!inode)
3852 : : return -ENOENT;
3853 : :
3854 : : error = may_create(dir, new_dentry);
3855 [ + + ]: 5290 : if (error)
3856 : : return error;
3857 : :
3858 [ + - ]: 5289 : if (dir->i_sb != inode->i_sb)
3859 : : return -EXDEV;
3860 : :
3861 : : /*
3862 : : * A link to an append-only or immutable file cannot be created.
3863 : : */
3864 [ + - ]: 5289 : if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3865 : : return -EPERM;
3866 [ + - ]: 5289 : if (!dir->i_op->link)
3867 : : return -EPERM;
3868 [ + + ]: 5289 : if (S_ISDIR(inode->i_mode))
3869 : : return -EPERM;
3870 : :
3871 : 5288 : error = security_inode_link(old_dentry, dir, new_dentry);
3872 [ + - ]: 5288 : if (error)
3873 : : return error;
3874 : :
3875 : 5288 : mutex_lock(&inode->i_mutex);
3876 : : /* Make sure we don't allow creating hardlink to an unlinked file */
3877 [ - + ][ # # ]: 5288 : if (inode->i_nlink == 0 && !(inode->i_state & I_LINKABLE))
3878 : : error = -ENOENT;
3879 [ - + ][ # # ]: 5288 : else if (max_links && inode->i_nlink >= max_links)
3880 : : error = -EMLINK;
3881 : : else {
3882 : : error = try_break_deleg(inode, delegated_inode);
3883 [ + - ]: 5288 : if (!error)
3884 : 5288 : error = dir->i_op->link(old_dentry, dir, new_dentry);
3885 : : }
3886 : :
3887 [ + - ][ - + ]: 5288 : if (!error && (inode->i_state & I_LINKABLE)) {
3888 : : spin_lock(&inode->i_lock);
3889 : 0 : inode->i_state &= ~I_LINKABLE;
3890 : : spin_unlock(&inode->i_lock);
3891 : : }
3892 : 5288 : mutex_unlock(&inode->i_mutex);
3893 [ + - ]: 5288 : if (!error)
3894 : : fsnotify_link(dir, inode, new_dentry);
3895 : 5288 : return error;
3896 : : }
3897 : :
3898 : : /*
3899 : : * Hardlinks are often used in delicate situations. We avoid
3900 : : * security-related surprises by not following symlinks on the
3901 : : * newname. --KAB
3902 : : *
3903 : : * We don't follow them on the oldname either to be compatible
3904 : : * with linux 2.0, and to avoid hard-linking to directories
3905 : : * and other special files. --ADM
3906 : : */
3907 : 0 : SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
3908 : : int, newdfd, const char __user *, newname, int, flags)
3909 : : {
3910 : : struct dentry *new_dentry;
3911 : : struct path old_path, new_path;
3912 : 5420 : struct inode *delegated_inode = NULL;
3913 : : int how = 0;
3914 : : int error;
3915 : :
3916 [ + + ]: 5420 : if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
3917 : : return -EINVAL;
3918 : : /*
3919 : : * To use null names we require CAP_DAC_READ_SEARCH
3920 : : * This ensures that not everyone will be able to create
3921 : : * handlink using the passed filedescriptor.
3922 : : */
3923 [ - + ]: 5419 : if (flags & AT_EMPTY_PATH) {
3924 [ # # ]: 0 : if (!capable(CAP_DAC_READ_SEARCH))
3925 : : return -ENOENT;
3926 : : how = LOOKUP_EMPTY;
3927 : : }
3928 : :
3929 [ - + ]: 5419 : if (flags & AT_SYMLINK_FOLLOW)
3930 : 5419 : how |= LOOKUP_FOLLOW;
3931 : : retry:
3932 : 5419 : error = user_path_at(olddfd, oldname, how, &old_path);
3933 [ + + ]: 5419 : if (error)
3934 : : return error;
3935 : :
3936 : 5408 : new_dentry = user_path_create(newdfd, newname, &new_path,
3937 : : (how & LOOKUP_REVAL));
3938 : : error = PTR_ERR(new_dentry);
3939 [ + + ]: 5408 : if (IS_ERR(new_dentry))
3940 : : goto out;
3941 : :
3942 : : error = -EXDEV;
3943 [ + + ]: 5318 : if (old_path.mnt != new_path.mnt)
3944 : : goto out_dput;
3945 : 5317 : error = may_linkat(&old_path);
3946 [ + + ]: 5317 : if (unlikely(error))
3947 : : goto out_dput;
3948 : 5290 : error = security_path_link(old_path.dentry, &new_path, new_dentry);
3949 [ + - ]: 5290 : if (error)
3950 : : goto out_dput;
3951 : 5290 : error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
3952 : : out_dput:
3953 : 5318 : done_path_create(&new_path, new_dentry);
3954 [ - + ]: 5318 : if (delegated_inode) {
3955 : : error = break_deleg_wait(&delegated_inode);
3956 [ # # ]: 0 : if (!error) {
3957 : 0 : path_put(&old_path);
3958 : : goto retry;
3959 : : }
3960 : : }
3961 [ - + ]: 5318 : if (retry_estale(error, how)) {
3962 : 0 : path_put(&old_path);
3963 : 0 : how |= LOOKUP_REVAL;
3964 : : goto retry;
3965 : : }
3966 : : out:
3967 : 5408 : path_put(&old_path);
3968 : :
3969 : : return error;
3970 : : }
3971 : :
3972 : 0 : SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
3973 : : {
3974 : 4398 : return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
3975 : : }
3976 : :
3977 : : /*
3978 : : * The worst of all namespace operations - renaming directory. "Perverted"
3979 : : * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
3980 : : * Problems:
3981 : : * a) we can get into loop creation. Check is done in is_subdir().
3982 : : * b) race potential - two innocent renames can create a loop together.
3983 : : * That's where 4.4 screws up. Current fix: serialization on
3984 : : * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
3985 : : * story.
3986 : : * c) we have to lock _four_ objects - parents and victim (if it exists),
3987 : : * and source (if it is not a directory).
3988 : : * And that - after we got ->i_mutex on parents (until then we don't know
3989 : : * whether the target exists). Solution: try to be smart with locking
3990 : : * order for inodes. We rely on the fact that tree topology may change
3991 : : * only under ->s_vfs_rename_mutex _and_ that parent of the object we
3992 : : * move will be locked. Thus we can rank directories by the tree
3993 : : * (ancestors first) and rank all non-directories after them.
3994 : : * That works since everybody except rename does "lock parent, lookup,
3995 : : * lock child" and rename is under ->s_vfs_rename_mutex.
3996 : : * HOWEVER, it relies on the assumption that any object with ->lookup()
3997 : : * has no more than 1 dentry. If "hybrid" objects will ever appear,
3998 : : * we'd better make sure that there's no link(2) for them.
3999 : : * d) conversion from fhandle to dentry may come in the wrong moment - when
4000 : : * we are removing the target. Solution: we will have to grab ->i_mutex
4001 : : * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
4002 : : * ->i_mutex on parents, which works but leads to some truly excessive
4003 : : * locking].
4004 : : */
4005 : 0 : static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
4006 : 17 : struct inode *new_dir, struct dentry *new_dentry)
4007 : : {
4008 : : int error = 0;
4009 : 17 : struct inode *target = new_dentry->d_inode;
4010 : 17 : unsigned max_links = new_dir->i_sb->s_max_links;
4011 : :
4012 : : /*
4013 : : * If we are going to change the parent - check write permissions,
4014 : : * we'll need to flip '..'.
4015 : : */
4016 [ + + ]: 17 : if (new_dir != old_dir) {
4017 : 5 : error = inode_permission(old_dentry->d_inode, MAY_WRITE);
4018 [ + - ]: 5 : if (error)
4019 : : return error;
4020 : : }
4021 : :
4022 : 17 : error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
4023 [ + - ]: 17 : if (error)
4024 : : return error;
4025 : :
4026 : : dget(new_dentry);
4027 [ + + ]: 34 : if (target)
4028 : 6 : mutex_lock(&target->i_mutex);
4029 : :
4030 : : error = -EBUSY;
4031 [ + - ][ + - ]: 17 : if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
4032 : : goto out;
4033 : :
4034 : : error = -EMLINK;
4035 [ - + ][ # # ]: 17 : if (max_links && !target && new_dir != old_dir &&
[ # # ]
4036 : 0 : new_dir->i_nlink >= max_links)
4037 : : goto out;
4038 : :
4039 [ + + ]: 17 : if (target)
4040 : 6 : shrink_dcache_parent(new_dentry);
4041 : 17 : error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
4042 [ + + ]: 17 : if (error)
4043 : : goto out;
4044 : :
4045 [ + + ]: 12 : if (target) {
4046 : 1 : target->i_flags |= S_DEAD;
4047 : : dont_mount(new_dentry);
4048 : : }
4049 : : out:
4050 [ + + ]: 17 : if (target)
4051 : 6 : mutex_unlock(&target->i_mutex);
4052 : 17 : dput(new_dentry);
4053 [ + + ]: 17 : if (!error)
4054 [ + - ]: 12 : if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
4055 : 12 : d_move(old_dentry,new_dentry);
4056 : 17 : return error;
4057 : : }
4058 : :
4059 : 0 : static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
4060 : 153075 : struct inode *new_dir, struct dentry *new_dentry,
4061 : : struct inode **delegated_inode)
4062 : : {
4063 : 153075 : struct inode *target = new_dentry->d_inode;
4064 : 153075 : struct inode *source = old_dentry->d_inode;
4065 : : int error;
4066 : :
4067 : 153075 : error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
4068 [ + - ]: 153075 : if (error)
4069 : : return error;
4070 : :
4071 : : dget(new_dentry);
4072 : 153075 : lock_two_nondirectories(source, target);
4073 : :
4074 : : error = -EBUSY;
4075 [ + - ][ + - ]: 153075 : if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
4076 : : goto out;
4077 : :
4078 : : error = try_break_deleg(source, delegated_inode);
4079 [ + - ]: 153075 : if (error)
4080 : : goto out;
4081 [ + + ]: 153075 : if (target) {
4082 : : error = try_break_deleg(target, delegated_inode);
4083 [ + - ]: 152824 : if (error)
4084 : : goto out;
4085 : : }
4086 : 153075 : error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
4087 [ + - ]: 153075 : if (error)
4088 : : goto out;
4089 : :
4090 [ + + ]: 153075 : if (target)
4091 : : dont_mount(new_dentry);
4092 [ + - ]: 153075 : if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
4093 : 153075 : d_move(old_dentry, new_dentry);
4094 : : out:
4095 : 153075 : unlock_two_nondirectories(source, target);
4096 : 153075 : dput(new_dentry);
4097 : 153075 : return error;
4098 : : }
4099 : :
4100 : : /**
4101 : : * vfs_rename - rename a filesystem object
4102 : : * @old_dir: parent of source
4103 : : * @old_dentry: source
4104 : : * @new_dir: parent of destination
4105 : : * @new_dentry: destination
4106 : : * @delegated_inode: returns an inode needing a delegation break
4107 : : *
4108 : : * The caller must hold multiple mutexes--see lock_rename()).
4109 : : *
4110 : : * If vfs_rename discovers a delegation in need of breaking at either
4111 : : * the source or destination, it will return -EWOULDBLOCK and return a
4112 : : * reference to the inode in delegated_inode. The caller should then
4113 : : * break the delegation and retry. Because breaking a delegation may
4114 : : * take a long time, the caller should drop all locks before doing
4115 : : * so.
4116 : : *
4117 : : * Alternatively, a caller may pass NULL for delegated_inode. This may
4118 : : * be appropriate for callers that expect the underlying filesystem not
4119 : : * to be NFS exported.
4120 : : */
4121 : 0 : int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
4122 : : struct inode *new_dir, struct dentry *new_dentry,
4123 : : struct inode **delegated_inode)
4124 : : {
4125 : : int error;
4126 [ + + ][ + - ]: 153096 : int is_dir = d_is_directory(old_dentry) || d_is_autodir(old_dentry);
4127 : : const unsigned char *old_name;
4128 : :
4129 [ + + ]: 153096 : if (old_dentry->d_inode == new_dentry->d_inode)
4130 : : return 0;
4131 : :
4132 : 153095 : error = may_delete(old_dir, old_dentry, is_dir);
4133 [ + + ]: 153095 : if (error)
4134 : : return error;
4135 : :
4136 [ + + ]: 153094 : if (!new_dentry->d_inode)
4137 : : error = may_create(new_dir, new_dentry);
4138 : : else
4139 : 152832 : error = may_delete(new_dir, new_dentry, is_dir);
4140 [ + + ]: 153094 : if (error)
4141 : : return error;
4142 : :
4143 [ + - ]: 153092 : if (!old_dir->i_op->rename)
4144 : : return -EPERM;
4145 : :
4146 : 153092 : old_name = fsnotify_oldname_init(old_dentry->d_name.name);
4147 : :
4148 [ + + ]: 153092 : if (is_dir)
4149 : 17 : error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
4150 : : else
4151 : 153075 : error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry,delegated_inode);
4152 [ + + ]: 153092 : if (!error)
4153 : 153087 : fsnotify_move(old_dir, new_dir, old_name, is_dir,
4154 : : new_dentry->d_inode, old_dentry);
4155 : : fsnotify_oldname_free(old_name);
4156 : :
4157 : 153092 : return error;
4158 : : }
4159 : :
4160 : 0 : SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
4161 : : int, newdfd, const char __user *, newname)
4162 : : {
4163 : : struct dentry *old_dir, *new_dir;
4164 : : struct dentry *old_dentry, *new_dentry;
4165 : : struct dentry *trap;
4166 : : struct nameidata oldnd, newnd;
4167 : 628016 : struct inode *delegated_inode = NULL;
4168 : : struct filename *from;
4169 : : struct filename *to;
4170 : : unsigned int lookup_flags = 0;
4171 : : bool should_retry = false;
4172 : : int error;
4173 : : retry:
4174 : 628016 : from = user_path_parent(olddfd, oldname, &oldnd, lookup_flags);
4175 [ + + ]: 628016 : if (IS_ERR(from)) {
4176 : : error = PTR_ERR(from);
4177 : : goto exit;
4178 : : }
4179 : :
4180 : 628011 : to = user_path_parent(newdfd, newname, &newnd, lookup_flags);
4181 [ + + ]: 628011 : if (IS_ERR(to)) {
4182 : : error = PTR_ERR(to);
4183 : : goto exit1;
4184 : : }
4185 : :
4186 : : error = -EXDEV;
4187 [ + - ]: 628009 : if (oldnd.path.mnt != newnd.path.mnt)
4188 : : goto exit2;
4189 : :
4190 : 628009 : old_dir = oldnd.path.dentry;
4191 : : error = -EBUSY;
4192 [ + - ]: 628009 : if (oldnd.last_type != LAST_NORM)
4193 : : goto exit2;
4194 : :
4195 : 628009 : new_dir = newnd.path.dentry;
4196 [ + - ]: 628009 : if (newnd.last_type != LAST_NORM)
4197 : : goto exit2;
4198 : :
4199 : 628009 : error = mnt_want_write(oldnd.path.mnt);
4200 [ + - ]: 628009 : if (error)
4201 : : goto exit2;
4202 : :
4203 : 628009 : oldnd.flags &= ~LOOKUP_PARENT;
4204 : 628009 : newnd.flags &= ~LOOKUP_PARENT;
4205 : 628009 : newnd.flags |= LOOKUP_RENAME_TARGET;
4206 : :
4207 : : retry_deleg:
4208 : 628009 : trap = lock_rename(new_dir, old_dir);
4209 : :
4210 : 628009 : old_dentry = lookup_hash(&oldnd);
4211 : : error = PTR_ERR(old_dentry);
4212 [ + - ]: 628009 : if (IS_ERR(old_dentry))
4213 : : goto exit3;
4214 : : /* source must exist */
4215 : : error = -ENOENT;
4216 [ + + ]: 628009 : if (d_is_negative(old_dentry))
4217 : : goto exit4;
4218 : : /* unless the source is a directory trailing slashes give -ENOTDIR */
4219 [ + + ][ + - ]: 153106 : if (!d_is_directory(old_dentry) && !d_is_autodir(old_dentry)) {
4220 : : error = -ENOTDIR;
4221 [ + - ]: 153079 : if (oldnd.last.name[oldnd.last.len])
4222 : : goto exit4;
4223 [ + - ]: 153079 : if (newnd.last.name[newnd.last.len])
4224 : : goto exit4;
4225 : : }
4226 : : /* source should not be ancestor of target */
4227 : : error = -EINVAL;
4228 [ + + ]: 153106 : if (old_dentry == trap)
4229 : : goto exit4;
4230 : 153097 : new_dentry = lookup_hash(&newnd);
4231 : : error = PTR_ERR(new_dentry);
4232 [ + + ]: 153097 : if (IS_ERR(new_dentry))
4233 : : goto exit4;
4234 : : /* target should not be an ancestor of source */
4235 : : error = -ENOTEMPTY;
4236 [ + - ]: 153096 : if (new_dentry == trap)
4237 : : goto exit5;
4238 : :
4239 : 153096 : error = security_path_rename(&oldnd.path, old_dentry,
4240 : : &newnd.path, new_dentry);
4241 [ + - ]: 153096 : if (error)
4242 : : goto exit5;
4243 : 153096 : error = vfs_rename(old_dir->d_inode, old_dentry,
4244 : : new_dir->d_inode, new_dentry,
4245 : : &delegated_inode);
4246 : : exit5:
4247 : 153096 : dput(new_dentry);
4248 : : exit4:
4249 : 628009 : dput(old_dentry);
4250 : : exit3:
4251 : 628009 : unlock_rename(new_dir, old_dir);
4252 [ - + ]: 628009 : if (delegated_inode) {
4253 : : error = break_deleg_wait(&delegated_inode);
4254 [ # # ]: 0 : if (!error)
4255 : : goto retry_deleg;
4256 : : }
4257 : 628009 : mnt_drop_write(oldnd.path.mnt);
4258 : : exit2:
4259 [ - + ]: 628009 : if (retry_estale(error, lookup_flags))
4260 : : should_retry = true;
4261 : 628009 : path_put(&newnd.path);
4262 : 628009 : putname(to);
4263 : : exit1:
4264 : 628011 : path_put(&oldnd.path);
4265 : 628011 : putname(from);
4266 [ - + ]: 628011 : if (should_retry) {
4267 : : should_retry = false;
4268 : : lookup_flags |= LOOKUP_REVAL;
4269 : : goto retry;
4270 : : }
4271 : : exit:
4272 : : return error;
4273 : : }
4274 : :
4275 : 0 : SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
4276 : : {
4277 : 628011 : return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
4278 : : }
4279 : :
4280 : 0 : int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
4281 : : {
4282 : : int len;
4283 : :
4284 : : len = PTR_ERR(link);
4285 [ + - ]: 4639 : if (IS_ERR(link))
4286 : : goto out;
4287 : :
4288 : 4639 : len = strlen(link);
4289 [ - + ]: 4639 : if (len > (unsigned) buflen)
4290 : : len = buflen;
4291 [ - + ]: 9278 : if (copy_to_user(buffer, link, len))
4292 : : len = -EFAULT;
4293 : : out:
4294 : 4639 : return len;
4295 : : }
4296 : :
4297 : : /*
4298 : : * A helper for ->readlink(). This should be used *ONLY* for symlinks that
4299 : : * have ->follow_link() touching nd only in nd_set_link(). Using (or not
4300 : : * using) it for any given inode is up to filesystem.
4301 : : */
4302 : 0 : int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
4303 : : {
4304 : : struct nameidata nd;
4305 : : void *cookie;
4306 : : int res;
4307 : :
4308 : 4639 : nd.depth = 0;
4309 : 4639 : cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
4310 [ - + ]: 9278 : if (IS_ERR(cookie))
4311 : 0 : return PTR_ERR(cookie);
4312 : :
4313 : 4639 : res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
4314 [ + + ]: 4639 : if (dentry->d_inode->i_op->put_link)
4315 : 2956 : dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
4316 : 4639 : return res;
4317 : : }
4318 : :
4319 : : /* get the link contents into pagecache */
4320 : 0 : static char *page_getlink(struct dentry * dentry, struct page **ppage)
4321 : : {
4322 : : char *kaddr;
4323 : : struct page *page;
4324 : 3794 : struct address_space *mapping = dentry->d_inode->i_mapping;
4325 : : page = read_mapping_page(mapping, 0, NULL);
4326 [ + - ]: 3794 : if (IS_ERR(page))
4327 : : return (char*)page;
4328 : 3794 : *ppage = page;
4329 : 3794 : kaddr = kmap(page);
4330 : 3794 : nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
4331 : : return kaddr;
4332 : : }
4333 : :
4334 : 0 : int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
4335 : : {
4336 : 0 : struct page *page = NULL;
4337 : 0 : char *s = page_getlink(dentry, &page);
4338 : 0 : int res = vfs_readlink(dentry,buffer,buflen,s);
4339 [ # # ]: 0 : if (page) {
4340 : 0 : kunmap(page);
4341 : 0 : page_cache_release(page);
4342 : : }
4343 : 0 : return res;
4344 : : }
4345 : :
4346 : 0 : void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
4347 : : {
4348 : 3794 : struct page *page = NULL;
4349 : 3794 : nd_set_link(nd, page_getlink(dentry, &page));
4350 : 3794 : return page;
4351 : : }
4352 : :
4353 : 0 : void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
4354 : : {
4355 : : struct page *page = cookie;
4356 : :
4357 [ + - ]: 3794 : if (page) {
4358 : 3794 : kunmap(page);
4359 : 3794 : page_cache_release(page);
4360 : : }
4361 : 0 : }
4362 : :
4363 : : /*
4364 : : * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
4365 : : */
4366 : 0 : int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
4367 : : {
4368 : 2834 : struct address_space *mapping = inode->i_mapping;
4369 : : struct page *page;
4370 : : void *fsdata;
4371 : : int err;
4372 : : char *kaddr;
4373 : : unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
4374 [ + - ]: 2834 : if (nofs)
4375 : : flags |= AOP_FLAG_NOFS;
4376 : :
4377 : : retry:
4378 : 2834 : err = pagecache_write_begin(NULL, mapping, 0, len-1,
4379 : : flags, &page, &fsdata);
4380 [ + - ]: 5668 : if (err)
4381 : : goto fail;
4382 : :
4383 : 2834 : kaddr = kmap_atomic(page);
4384 : 2834 : memcpy(kaddr, symname, len-1);
4385 : 2834 : kunmap_atomic(kaddr);
4386 : :
4387 : 2834 : err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
4388 : : page, fsdata);
4389 [ + - ]: 2834 : if (err < 0)
4390 : : goto fail;
4391 [ - + ]: 2834 : if (err < len-1)
4392 : : goto retry;
4393 : :
4394 : : mark_inode_dirty(inode);
4395 : 2834 : return 0;
4396 : : fail:
4397 : 0 : return err;
4398 : : }
4399 : :
4400 : 0 : int page_symlink(struct inode *inode, const char *symname, int len)
4401 : : {
4402 : 0 : return __page_symlink(inode, symname, len,
4403 : 0 : !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
4404 : : }
4405 : :
4406 : : const struct inode_operations page_symlink_inode_operations = {
4407 : : .readlink = generic_readlink,
4408 : : .follow_link = page_follow_link_light,
4409 : : .put_link = page_put_link,
4410 : : };
4411 : :
4412 : : EXPORT_SYMBOL(user_path_at);
4413 : : EXPORT_SYMBOL(follow_down_one);
4414 : : EXPORT_SYMBOL(follow_down);
4415 : : EXPORT_SYMBOL(follow_up);
4416 : : EXPORT_SYMBOL(get_write_access); /* nfsd */
4417 : : EXPORT_SYMBOL(lock_rename);
4418 : : EXPORT_SYMBOL(lookup_one_len);
4419 : : EXPORT_SYMBOL(page_follow_link_light);
4420 : : EXPORT_SYMBOL(page_put_link);
4421 : : EXPORT_SYMBOL(page_readlink);
4422 : : EXPORT_SYMBOL(__page_symlink);
4423 : : EXPORT_SYMBOL(page_symlink);
4424 : : EXPORT_SYMBOL(page_symlink_inode_operations);
4425 : : EXPORT_SYMBOL(kern_path);
4426 : : EXPORT_SYMBOL(vfs_path_lookup);
4427 : : EXPORT_SYMBOL(inode_permission);
4428 : : EXPORT_SYMBOL(unlock_rename);
4429 : : EXPORT_SYMBOL(vfs_create);
4430 : : EXPORT_SYMBOL(vfs_link);
4431 : : EXPORT_SYMBOL(vfs_mkdir);
4432 : : EXPORT_SYMBOL(vfs_mknod);
4433 : : EXPORT_SYMBOL(generic_permission);
4434 : : EXPORT_SYMBOL(vfs_readlink);
4435 : : EXPORT_SYMBOL(vfs_rename);
4436 : : EXPORT_SYMBOL(vfs_rmdir);
4437 : : EXPORT_SYMBOL(vfs_symlink);
4438 : : EXPORT_SYMBOL(vfs_unlink);
4439 : : EXPORT_SYMBOL(dentry_unhash);
4440 : : EXPORT_SYMBOL(generic_readlink);
|
