blob: 4521b5ff7c9397ea6159eb75ffbb94f761ba35e5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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/module.h>
19#include <linux/slab.h>
20#include <linux/fs.h>
21#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/pagemap.h>
Robert Love0eeca282005-07-12 17:06:03 -040023#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/personality.h>
25#include <linux/security.h>
Mimi Zohar6146f0d2009-02-04 09:06:57 -050026#include <linux/ima.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/syscalls.h>
28#include <linux/mount.h>
29#include <linux/audit.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080030#include <linux/capability.h>
Trond Myklebust834f2a42005-10-18 14:20:16 -070031#include <linux/file.h>
Ulrich Drepper5590ff02006-01-18 17:43:53 -080032#include <linux/fcntl.h>
Serge E. Hallyn08ce5f12008-04-29 01:00:10 -070033#include <linux/device_cgroup.h>
Al Viro5ad4e532009-03-29 19:50:06 -040034#include <linux/fs_struct.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/uaccess.h>
36
Eric Parise81e3f42009-12-04 15:47:36 -050037#include "internal.h"
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/* [Feb-1997 T. Schoebel-Theuer]
40 * Fundamental changes in the pathname lookup mechanisms (namei)
41 * were necessary because of omirr. The reason is that omirr needs
42 * to know the _real_ pathname, not the user-supplied one, in case
43 * of symlinks (and also when transname replacements occur).
44 *
45 * The new code replaces the old recursive symlink resolution with
46 * an iterative one (in case of non-nested symlink chains). It does
47 * this with calls to <fs>_follow_link().
48 * As a side effect, dir_namei(), _namei() and follow_link() are now
49 * replaced with a single function lookup_dentry() that can handle all
50 * the special cases of the former code.
51 *
52 * With the new dcache, the pathname is stored at each inode, at least as
53 * long as the refcount of the inode is positive. As a side effect, the
54 * size of the dcache depends on the inode cache and thus is dynamic.
55 *
56 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
57 * resolution to correspond with current state of the code.
58 *
59 * Note that the symlink resolution is not *completely* iterative.
60 * There is still a significant amount of tail- and mid- recursion in
61 * the algorithm. Also, note that <fs>_readlink() is not used in
62 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
63 * may return different results than <fs>_follow_link(). Many virtual
64 * filesystems (including /proc) exhibit this behavior.
65 */
66
67/* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
68 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
69 * and the name already exists in form of a symlink, try to create the new
70 * name indicated by the symlink. The old code always complained that the
71 * name already exists, due to not following the symlink even if its target
72 * is nonexistent. The new semantics affects also mknod() and link() when
73 * the name is a symlink pointing to a non-existant name.
74 *
75 * I don't know which semantics is the right one, since I have no access
76 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
77 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
78 * "old" one. Personally, I think the new semantics is much more logical.
79 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
80 * file does succeed in both HP-UX and SunOs, but not in Solaris
81 * and in the old Linux semantics.
82 */
83
84/* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
85 * semantics. See the comments in "open_namei" and "do_link" below.
86 *
87 * [10-Sep-98 Alan Modra] Another symlink change.
88 */
89
90/* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
91 * inside the path - always follow.
92 * in the last component in creation/removal/renaming - never follow.
93 * if LOOKUP_FOLLOW passed - follow.
94 * if the pathname has trailing slashes - follow.
95 * otherwise - don't follow.
96 * (applied in that order).
97 *
98 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
99 * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
100 * During the 2.4 we need to fix the userland stuff depending on it -
101 * hopefully we will be able to get rid of that wart in 2.5. So far only
102 * XEmacs seems to be relying on it...
103 */
104/*
105 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
Arjan van de Vena11f3a02006-03-23 03:00:33 -0800106 * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 * any extra contention...
108 */
109
110/* In order to reduce some races, while at the same time doing additional
111 * checking and hopefully speeding things up, we copy filenames to the
112 * kernel data space before using them..
113 *
114 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
115 * PATH_MAX includes the nul terminator --RR.
116 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800117static int do_getname(const char __user *filename, char *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
119 int retval;
120 unsigned long len = PATH_MAX;
121
122 if (!segment_eq(get_fs(), KERNEL_DS)) {
123 if ((unsigned long) filename >= TASK_SIZE)
124 return -EFAULT;
125 if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
126 len = TASK_SIZE - (unsigned long) filename;
127 }
128
129 retval = strncpy_from_user(page, filename, len);
130 if (retval > 0) {
131 if (retval < len)
132 return 0;
133 return -ENAMETOOLONG;
134 } else if (!retval)
135 retval = -ENOENT;
136 return retval;
137}
138
139char * getname(const char __user * filename)
140{
141 char *tmp, *result;
142
143 result = ERR_PTR(-ENOMEM);
144 tmp = __getname();
145 if (tmp) {
146 int retval = do_getname(filename, tmp);
147
148 result = tmp;
149 if (retval < 0) {
150 __putname(tmp);
151 result = ERR_PTR(retval);
152 }
153 }
154 audit_getname(result);
155 return result;
156}
157
158#ifdef CONFIG_AUDITSYSCALL
159void putname(const char *name)
160{
Al Viro5ac3a9c2006-07-16 06:38:45 -0400161 if (unlikely(!audit_dummy_context()))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 audit_putname(name);
163 else
164 __putname(name);
165}
166EXPORT_SYMBOL(putname);
167#endif
168
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700169/*
170 * This does basic POSIX ACL permission checking
171 */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100172static int acl_permission_check(struct inode *inode, int mask, unsigned int flags,
173 int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700174{
175 umode_t mode = inode->i_mode;
176
177 mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
178
179 if (current_fsuid() == inode->i_uid)
180 mode >>= 6;
181 else {
182 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
Nick Pigginb74c79e2011-01-07 17:49:58 +1100183 int error = check_acl(inode, mask, flags);
184 if (error != -EAGAIN)
185 return error;
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700186 }
187
188 if (in_group_p(inode->i_gid))
189 mode >>= 3;
190 }
191
192 /*
193 * If the DACs are ok we don't need any capability check.
194 */
195 if ((mask & ~mode) == 0)
196 return 0;
197 return -EACCES;
198}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200/**
Nick Pigginb74c79e2011-01-07 17:49:58 +1100201 * generic_permission - check for access rights on a Posix-like filesystem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 * @inode: inode to check access rights for
203 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
204 * @check_acl: optional callback to check for Posix ACLs
Randy Dunlap39191622011-01-08 19:36:21 -0800205 * @flags: IPERM_FLAG_ flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 *
207 * Used to check for read/write/execute permissions on a file.
208 * We use "fsuid" for this, letting us set arbitrary permissions
209 * for filesystem access without changing the "normal" uids which
Nick Pigginb74c79e2011-01-07 17:49:58 +1100210 * are used for other things.
211 *
212 * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
213 * request cannot be satisfied (eg. requires blocking or too much complexity).
214 * It would then be called again in ref-walk mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100216int generic_permission(struct inode *inode, int mask, unsigned int flags,
217 int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700219 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 /*
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700222 * Do the basic POSIX ACL permission checks.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100224 ret = acl_permission_check(inode, mask, flags, check_acl);
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700225 if (ret != -EACCES)
226 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 /*
229 * Read/write DACs are always overridable.
230 * Executable DACs are overridable if at least one exec bit is set.
231 */
Miklos Szeredif696a362008-07-31 13:41:58 +0200232 if (!(mask & MAY_EXEC) || execute_ok(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (capable(CAP_DAC_OVERRIDE))
234 return 0;
235
236 /*
237 * Searching includes executable on directories, else just read.
238 */
Serge E. Hallyn7ea66002009-12-29 14:50:19 -0600239 mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
241 if (capable(CAP_DAC_READ_SEARCH))
242 return 0;
243
244 return -EACCES;
245}
246
Christoph Hellwigcb23beb2008-10-24 09:59:29 +0200247/**
248 * inode_permission - check for access rights to a given inode
249 * @inode: inode to check permission on
250 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
251 *
252 * Used to check for read/write/execute permissions on an inode.
253 * We use "fsuid" for this, letting us set arbitrary permissions
254 * for filesystem access without changing the "normal" uids which
255 * are used for other things.
256 */
Al Virof419a2e2008-07-22 00:07:17 -0400257int inode_permission(struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258{
Al Viroe6305c42008-07-15 21:03:57 -0400259 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 if (mask & MAY_WRITE) {
Miklos Szeredi22590e42007-10-16 23:27:08 -0700262 umode_t mode = inode->i_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 /*
265 * Nobody gets write access to a read-only fs.
266 */
267 if (IS_RDONLY(inode) &&
268 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
269 return -EROFS;
270
271 /*
272 * Nobody gets write access to an immutable file.
273 */
274 if (IS_IMMUTABLE(inode))
275 return -EACCES;
276 }
277
Al Viroacfa4382008-12-04 10:06:33 -0500278 if (inode->i_op->permission)
Nick Pigginb74c79e2011-01-07 17:49:58 +1100279 retval = inode->i_op->permission(inode, mask, 0);
Miklos Szeredif696a362008-07-31 13:41:58 +0200280 else
Nick Pigginb74c79e2011-01-07 17:49:58 +1100281 retval = generic_permission(inode, mask, 0,
282 inode->i_op->check_acl);
Miklos Szeredif696a362008-07-31 13:41:58 +0200283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (retval)
285 return retval;
286
Serge E. Hallyn08ce5f12008-04-29 01:00:10 -0700287 retval = devcgroup_inode_permission(inode, mask);
288 if (retval)
289 return retval;
290
Eric Parisd09ca732010-07-23 11:43:57 -0400291 return security_inode_permission(inode, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
Christoph Hellwige4543ed2005-11-08 21:35:04 -0800294/**
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800295 * file_permission - check for additional access rights to a given file
296 * @file: file to check access rights for
297 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
298 *
299 * Used to check for read/write/execute permissions on an already opened
300 * file.
301 *
302 * Note:
303 * Do not use this function in new code. All access checks should
Christoph Hellwigcb23beb2008-10-24 09:59:29 +0200304 * be done using inode_permission().
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800305 */
306int file_permission(struct file *file, int mask)
307{
Al Virof419a2e2008-07-22 00:07:17 -0400308 return inode_permission(file->f_path.dentry->d_inode, mask);
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311/*
312 * get_write_access() gets write permission for a file.
313 * put_write_access() releases this write permission.
314 * This is used for regular files.
315 * We cannot support write (and maybe mmap read-write shared) accesses and
316 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
317 * can have the following values:
318 * 0: no writers, no VM_DENYWRITE mappings
319 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
320 * > 0: (i_writecount) users are writing to the file.
321 *
322 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
323 * except for the cases where we don't hold i_writecount yet. Then we need to
324 * use {get,deny}_write_access() - these functions check the sign and refuse
325 * to do the change if sign is wrong. Exclusion between them is provided by
326 * the inode->i_lock spinlock.
327 */
328
329int get_write_access(struct inode * inode)
330{
331 spin_lock(&inode->i_lock);
332 if (atomic_read(&inode->i_writecount) < 0) {
333 spin_unlock(&inode->i_lock);
334 return -ETXTBSY;
335 }
336 atomic_inc(&inode->i_writecount);
337 spin_unlock(&inode->i_lock);
338
339 return 0;
340}
341
342int deny_write_access(struct file * file)
343{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800344 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 spin_lock(&inode->i_lock);
347 if (atomic_read(&inode->i_writecount) > 0) {
348 spin_unlock(&inode->i_lock);
349 return -ETXTBSY;
350 }
351 atomic_dec(&inode->i_writecount);
352 spin_unlock(&inode->i_lock);
353
354 return 0;
355}
356
Jan Blunck1d957f92008-02-14 19:34:35 -0800357/**
Jan Blunck5dd784d02008-02-14 19:34:38 -0800358 * path_get - get a reference to a path
359 * @path: path to get the reference to
360 *
361 * Given a path increment the reference count to the dentry and the vfsmount.
362 */
363void path_get(struct path *path)
364{
365 mntget(path->mnt);
366 dget(path->dentry);
367}
368EXPORT_SYMBOL(path_get);
369
370/**
Jan Blunck1d957f92008-02-14 19:34:35 -0800371 * path_put - put a reference to a path
372 * @path: path to put the reference to
373 *
374 * Given a path decrement the reference count to the dentry and the vfsmount.
375 */
376void path_put(struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
Jan Blunck1d957f92008-02-14 19:34:35 -0800378 dput(path->dentry);
379 mntput(path->mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
Jan Blunck1d957f92008-02-14 19:34:35 -0800381EXPORT_SYMBOL(path_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Trond Myklebust834f2a42005-10-18 14:20:16 -0700383/**
Nick Piggin31e6b012011-01-07 17:49:52 +1100384 * nameidata_drop_rcu - drop this nameidata out of rcu-walk
385 * @nd: nameidata pathwalk data to drop
Randy Dunlap39191622011-01-08 19:36:21 -0800386 * Returns: 0 on success, -ECHILD on failure
Nick Piggin31e6b012011-01-07 17:49:52 +1100387 *
388 * Path walking has 2 modes, rcu-walk and ref-walk (see
389 * Documentation/filesystems/path-lookup.txt). __drop_rcu* functions attempt
390 * to drop out of rcu-walk mode and take normal reference counts on dentries
391 * and vfsmounts to transition to rcu-walk mode. __drop_rcu* functions take
392 * refcounts at the last known good point before rcu-walk got stuck, so
393 * ref-walk may continue from there. If this is not successful (eg. a seqcount
394 * has changed), then failure is returned and path walk restarts from the
395 * beginning in ref-walk mode.
396 *
397 * nameidata_drop_rcu attempts to drop the current nd->path and nd->root into
398 * ref-walk. Must be called from rcu-walk context.
399 */
400static int nameidata_drop_rcu(struct nameidata *nd)
401{
402 struct fs_struct *fs = current->fs;
403 struct dentry *dentry = nd->path.dentry;
404
405 BUG_ON(!(nd->flags & LOOKUP_RCU));
406 if (nd->root.mnt) {
407 spin_lock(&fs->lock);
408 if (nd->root.mnt != fs->root.mnt ||
409 nd->root.dentry != fs->root.dentry)
410 goto err_root;
411 }
412 spin_lock(&dentry->d_lock);
413 if (!__d_rcu_to_refcount(dentry, nd->seq))
414 goto err;
415 BUG_ON(nd->inode != dentry->d_inode);
416 spin_unlock(&dentry->d_lock);
417 if (nd->root.mnt) {
418 path_get(&nd->root);
419 spin_unlock(&fs->lock);
420 }
421 mntget(nd->path.mnt);
422
423 rcu_read_unlock();
424 br_read_unlock(vfsmount_lock);
425 nd->flags &= ~LOOKUP_RCU;
426 return 0;
427err:
428 spin_unlock(&dentry->d_lock);
429err_root:
430 if (nd->root.mnt)
431 spin_unlock(&fs->lock);
432 return -ECHILD;
433}
434
435/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing. */
436static inline int nameidata_drop_rcu_maybe(struct nameidata *nd)
437{
438 if (nd->flags & LOOKUP_RCU)
439 return nameidata_drop_rcu(nd);
440 return 0;
441}
442
443/**
444 * nameidata_dentry_drop_rcu - drop nameidata and dentry out of rcu-walk
445 * @nd: nameidata pathwalk data to drop
446 * @dentry: dentry to drop
Randy Dunlap39191622011-01-08 19:36:21 -0800447 * Returns: 0 on success, -ECHILD on failure
Nick Piggin31e6b012011-01-07 17:49:52 +1100448 *
449 * nameidata_dentry_drop_rcu attempts to drop the current nd->path and nd->root,
450 * and dentry into ref-walk. @dentry must be a path found by a do_lookup call on
451 * @nd. Must be called from rcu-walk context.
452 */
453static int nameidata_dentry_drop_rcu(struct nameidata *nd, struct dentry *dentry)
454{
455 struct fs_struct *fs = current->fs;
456 struct dentry *parent = nd->path.dentry;
457
458 BUG_ON(!(nd->flags & LOOKUP_RCU));
459 if (nd->root.mnt) {
460 spin_lock(&fs->lock);
461 if (nd->root.mnt != fs->root.mnt ||
462 nd->root.dentry != fs->root.dentry)
463 goto err_root;
464 }
465 spin_lock(&parent->d_lock);
466 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
467 if (!__d_rcu_to_refcount(dentry, nd->seq))
468 goto err;
469 /*
470 * If the sequence check on the child dentry passed, then the child has
471 * not been removed from its parent. This means the parent dentry must
472 * be valid and able to take a reference at this point.
473 */
474 BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
475 BUG_ON(!parent->d_count);
476 parent->d_count++;
477 spin_unlock(&dentry->d_lock);
478 spin_unlock(&parent->d_lock);
479 if (nd->root.mnt) {
480 path_get(&nd->root);
481 spin_unlock(&fs->lock);
482 }
483 mntget(nd->path.mnt);
484
485 rcu_read_unlock();
486 br_read_unlock(vfsmount_lock);
487 nd->flags &= ~LOOKUP_RCU;
488 return 0;
489err:
490 spin_unlock(&dentry->d_lock);
491 spin_unlock(&parent->d_lock);
492err_root:
493 if (nd->root.mnt)
494 spin_unlock(&fs->lock);
495 return -ECHILD;
496}
497
498/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing. */
499static inline int nameidata_dentry_drop_rcu_maybe(struct nameidata *nd, struct dentry *dentry)
500{
501 if (nd->flags & LOOKUP_RCU)
502 return nameidata_dentry_drop_rcu(nd, dentry);
503 return 0;
504}
505
506/**
507 * nameidata_drop_rcu_last - drop nameidata ending path walk out of rcu-walk
508 * @nd: nameidata pathwalk data to drop
Randy Dunlap39191622011-01-08 19:36:21 -0800509 * Returns: 0 on success, -ECHILD on failure
Nick Piggin31e6b012011-01-07 17:49:52 +1100510 *
511 * nameidata_drop_rcu_last attempts to drop the current nd->path into ref-walk.
512 * nd->path should be the final element of the lookup, so nd->root is discarded.
513 * Must be called from rcu-walk context.
514 */
515static int nameidata_drop_rcu_last(struct nameidata *nd)
516{
517 struct dentry *dentry = nd->path.dentry;
518
519 BUG_ON(!(nd->flags & LOOKUP_RCU));
520 nd->flags &= ~LOOKUP_RCU;
521 nd->root.mnt = NULL;
522 spin_lock(&dentry->d_lock);
523 if (!__d_rcu_to_refcount(dentry, nd->seq))
524 goto err_unlock;
525 BUG_ON(nd->inode != dentry->d_inode);
526 spin_unlock(&dentry->d_lock);
527
528 mntget(nd->path.mnt);
529
530 rcu_read_unlock();
531 br_read_unlock(vfsmount_lock);
532
533 return 0;
534
535err_unlock:
536 spin_unlock(&dentry->d_lock);
537 rcu_read_unlock();
538 br_read_unlock(vfsmount_lock);
539 return -ECHILD;
540}
541
542/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing. */
543static inline int nameidata_drop_rcu_last_maybe(struct nameidata *nd)
544{
545 if (likely(nd->flags & LOOKUP_RCU))
546 return nameidata_drop_rcu_last(nd);
547 return 0;
548}
549
550/**
Trond Myklebust834f2a42005-10-18 14:20:16 -0700551 * release_open_intent - free up open intent resources
552 * @nd: pointer to nameidata
553 */
554void release_open_intent(struct nameidata *nd)
555{
Linus Torvalds2dab5972011-02-11 15:53:38 -0800556 struct file *file = nd->intent.open.file;
557
558 if (file && !IS_ERR(file)) {
559 if (file->f_path.dentry == NULL)
560 put_filp(file);
561 else
562 fput(file);
563 }
Trond Myklebust834f2a42005-10-18 14:20:16 -0700564}
565
Al Virof60aef72011-02-15 01:35:28 -0500566static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
Nick Piggin34286d62011-01-07 17:49:57 +1100567{
Al Virof60aef72011-02-15 01:35:28 -0500568 return dentry->d_op->d_revalidate(dentry, nd);
Nick Piggin34286d62011-01-07 17:49:57 +1100569}
570
Al Virof5e1c1c2011-02-15 01:32:55 -0500571static struct dentry *
Ian Kentbcdc5e02006-09-27 01:50:44 -0700572do_revalidate(struct dentry *dentry, struct nameidata *nd)
573{
Al Virof5e1c1c2011-02-15 01:32:55 -0500574 int status = d_revalidate(dentry, nd);
Ian Kentbcdc5e02006-09-27 01:50:44 -0700575 if (unlikely(status <= 0)) {
576 /*
577 * The dentry failed validation.
578 * If d_revalidate returned 0 attempt to invalidate
579 * the dentry otherwise d_revalidate is asking us
580 * to return a fail status.
581 */
Nick Piggin34286d62011-01-07 17:49:57 +1100582 if (status < 0) {
Al Virof5e1c1c2011-02-15 01:32:55 -0500583 dput(dentry);
Nick Piggin34286d62011-01-07 17:49:57 +1100584 dentry = ERR_PTR(status);
Al Virof5e1c1c2011-02-15 01:32:55 -0500585 } else if (!d_invalidate(dentry)) {
586 dput(dentry);
587 dentry = NULL;
Ian Kentbcdc5e02006-09-27 01:50:44 -0700588 }
589 }
590 return dentry;
591}
592
Al Virof5e1c1c2011-02-15 01:32:55 -0500593static inline struct dentry *
594do_revalidate_rcu(struct dentry *dentry, struct nameidata *nd)
595{
Al Virof60aef72011-02-15 01:35:28 -0500596 int status = d_revalidate(dentry, nd);
Al Virof5e1c1c2011-02-15 01:32:55 -0500597 if (likely(status > 0))
598 return dentry;
599 if (status == -ECHILD) {
600 if (nameidata_dentry_drop_rcu(nd, dentry))
601 return ERR_PTR(-ECHILD);
602 return do_revalidate(dentry, nd);
603 }
604 if (status < 0)
605 return ERR_PTR(status);
606 /* Don't d_invalidate in rcu-walk mode */
607 if (nameidata_dentry_drop_rcu(nd, dentry))
608 return ERR_PTR(-ECHILD);
609 if (!d_invalidate(dentry)) {
610 dput(dentry);
611 dentry = NULL;
612 }
613 return dentry;
614}
615
Nick Pigginfb045ad2011-01-07 17:49:55 +1100616static inline int need_reval_dot(struct dentry *dentry)
617{
618 if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
619 return 0;
620
621 if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
622 return 0;
623
624 return 1;
625}
626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627/*
Jeff Layton39159de2009-12-07 12:01:50 -0500628 * force_reval_path - force revalidation of a dentry
629 *
630 * In some situations the path walking code will trust dentries without
631 * revalidating them. This causes problems for filesystems that depend on
632 * d_revalidate to handle file opens (e.g. NFSv4). When FS_REVAL_DOT is set
633 * (which indicates that it's possible for the dentry to go stale), force
634 * a d_revalidate call before proceeding.
635 *
636 * Returns 0 if the revalidation was successful. If the revalidation fails,
637 * either return the error returned by d_revalidate or -ESTALE if the
638 * revalidation it just returned 0. If d_revalidate returns 0, we attempt to
639 * invalidate the dentry. It's up to the caller to handle putting references
640 * to the path if necessary.
641 */
642static int
643force_reval_path(struct path *path, struct nameidata *nd)
644{
645 int status;
646 struct dentry *dentry = path->dentry;
647
648 /*
649 * only check on filesystems where it's possible for the dentry to
Nick Pigginfb045ad2011-01-07 17:49:55 +1100650 * become stale.
Jeff Layton39159de2009-12-07 12:01:50 -0500651 */
Nick Pigginfb045ad2011-01-07 17:49:55 +1100652 if (!need_reval_dot(dentry))
Jeff Layton39159de2009-12-07 12:01:50 -0500653 return 0;
654
Nick Piggin34286d62011-01-07 17:49:57 +1100655 status = d_revalidate(dentry, nd);
Jeff Layton39159de2009-12-07 12:01:50 -0500656 if (status > 0)
657 return 0;
658
659 if (!status) {
660 d_invalidate(dentry);
661 status = -ESTALE;
662 }
663 return status;
664}
665
666/*
Al Virob75b5082009-12-16 01:01:38 -0500667 * Short-cut version of permission(), for calling on directories
668 * during pathname resolution. Combines parts of permission()
669 * and generic_permission(), and tests ONLY for MAY_EXEC permission.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 *
671 * If appropriate, check DAC only. If not appropriate, or
Al Virob75b5082009-12-16 01:01:38 -0500672 * short-cut DAC fails, then call ->permission() to do more
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 * complete permission check.
674 */
Nick Pigginb74c79e2011-01-07 17:49:58 +1100675static inline int exec_permission(struct inode *inode, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700677 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Linus Torvaldscb9179e2009-08-28 11:08:31 -0700679 if (inode->i_op->permission) {
Nick Pigginb74c79e2011-01-07 17:49:58 +1100680 ret = inode->i_op->permission(inode, MAY_EXEC, flags);
681 } else {
682 ret = acl_permission_check(inode, MAY_EXEC, flags,
683 inode->i_op->check_acl);
Linus Torvaldscb9179e2009-08-28 11:08:31 -0700684 }
Nick Pigginb74c79e2011-01-07 17:49:58 +1100685 if (likely(!ret))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 goto ok;
Nick Pigginb74c79e2011-01-07 17:49:58 +1100687 if (ret == -ECHILD)
Nick Piggin31e6b012011-01-07 17:49:52 +1100688 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Linus Torvaldsf1ac9f62009-08-28 10:53:56 -0700690 if (capable(CAP_DAC_OVERRIDE) || capable(CAP_DAC_READ_SEARCH))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 goto ok;
692
Linus Torvalds5909ccaa2009-08-28 11:51:25 -0700693 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694ok:
Nick Pigginb74c79e2011-01-07 17:49:58 +1100695 return security_inode_exec_permission(inode, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
Al Viro2a737872009-04-07 11:49:53 -0400698static __always_inline void set_root(struct nameidata *nd)
699{
Miklos Szeredif7ad3c62010-08-10 11:41:36 +0200700 if (!nd->root.mnt)
701 get_fs_root(current->fs, &nd->root);
Al Viro2a737872009-04-07 11:49:53 -0400702}
703
Al Viro6de88d72009-08-09 01:41:57 +0400704static int link_path_walk(const char *, struct nameidata *);
705
Nick Piggin31e6b012011-01-07 17:49:52 +1100706static __always_inline void set_root_rcu(struct nameidata *nd)
707{
708 if (!nd->root.mnt) {
709 struct fs_struct *fs = current->fs;
Nick Pigginc28cc362011-01-07 17:49:53 +1100710 unsigned seq;
711
712 do {
713 seq = read_seqcount_begin(&fs->seq);
714 nd->root = fs->root;
715 } while (read_seqcount_retry(&fs->seq, seq));
Nick Piggin31e6b012011-01-07 17:49:52 +1100716 }
717}
718
Arjan van de Venf1662352006-01-14 13:21:31 -0800719static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
Nick Piggin31e6b012011-01-07 17:49:52 +1100721 int ret;
722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 if (IS_ERR(link))
724 goto fail;
725
726 if (*link == '/') {
Al Viro2a737872009-04-07 11:49:53 -0400727 set_root(nd);
Jan Blunck1d957f92008-02-14 19:34:35 -0800728 path_put(&nd->path);
Al Viro2a737872009-04-07 11:49:53 -0400729 nd->path = nd->root;
730 path_get(&nd->root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 }
Nick Piggin31e6b012011-01-07 17:49:52 +1100732 nd->inode = nd->path.dentry->d_inode;
Christoph Hellwigb4091d52008-11-05 15:07:21 +0100733
Nick Piggin31e6b012011-01-07 17:49:52 +1100734 ret = link_path_walk(link, nd);
735 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736fail:
Jan Blunck1d957f92008-02-14 19:34:35 -0800737 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 return PTR_ERR(link);
739}
740
Jan Blunck1d957f92008-02-14 19:34:35 -0800741static void path_put_conditional(struct path *path, struct nameidata *nd)
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700742{
743 dput(path->dentry);
Jan Blunck4ac91372008-02-14 19:34:32 -0800744 if (path->mnt != nd->path.mnt)
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700745 mntput(path->mnt);
746}
747
Nick Piggin7b9337a2011-01-14 08:42:43 +0000748static inline void path_to_nameidata(const struct path *path,
749 struct nameidata *nd)
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700750{
Nick Piggin31e6b012011-01-07 17:49:52 +1100751 if (!(nd->flags & LOOKUP_RCU)) {
752 dput(nd->path.dentry);
753 if (nd->path.mnt != path->mnt)
754 mntput(nd->path.mnt);
Huang Shijie9a229682010-04-02 17:37:13 +0800755 }
Nick Piggin31e6b012011-01-07 17:49:52 +1100756 nd->path.mnt = path->mnt;
Jan Blunck4ac91372008-02-14 19:34:32 -0800757 nd->path.dentry = path->dentry;
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700758}
759
Al Virodef4af32009-12-26 08:37:05 -0500760static __always_inline int
Nick Piggin7b9337a2011-01-14 08:42:43 +0000761__do_follow_link(const struct path *link, struct nameidata *nd, void **p)
Ian Kent051d3812006-03-27 01:14:53 -0800762{
763 int error;
Nick Piggin7b9337a2011-01-14 08:42:43 +0000764 struct dentry *dentry = link->dentry;
Ian Kent051d3812006-03-27 01:14:53 -0800765
Al Viro844a3912011-02-15 00:38:26 -0500766 BUG_ON(nd->flags & LOOKUP_RCU);
767
Nick Piggin7b9337a2011-01-14 08:42:43 +0000768 touch_atime(link->mnt, dentry);
Ian Kent051d3812006-03-27 01:14:53 -0800769 nd_set_link(nd, NULL);
770
David Howells87556ef2011-01-14 18:46:46 +0000771 if (link->mnt == nd->path.mnt)
772 mntget(link->mnt);
Nick Piggin31e6b012011-01-07 17:49:52 +1100773
Al Viro86acdca12009-12-22 23:45:11 -0500774 nd->last_type = LAST_BIND;
Al Virodef4af32009-12-26 08:37:05 -0500775 *p = dentry->d_inode->i_op->follow_link(dentry, nd);
776 error = PTR_ERR(*p);
777 if (!IS_ERR(*p)) {
Ian Kent051d3812006-03-27 01:14:53 -0800778 char *s = nd_get_link(nd);
779 error = 0;
780 if (s)
781 error = __vfs_follow_link(nd, s);
Jeff Layton39159de2009-12-07 12:01:50 -0500782 else if (nd->last_type == LAST_BIND) {
783 error = force_reval_path(&nd->path, nd);
784 if (error)
785 path_put(&nd->path);
786 }
Ian Kent051d3812006-03-27 01:14:53 -0800787 }
Ian Kent051d3812006-03-27 01:14:53 -0800788 return error;
789}
790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791/*
792 * This limits recursive symlink follows to 8, while
793 * limiting consecutive symlinks to 40.
794 *
795 * Without that kind of total limit, nasty chains of consecutive
796 * symlinks can cause almost arbitrarily long lookups.
797 */
Linus Torvalds3abb17e2011-02-16 08:56:55 -0800798static inline int do_follow_link(struct inode *inode, struct path *path, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799{
Al Virodef4af32009-12-26 08:37:05 -0500800 void *cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 int err = -ELOOP;
Al Viro844a3912011-02-15 00:38:26 -0500802
803 /* We drop rcu-walk here */
804 if (nameidata_dentry_drop_rcu_maybe(nd, path->dentry))
805 return -ECHILD;
Linus Torvalds3abb17e2011-02-16 08:56:55 -0800806 BUG_ON(inode != path->dentry->d_inode);
Al Viro844a3912011-02-15 00:38:26 -0500807
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 if (current->link_count >= MAX_NESTED_LINKS)
809 goto loop;
810 if (current->total_link_count >= 40)
811 goto loop;
812 BUG_ON(nd->depth >= MAX_NESTED_LINKS);
813 cond_resched();
Al Viro90ebe562005-06-06 13:35:58 -0700814 err = security_inode_follow_link(path->dentry, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 if (err)
816 goto loop;
817 current->link_count++;
818 current->total_link_count++;
819 nd->depth++;
Al Virodef4af32009-12-26 08:37:05 -0500820 err = __do_follow_link(path, nd, &cookie);
821 if (!IS_ERR(cookie) && path->dentry->d_inode->i_op->put_link)
822 path->dentry->d_inode->i_op->put_link(path->dentry, nd, cookie);
Al Viro258fa992009-08-09 01:32:02 +0400823 path_put(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 current->link_count--;
825 nd->depth--;
826 return err;
827loop:
Jan Blunck1d957f92008-02-14 19:34:35 -0800828 path_put_conditional(path, nd);
829 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 return err;
831}
832
Nick Piggin31e6b012011-01-07 17:49:52 +1100833static int follow_up_rcu(struct path *path)
834{
835 struct vfsmount *parent;
836 struct dentry *mountpoint;
837
838 parent = path->mnt->mnt_parent;
839 if (parent == path->mnt)
840 return 0;
841 mountpoint = path->mnt->mnt_mountpoint;
842 path->dentry = mountpoint;
843 path->mnt = parent;
844 return 1;
845}
846
Al Virobab77eb2009-04-18 03:26:48 -0400847int follow_up(struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
849 struct vfsmount *parent;
850 struct dentry *mountpoint;
Nick Piggin99b7db72010-08-18 04:37:39 +1000851
852 br_read_lock(vfsmount_lock);
Al Virobab77eb2009-04-18 03:26:48 -0400853 parent = path->mnt->mnt_parent;
854 if (parent == path->mnt) {
Nick Piggin99b7db72010-08-18 04:37:39 +1000855 br_read_unlock(vfsmount_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return 0;
857 }
858 mntget(parent);
Al Virobab77eb2009-04-18 03:26:48 -0400859 mountpoint = dget(path->mnt->mnt_mountpoint);
Nick Piggin99b7db72010-08-18 04:37:39 +1000860 br_read_unlock(vfsmount_lock);
Al Virobab77eb2009-04-18 03:26:48 -0400861 dput(path->dentry);
862 path->dentry = mountpoint;
863 mntput(path->mnt);
864 path->mnt = parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return 1;
866}
867
Nick Pigginb5c84bf2011-01-07 17:49:38 +1100868/*
David Howells9875cf82011-01-14 18:45:21 +0000869 * Perform an automount
870 * - return -EISDIR to tell follow_managed() to stop and return the path we
871 * were called with.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 */
David Howells9875cf82011-01-14 18:45:21 +0000873static int follow_automount(struct path *path, unsigned flags,
874 bool *need_mntput)
Nick Piggin31e6b012011-01-07 17:49:52 +1100875{
David Howells9875cf82011-01-14 18:45:21 +0000876 struct vfsmount *mnt;
David Howellsea5b7782011-01-14 19:10:03 +0000877 int err;
Nick Piggin31e6b012011-01-07 17:49:52 +1100878
David Howells9875cf82011-01-14 18:45:21 +0000879 if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
880 return -EREMOTE;
Al Viro463ffb22005-06-06 13:36:05 -0700881
David Howells6f45b652011-01-14 18:45:31 +0000882 /* We don't want to mount if someone supplied AT_NO_AUTOMOUNT
883 * and this is the terminal part of the path.
884 */
885 if ((flags & LOOKUP_NO_AUTOMOUNT) && !(flags & LOOKUP_CONTINUE))
886 return -EISDIR; /* we actually want to stop here */
887
David Howells9875cf82011-01-14 18:45:21 +0000888 /* We want to mount if someone is trying to open/create a file of any
889 * type under the mountpoint, wants to traverse through the mountpoint
890 * or wants to open the mounted directory.
891 *
892 * We don't want to mount if someone's just doing a stat and they've
893 * set AT_SYMLINK_NOFOLLOW - unless they're stat'ing a directory and
894 * appended a '/' to the name.
895 */
896 if (!(flags & LOOKUP_FOLLOW) &&
897 !(flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY |
898 LOOKUP_OPEN | LOOKUP_CREATE)))
899 return -EISDIR;
900
901 current->total_link_count++;
902 if (current->total_link_count >= 40)
903 return -ELOOP;
904
905 mnt = path->dentry->d_op->d_automount(path);
906 if (IS_ERR(mnt)) {
907 /*
908 * The filesystem is allowed to return -EISDIR here to indicate
909 * it doesn't want to automount. For instance, autofs would do
910 * this so that its userspace daemon can mount on this dentry.
911 *
912 * However, we can only permit this if it's a terminal point in
913 * the path being looked up; if it wasn't then the remainder of
914 * the path is inaccessible and we should say so.
915 */
916 if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_CONTINUE))
917 return -EREMOTE;
918 return PTR_ERR(mnt);
919 }
David Howellsea5b7782011-01-14 19:10:03 +0000920
David Howells9875cf82011-01-14 18:45:21 +0000921 if (!mnt) /* mount collision */
922 return 0;
923
Al Viro19a167a2011-01-17 01:35:23 -0500924 err = finish_automount(mnt, path);
David Howellsea5b7782011-01-14 19:10:03 +0000925
David Howellsea5b7782011-01-14 19:10:03 +0000926 switch (err) {
927 case -EBUSY:
928 /* Someone else made a mount here whilst we were busy */
Al Viro19a167a2011-01-17 01:35:23 -0500929 return 0;
David Howellsea5b7782011-01-14 19:10:03 +0000930 case 0:
David Howellsea5b7782011-01-14 19:10:03 +0000931 dput(path->dentry);
932 if (*need_mntput)
933 mntput(path->mnt);
934 path->mnt = mnt;
935 path->dentry = dget(mnt->mnt_root);
936 *need_mntput = true;
937 return 0;
Al Viro19a167a2011-01-17 01:35:23 -0500938 default:
939 return err;
David Howellsea5b7782011-01-14 19:10:03 +0000940 }
Al Viro19a167a2011-01-17 01:35:23 -0500941
David Howells9875cf82011-01-14 18:45:21 +0000942}
943
944/*
945 * Handle a dentry that is managed in some way.
David Howellscc53ce52011-01-14 18:45:26 +0000946 * - Flagged for transit management (autofs)
David Howells9875cf82011-01-14 18:45:21 +0000947 * - Flagged as mountpoint
948 * - Flagged as automount point
949 *
950 * This may only be called in refwalk mode.
951 *
952 * Serialization is taken care of in namespace.c
953 */
954static int follow_managed(struct path *path, unsigned flags)
955{
956 unsigned managed;
957 bool need_mntput = false;
958 int ret;
959
960 /* Given that we're not holding a lock here, we retain the value in a
961 * local variable for each dentry as we look at it so that we don't see
962 * the components of that value change under us */
963 while (managed = ACCESS_ONCE(path->dentry->d_flags),
964 managed &= DCACHE_MANAGED_DENTRY,
965 unlikely(managed != 0)) {
David Howellscc53ce52011-01-14 18:45:26 +0000966 /* Allow the filesystem to manage the transit without i_mutex
967 * being held. */
968 if (managed & DCACHE_MANAGE_TRANSIT) {
969 BUG_ON(!path->dentry->d_op);
970 BUG_ON(!path->dentry->d_op->d_manage);
David Howellsab909112011-01-14 18:46:51 +0000971 ret = path->dentry->d_op->d_manage(path->dentry,
972 false, false);
David Howellscc53ce52011-01-14 18:45:26 +0000973 if (ret < 0)
974 return ret == -EISDIR ? 0 : ret;
975 }
976
David Howells9875cf82011-01-14 18:45:21 +0000977 /* Transit to a mounted filesystem. */
978 if (managed & DCACHE_MOUNTED) {
979 struct vfsmount *mounted = lookup_mnt(path);
980 if (mounted) {
981 dput(path->dentry);
982 if (need_mntput)
983 mntput(path->mnt);
984 path->mnt = mounted;
985 path->dentry = dget(mounted->mnt_root);
986 need_mntput = true;
987 continue;
988 }
989
990 /* Something is mounted on this dentry in another
991 * namespace and/or whatever was mounted there in this
992 * namespace got unmounted before we managed to get the
993 * vfsmount_lock */
994 }
995
996 /* Handle an automount point */
997 if (managed & DCACHE_NEED_AUTOMOUNT) {
998 ret = follow_automount(path, flags, &need_mntput);
999 if (ret < 0)
1000 return ret == -EISDIR ? 0 : ret;
1001 continue;
1002 }
1003
1004 /* We didn't change the current path point */
1005 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
David Howells9875cf82011-01-14 18:45:21 +00001007 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
David Howellscc53ce52011-01-14 18:45:26 +00001010int follow_down_one(struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011{
1012 struct vfsmount *mounted;
1013
Al Viro1c755af2009-04-18 14:06:57 -04001014 mounted = lookup_mnt(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (mounted) {
Al Viro9393bd02009-04-18 13:58:15 -04001016 dput(path->dentry);
1017 mntput(path->mnt);
1018 path->mnt = mounted;
1019 path->dentry = dget(mounted->mnt_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 return 1;
1021 }
1022 return 0;
1023}
1024
David Howells9875cf82011-01-14 18:45:21 +00001025/*
1026 * Skip to top of mountpoint pile in rcuwalk mode. We abort the rcu-walk if we
David Howellscc53ce52011-01-14 18:45:26 +00001027 * meet a managed dentry and we're not walking to "..". True is returned to
David Howells9875cf82011-01-14 18:45:21 +00001028 * continue, false to abort.
1029 */
1030static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
1031 struct inode **inode, bool reverse_transit)
1032{
1033 while (d_mountpoint(path->dentry)) {
1034 struct vfsmount *mounted;
David Howellsab909112011-01-14 18:46:51 +00001035 if (unlikely(path->dentry->d_flags & DCACHE_MANAGE_TRANSIT) &&
1036 !reverse_transit &&
1037 path->dentry->d_op->d_manage(path->dentry, false, true) < 0)
1038 return false;
David Howells9875cf82011-01-14 18:45:21 +00001039 mounted = __lookup_mnt(path->mnt, path->dentry, 1);
1040 if (!mounted)
1041 break;
1042 path->mnt = mounted;
1043 path->dentry = mounted->mnt_root;
1044 nd->seq = read_seqcount_begin(&path->dentry->d_seq);
1045 *inode = path->dentry->d_inode;
1046 }
1047
1048 if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1049 return reverse_transit;
1050 return true;
1051}
1052
Nick Piggin31e6b012011-01-07 17:49:52 +11001053static int follow_dotdot_rcu(struct nameidata *nd)
1054{
1055 struct inode *inode = nd->inode;
1056
1057 set_root_rcu(nd);
1058
David Howells9875cf82011-01-14 18:45:21 +00001059 while (1) {
Nick Piggin31e6b012011-01-07 17:49:52 +11001060 if (nd->path.dentry == nd->root.dentry &&
1061 nd->path.mnt == nd->root.mnt) {
1062 break;
1063 }
1064 if (nd->path.dentry != nd->path.mnt->mnt_root) {
1065 struct dentry *old = nd->path.dentry;
1066 struct dentry *parent = old->d_parent;
1067 unsigned seq;
1068
1069 seq = read_seqcount_begin(&parent->d_seq);
1070 if (read_seqcount_retry(&old->d_seq, nd->seq))
1071 return -ECHILD;
1072 inode = parent->d_inode;
1073 nd->path.dentry = parent;
1074 nd->seq = seq;
1075 break;
1076 }
1077 if (!follow_up_rcu(&nd->path))
1078 break;
1079 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1080 inode = nd->path.dentry->d_inode;
1081 }
David Howells9875cf82011-01-14 18:45:21 +00001082 __follow_mount_rcu(nd, &nd->path, &inode, true);
Nick Piggin31e6b012011-01-07 17:49:52 +11001083 nd->inode = inode;
1084
1085 return 0;
1086}
1087
David Howells9875cf82011-01-14 18:45:21 +00001088/*
David Howellscc53ce52011-01-14 18:45:26 +00001089 * Follow down to the covering mount currently visible to userspace. At each
1090 * point, the filesystem owning that dentry may be queried as to whether the
1091 * caller is permitted to proceed or not.
1092 *
1093 * Care must be taken as namespace_sem may be held (indicated by mounting_here
1094 * being true).
1095 */
1096int follow_down(struct path *path, bool mounting_here)
1097{
1098 unsigned managed;
1099 int ret;
1100
1101 while (managed = ACCESS_ONCE(path->dentry->d_flags),
1102 unlikely(managed & DCACHE_MANAGED_DENTRY)) {
1103 /* Allow the filesystem to manage the transit without i_mutex
1104 * being held.
1105 *
1106 * We indicate to the filesystem if someone is trying to mount
1107 * something here. This gives autofs the chance to deny anyone
1108 * other than its daemon the right to mount on its
1109 * superstructure.
1110 *
1111 * The filesystem may sleep at this point.
1112 */
1113 if (managed & DCACHE_MANAGE_TRANSIT) {
1114 BUG_ON(!path->dentry->d_op);
1115 BUG_ON(!path->dentry->d_op->d_manage);
David Howellsab909112011-01-14 18:46:51 +00001116 ret = path->dentry->d_op->d_manage(
1117 path->dentry, mounting_here, false);
David Howellscc53ce52011-01-14 18:45:26 +00001118 if (ret < 0)
1119 return ret == -EISDIR ? 0 : ret;
1120 }
1121
1122 /* Transit to a mounted filesystem. */
1123 if (managed & DCACHE_MOUNTED) {
1124 struct vfsmount *mounted = lookup_mnt(path);
1125 if (!mounted)
1126 break;
1127 dput(path->dentry);
1128 mntput(path->mnt);
1129 path->mnt = mounted;
1130 path->dentry = dget(mounted->mnt_root);
1131 continue;
1132 }
1133
1134 /* Don't handle automount points here */
1135 break;
1136 }
1137 return 0;
1138}
1139
1140/*
David Howells9875cf82011-01-14 18:45:21 +00001141 * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1142 */
1143static void follow_mount(struct path *path)
1144{
1145 while (d_mountpoint(path->dentry)) {
1146 struct vfsmount *mounted = lookup_mnt(path);
1147 if (!mounted)
1148 break;
1149 dput(path->dentry);
1150 mntput(path->mnt);
1151 path->mnt = mounted;
1152 path->dentry = dget(mounted->mnt_root);
1153 }
1154}
1155
Nick Piggin31e6b012011-01-07 17:49:52 +11001156static void follow_dotdot(struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157{
Al Viro2a737872009-04-07 11:49:53 -04001158 set_root(nd);
Andreas Mohre518ddb2006-09-29 02:01:22 -07001159
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 while(1) {
Jan Blunck4ac91372008-02-14 19:34:32 -08001161 struct dentry *old = nd->path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Al Viro2a737872009-04-07 11:49:53 -04001163 if (nd->path.dentry == nd->root.dentry &&
1164 nd->path.mnt == nd->root.mnt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 break;
1166 }
Jan Blunck4ac91372008-02-14 19:34:32 -08001167 if (nd->path.dentry != nd->path.mnt->mnt_root) {
Al Viro3088dd72010-01-30 15:47:29 -05001168 /* rare case of legitimate dget_parent()... */
1169 nd->path.dentry = dget_parent(nd->path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 dput(old);
1171 break;
1172 }
Al Viro3088dd72010-01-30 15:47:29 -05001173 if (!follow_up(&nd->path))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
Al Viro79ed0222009-04-18 13:59:41 -04001176 follow_mount(&nd->path);
Nick Piggin31e6b012011-01-07 17:49:52 +11001177 nd->inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178}
1179
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180/*
Nick Pigginbaa03892010-08-18 04:37:31 +10001181 * Allocate a dentry with name and parent, and perform a parent
1182 * directory ->lookup on it. Returns the new dentry, or ERR_PTR
1183 * on error. parent->d_inode->i_mutex must be held. d_lookup must
1184 * have verified that no child exists while under i_mutex.
1185 */
1186static struct dentry *d_alloc_and_lookup(struct dentry *parent,
1187 struct qstr *name, struct nameidata *nd)
1188{
1189 struct inode *inode = parent->d_inode;
1190 struct dentry *dentry;
1191 struct dentry *old;
1192
1193 /* Don't create child dentry for a dead directory. */
1194 if (unlikely(IS_DEADDIR(inode)))
1195 return ERR_PTR(-ENOENT);
1196
1197 dentry = d_alloc(parent, name);
1198 if (unlikely(!dentry))
1199 return ERR_PTR(-ENOMEM);
1200
1201 old = inode->i_op->lookup(inode, dentry, nd);
1202 if (unlikely(old)) {
1203 dput(dentry);
1204 dentry = old;
1205 }
1206 return dentry;
1207}
1208
1209/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 * It's more convoluted than I'd like it to be, but... it's still fairly
1211 * small and for now I'd prefer to have fast path as straight as possible.
1212 * It _is_ time-critical.
1213 */
1214static int do_lookup(struct nameidata *nd, struct qstr *name,
Nick Piggin31e6b012011-01-07 17:49:52 +11001215 struct path *path, struct inode **inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216{
Jan Blunck4ac91372008-02-14 19:34:32 -08001217 struct vfsmount *mnt = nd->path.mnt;
Nick Piggin31e6b012011-01-07 17:49:52 +11001218 struct dentry *dentry, *parent = nd->path.dentry;
Al Viro6e6b1bd2009-08-13 23:38:37 +04001219 struct inode *dir;
David Howells9875cf82011-01-14 18:45:21 +00001220 int err;
1221
Al Viro3cac2602009-08-13 18:27:43 +04001222 /*
1223 * See if the low-level filesystem might want
1224 * to use its own hash..
1225 */
Nick Pigginfb045ad2011-01-07 17:49:55 +11001226 if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
David Howells9875cf82011-01-14 18:45:21 +00001227 err = parent->d_op->d_hash(parent, nd->inode, name);
Al Viro3cac2602009-08-13 18:27:43 +04001228 if (err < 0)
1229 return err;
1230 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
Nick Pigginb04f7842010-08-18 04:37:34 +10001232 /*
1233 * Rename seqlock is not required here because in the off chance
1234 * of a false negative due to a concurrent rename, we're going to
1235 * do the non-racy lookup, below.
1236 */
Nick Piggin31e6b012011-01-07 17:49:52 +11001237 if (nd->flags & LOOKUP_RCU) {
1238 unsigned seq;
1239
1240 *inode = nd->inode;
1241 dentry = __d_lookup_rcu(parent, name, &seq, inode);
1242 if (!dentry) {
1243 if (nameidata_drop_rcu(nd))
1244 return -ECHILD;
1245 goto need_lookup;
1246 }
1247 /* Memory barrier in read_seqcount_begin of child is enough */
1248 if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1249 return -ECHILD;
1250
1251 nd->seq = seq;
Al Viro24643082011-02-15 01:26:22 -05001252 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
Al Virof5e1c1c2011-02-15 01:32:55 -05001253 dentry = do_revalidate_rcu(dentry, nd);
Al Viro24643082011-02-15 01:26:22 -05001254 if (!dentry)
1255 goto need_lookup;
1256 if (IS_ERR(dentry))
1257 goto fail;
1258 if (!(nd->flags & LOOKUP_RCU))
1259 goto done;
1260 }
Nick Piggin31e6b012011-01-07 17:49:52 +11001261 path->mnt = mnt;
1262 path->dentry = dentry;
David Howells9875cf82011-01-14 18:45:21 +00001263 if (likely(__follow_mount_rcu(nd, path, inode, false)))
1264 return 0;
1265 if (nameidata_drop_rcu(nd))
1266 return -ECHILD;
1267 /* fallthru */
Nick Piggin31e6b012011-01-07 17:49:52 +11001268 }
David Howells9875cf82011-01-14 18:45:21 +00001269 dentry = __d_lookup(parent, name);
1270 if (!dentry)
1271 goto need_lookup;
1272found:
Al Viro24643082011-02-15 01:26:22 -05001273 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1274 dentry = do_revalidate(dentry, nd);
1275 if (!dentry)
1276 goto need_lookup;
1277 if (IS_ERR(dentry))
1278 goto fail;
1279 }
David Howells9875cf82011-01-14 18:45:21 +00001280done:
1281 path->mnt = mnt;
1282 path->dentry = dentry;
1283 err = follow_managed(path, nd->flags);
Ian Kent89312212011-01-18 12:06:10 +08001284 if (unlikely(err < 0)) {
1285 path_put_conditional(path, nd);
David Howells9875cf82011-01-14 18:45:21 +00001286 return err;
Ian Kent89312212011-01-18 12:06:10 +08001287 }
David Howells9875cf82011-01-14 18:45:21 +00001288 *inode = path->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 return 0;
1290
1291need_lookup:
Al Viro6e6b1bd2009-08-13 23:38:37 +04001292 dir = parent->d_inode;
Nick Piggin31e6b012011-01-07 17:49:52 +11001293 BUG_ON(nd->inode != dir);
Al Viro6e6b1bd2009-08-13 23:38:37 +04001294
1295 mutex_lock(&dir->i_mutex);
1296 /*
1297 * First re-do the cached lookup just in case it was created
Nick Pigginb04f7842010-08-18 04:37:34 +10001298 * while we waited for the directory semaphore, or the first
1299 * lookup failed due to an unrelated rename.
Al Viro6e6b1bd2009-08-13 23:38:37 +04001300 *
Nick Pigginb04f7842010-08-18 04:37:34 +10001301 * This could use version numbering or similar to avoid unnecessary
1302 * cache lookups, but then we'd have to do the first lookup in the
1303 * non-racy way. However in the common case here, everything should
1304 * be hot in cache, so would it be a big win?
Al Viro6e6b1bd2009-08-13 23:38:37 +04001305 */
1306 dentry = d_lookup(parent, name);
Nick Pigginbaa03892010-08-18 04:37:31 +10001307 if (likely(!dentry)) {
1308 dentry = d_alloc_and_lookup(parent, name, nd);
Al Viro6e6b1bd2009-08-13 23:38:37 +04001309 mutex_unlock(&dir->i_mutex);
1310 if (IS_ERR(dentry))
1311 goto fail;
1312 goto done;
1313 }
Al Viro6e6b1bd2009-08-13 23:38:37 +04001314 /*
1315 * Uhhuh! Nasty case: the cache was re-populated while
1316 * we waited on the semaphore. Need to revalidate.
1317 */
1318 mutex_unlock(&dir->i_mutex);
Nick Piggin2e2e88e2010-08-18 04:37:30 +10001319 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321fail:
1322 return PTR_ERR(dentry);
1323}
1324
Al Viro52094c82011-02-21 21:34:47 -05001325static inline int may_lookup(struct nameidata *nd)
1326{
1327 if (nd->flags & LOOKUP_RCU) {
1328 int err = exec_permission(nd->inode, IPERM_FLAG_RCU);
1329 if (err != -ECHILD)
1330 return err;
1331 if (nameidata_drop_rcu(nd))
1332 return -ECHILD;
1333 }
1334 return exec_permission(nd->inode, 0);
1335}
1336
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337/*
1338 * Name resolution.
Prasanna Medaea3834d2005-04-29 16:00:17 +01001339 * This is the basic name resolution function, turning a pathname into
1340 * the final dentry. We expect 'base' to be positive and a directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 *
Prasanna Medaea3834d2005-04-29 16:00:17 +01001342 * Returns 0 and nd will have valid dentry and mnt on success.
1343 * Returns error and drops reference to input namei data on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 */
Al Viro6de88d72009-08-09 01:41:57 +04001345static int link_path_walk(const char *name, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
1347 struct path next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 int err;
1349 unsigned int lookup_flags = nd->flags;
1350
1351 while (*name=='/')
1352 name++;
1353 if (!*name)
1354 goto return_reval;
1355
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 if (nd->depth)
Trond Myklebustf55eab82006-02-04 23:28:01 -08001357 lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 /* At this point we know we have a real path component. */
1360 for(;;) {
Nick Piggin31e6b012011-01-07 17:49:52 +11001361 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 unsigned long hash;
1363 struct qstr this;
1364 unsigned int c;
Al Virofe479a52011-02-22 15:10:03 -05001365 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
Trond Myklebustcdce5d62005-10-18 14:20:18 -07001367 nd->flags |= LOOKUP_CONTINUE;
Al Viro52094c82011-02-21 21:34:47 -05001368
1369 err = may_lookup(nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 if (err)
1371 break;
1372
1373 this.name = name;
1374 c = *(const unsigned char *)name;
1375
1376 hash = init_name_hash();
1377 do {
1378 name++;
1379 hash = partial_name_hash(c, hash);
1380 c = *(const unsigned char *)name;
1381 } while (c && (c != '/'));
1382 this.len = name - (const char *) this.name;
1383 this.hash = end_name_hash(hash);
1384
Al Virofe479a52011-02-22 15:10:03 -05001385 type = LAST_NORM;
1386 if (this.name[0] == '.') switch (this.len) {
1387 case 2:
1388 if (this.name[1] == '.')
1389 type = LAST_DOTDOT;
1390 break;
1391 case 1:
1392 type = LAST_DOT;
1393 }
1394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 /* remove trailing slashes? */
1396 if (!c)
1397 goto last_component;
1398 while (*++name == '/');
1399 if (!*name)
1400 goto last_with_slashes;
1401
1402 /*
1403 * "." and ".." are special - ".." especially so because it has
1404 * to be able to know about the current root directory and
1405 * parent relationships.
1406 */
Al Virofe479a52011-02-22 15:10:03 -05001407 if (unlikely(type != LAST_NORM)) {
1408 if (type == LAST_DOTDOT) {
Nick Piggin31e6b012011-01-07 17:49:52 +11001409 if (nd->flags & LOOKUP_RCU) {
1410 if (follow_dotdot_rcu(nd))
1411 return -ECHILD;
1412 } else
1413 follow_dotdot(nd);
Al Virofe479a52011-02-22 15:10:03 -05001414 }
1415 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 }
Al Virofe479a52011-02-22 15:10:03 -05001417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 /* This does the actual lookups.. */
Nick Piggin31e6b012011-01-07 17:49:52 +11001419 err = do_lookup(nd, &this, &next, &inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (err)
1421 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 err = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 if (!inode)
1424 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
1426 if (inode->i_op->follow_link) {
Linus Torvalds3abb17e2011-02-16 08:56:55 -08001427 err = do_follow_link(inode, &next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (err)
1429 goto return_err;
Nick Piggin31e6b012011-01-07 17:49:52 +11001430 nd->inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 err = -ENOENT;
Nick Piggin31e6b012011-01-07 17:49:52 +11001432 if (!nd->inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 break;
Nick Piggin31e6b012011-01-07 17:49:52 +11001434 } else {
Miklos Szeredi09dd17d2005-09-06 15:18:21 -07001435 path_to_nameidata(&next, nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11001436 nd->inode = inode;
1437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 err = -ENOTDIR;
Nick Piggin31e6b012011-01-07 17:49:52 +11001439 if (!nd->inode->i_op->lookup)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 break;
1441 continue;
1442 /* here ends the main loop */
1443
1444last_with_slashes:
1445 lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1446last_component:
Trond Myklebustf55eab82006-02-04 23:28:01 -08001447 /* Clear LOOKUP_CONTINUE iff it was previously unset */
1448 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 if (lookup_flags & LOOKUP_PARENT)
1450 goto lookup_parent;
Al Virofe479a52011-02-22 15:10:03 -05001451 if (unlikely(type != LAST_NORM)) {
1452 if (type == LAST_DOTDOT) {
Nick Piggin31e6b012011-01-07 17:49:52 +11001453 if (nd->flags & LOOKUP_RCU) {
1454 if (follow_dotdot_rcu(nd))
1455 return -ECHILD;
1456 } else
1457 follow_dotdot(nd);
Al Virofe479a52011-02-22 15:10:03 -05001458 }
1459 goto return_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 }
Nick Piggin31e6b012011-01-07 17:49:52 +11001461 err = do_lookup(nd, &this, &next, &inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 if (err)
1463 break;
David Howellsdb372912011-01-14 18:45:53 +00001464 if (inode && unlikely(inode->i_op->follow_link) &&
1465 (lookup_flags & LOOKUP_FOLLOW)) {
Linus Torvalds3abb17e2011-02-16 08:56:55 -08001466 err = do_follow_link(inode, &next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if (err)
1468 goto return_err;
Nick Piggin31e6b012011-01-07 17:49:52 +11001469 nd->inode = nd->path.dentry->d_inode;
1470 } else {
Miklos Szeredi09dd17d2005-09-06 15:18:21 -07001471 path_to_nameidata(&next, nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11001472 nd->inode = inode;
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 err = -ENOENT;
Nick Piggin31e6b012011-01-07 17:49:52 +11001475 if (!nd->inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 break;
1477 if (lookup_flags & LOOKUP_DIRECTORY) {
1478 err = -ENOTDIR;
Nick Piggin31e6b012011-01-07 17:49:52 +11001479 if (!nd->inode->i_op->lookup)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 break;
1481 }
1482 goto return_base;
1483lookup_parent:
1484 nd->last = this;
Al Virofe479a52011-02-22 15:10:03 -05001485 nd->last_type = type;
1486 if (type == LAST_NORM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 goto return_base;
1488return_reval:
1489 /*
1490 * We bypassed the ordinary revalidation routines.
1491 * We may need to check the cached dentry for staleness.
1492 */
Nick Pigginfb045ad2011-01-07 17:49:55 +11001493 if (need_reval_dot(nd->path.dentry)) {
Al Virof60aef72011-02-15 01:35:28 -05001494 if (nameidata_drop_rcu_last_maybe(nd))
1495 return -ECHILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 /* Note: we do not d_invalidate() */
Nick Piggin34286d62011-01-07 17:49:57 +11001497 err = d_revalidate(nd->path.dentry, nd);
1498 if (!err)
1499 err = -ESTALE;
1500 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 break;
Al Virof60aef72011-02-15 01:35:28 -05001502 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 }
1504return_base:
Nick Piggin31e6b012011-01-07 17:49:52 +11001505 if (nameidata_drop_rcu_last_maybe(nd))
1506 return -ECHILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 return 0;
1508out_dput:
Nick Piggin31e6b012011-01-07 17:49:52 +11001509 if (!(nd->flags & LOOKUP_RCU))
1510 path_put_conditional(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 break;
1512 }
Nick Piggin31e6b012011-01-07 17:49:52 +11001513 if (!(nd->flags & LOOKUP_RCU))
1514 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515return_err:
1516 return err;
1517}
1518
Al Viro9b4a9b12009-04-07 11:44:16 -04001519static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520{
Prasanna Medaea3834d2005-04-29 16:00:17 +01001521 int retval = 0;
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001522 int fput_needed;
1523 struct file *file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525 nd->last_type = LAST_ROOT; /* if there are only slashes... */
1526 nd->flags = flags;
1527 nd->depth = 0;
Al Viro2a737872009-04-07 11:49:53 -04001528 nd->root.mnt = NULL;
Al Viroe41f7d42011-02-22 14:02:58 -05001529 nd->file = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 if (*name=='/') {
Al Viroe41f7d42011-02-22 14:02:58 -05001532 if (flags & LOOKUP_RCU) {
1533 br_read_lock(vfsmount_lock);
1534 rcu_read_lock();
1535 set_root_rcu(nd);
1536 } else {
1537 set_root(nd);
1538 path_get(&nd->root);
1539 }
Al Viro2a737872009-04-07 11:49:53 -04001540 nd->path = nd->root;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001541 } else if (dfd == AT_FDCWD) {
Al Viroe41f7d42011-02-22 14:02:58 -05001542 if (flags & LOOKUP_RCU) {
1543 struct fs_struct *fs = current->fs;
1544 unsigned seq;
1545
1546 br_read_lock(vfsmount_lock);
1547 rcu_read_lock();
1548
1549 do {
1550 seq = read_seqcount_begin(&fs->seq);
1551 nd->path = fs->pwd;
1552 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1553 } while (read_seqcount_retry(&fs->seq, seq));
1554 } else {
1555 get_fs_pwd(current->fs, &nd->path);
1556 }
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001557 } else {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001558 struct dentry *dentry;
1559
1560 file = fget_light(dfd, &fput_needed);
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001561 retval = -EBADF;
1562 if (!file)
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001563 goto out_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001564
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -08001565 dentry = file->f_path.dentry;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001566
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001567 retval = -ENOTDIR;
1568 if (!S_ISDIR(dentry->d_inode->i_mode))
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001569 goto fput_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001570
1571 retval = file_permission(file, MAY_EXEC);
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001572 if (retval)
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001573 goto fput_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001574
Jan Blunck5dd784d02008-02-14 19:34:38 -08001575 nd->path = file->f_path;
Al Viroe41f7d42011-02-22 14:02:58 -05001576 if (flags & LOOKUP_RCU) {
1577 if (fput_needed)
1578 nd->file = file;
1579 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1580 br_read_lock(vfsmount_lock);
1581 rcu_read_lock();
1582 } else {
1583 path_get(&file->f_path);
1584 fput_light(file, fput_needed);
1585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 }
Al Viroe41f7d42011-02-22 14:02:58 -05001587
Nick Piggin31e6b012011-01-07 17:49:52 +11001588 nd->inode = nd->path.dentry->d_inode;
Al Viro9b4a9b12009-04-07 11:44:16 -04001589 return 0;
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001590
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001591fput_fail:
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001592 fput_light(file, fput_needed);
Al Viro9b4a9b12009-04-07 11:44:16 -04001593out_fail:
1594 return retval;
1595}
1596
1597/* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
Al Viroee0827c2011-02-21 23:38:09 -05001598static int path_lookupat(int dfd, const char *name,
Al Viro9b4a9b12009-04-07 11:44:16 -04001599 unsigned int flags, struct nameidata *nd)
1600{
Nick Piggin31e6b012011-01-07 17:49:52 +11001601 int retval;
1602
1603 /*
1604 * Path walking is largely split up into 2 different synchronisation
1605 * schemes, rcu-walk and ref-walk (explained in
1606 * Documentation/filesystems/path-lookup.txt). These share much of the
1607 * path walk code, but some things particularly setup, cleanup, and
1608 * following mounts are sufficiently divergent that functions are
1609 * duplicated. Typically there is a function foo(), and its RCU
1610 * analogue, foo_rcu().
1611 *
1612 * -ECHILD is the error number of choice (just to avoid clashes) that
1613 * is returned if some aspect of an rcu-walk fails. Such an error must
1614 * be handled by restarting a traditional ref-walk (which will always
1615 * be able to complete).
1616 */
Al Viroe41f7d42011-02-22 14:02:58 -05001617 retval = path_init(dfd, name, flags, nd);
Al Viroee0827c2011-02-21 23:38:09 -05001618
Nick Piggin31e6b012011-01-07 17:49:52 +11001619 if (unlikely(retval))
1620 return retval;
Al Viroee0827c2011-02-21 23:38:09 -05001621
1622 current->total_link_count = 0;
1623 retval = link_path_walk(name, nd);
1624
1625 if (nd->flags & LOOKUP_RCU) {
1626 /* RCU dangling. Cancel it. */
1627 nd->flags &= ~LOOKUP_RCU;
1628 nd->root.mnt = NULL;
1629 rcu_read_unlock();
1630 br_read_unlock(vfsmount_lock);
1631 }
1632
1633 if (nd->file) {
1634 fput(nd->file);
1635 nd->file = NULL;
1636 }
1637
Al Viro2a737872009-04-07 11:49:53 -04001638 if (nd->root.mnt) {
1639 path_put(&nd->root);
1640 nd->root.mnt = NULL;
1641 }
Al Viroee0827c2011-02-21 23:38:09 -05001642 return retval;
1643}
Nick Piggin31e6b012011-01-07 17:49:52 +11001644
Al Viroee0827c2011-02-21 23:38:09 -05001645static int do_path_lookup(int dfd, const char *name,
1646 unsigned int flags, struct nameidata *nd)
1647{
1648 int retval = path_lookupat(dfd, name, flags | LOOKUP_RCU, nd);
1649 if (unlikely(retval == -ECHILD))
1650 retval = path_lookupat(dfd, name, flags, nd);
1651 if (unlikely(retval == -ESTALE))
1652 retval = path_lookupat(dfd, name, flags | LOOKUP_REVAL, nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11001653
1654 if (likely(!retval)) {
1655 if (unlikely(!audit_dummy_context())) {
1656 if (nd->path.dentry && nd->inode)
1657 audit_inode(name, nd->path.dentry);
1658 }
1659 }
Al Viro9b4a9b12009-04-07 11:44:16 -04001660 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661}
1662
Al Viroc9c6cac2011-02-16 15:15:47 -05001663int kern_path_parent(const char *name, struct nameidata *nd)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001664{
Al Viroc9c6cac2011-02-16 15:15:47 -05001665 return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001666}
1667
Al Virod1811462008-08-02 00:49:18 -04001668int kern_path(const char *name, unsigned int flags, struct path *path)
1669{
1670 struct nameidata nd;
1671 int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1672 if (!res)
1673 *path = nd.path;
1674 return res;
1675}
1676
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001677/**
1678 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1679 * @dentry: pointer to dentry of the base directory
1680 * @mnt: pointer to vfs mount of the base directory
1681 * @name: pointer to file name
1682 * @flags: lookup flags
1683 * @nd: pointer to nameidata
1684 */
1685int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1686 const char *name, unsigned int flags,
1687 struct nameidata *nd)
1688{
Al Viroee0827c2011-02-21 23:38:09 -05001689 int result;
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001690
1691 /* same as do_path_lookup */
1692 nd->last_type = LAST_ROOT;
1693 nd->flags = flags;
1694 nd->depth = 0;
1695
Jan Blunckc8e7f442008-06-09 16:40:35 -07001696 nd->path.dentry = dentry;
1697 nd->path.mnt = mnt;
1698 path_get(&nd->path);
Al Viro5b857112009-04-07 11:53:49 -04001699 nd->root = nd->path;
1700 path_get(&nd->root);
Nick Piggin31e6b012011-01-07 17:49:52 +11001701 nd->inode = nd->path.dentry->d_inode;
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001702
Al Viroee0827c2011-02-21 23:38:09 -05001703 current->total_link_count = 0;
1704
1705 result = link_path_walk(name, nd);
1706 if (result == -ESTALE) {
1707 /* nd->path had been dropped */
1708 current->total_link_count = 0;
1709 nd->path.dentry = dentry;
1710 nd->path.mnt = mnt;
1711 nd->inode = dentry->d_inode;
1712 path_get(&nd->path);
1713 nd->flags |= LOOKUP_REVAL;
1714 result = link_path_walk(name, nd);
1715 }
1716 if (unlikely(!result && !audit_dummy_context() && nd->path.dentry &&
Nick Piggin31e6b012011-01-07 17:49:52 +11001717 nd->inode))
Jan Blunck4ac91372008-02-14 19:34:32 -08001718 audit_inode(name, nd->path.dentry);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001719
Al Viro5b857112009-04-07 11:53:49 -04001720 path_put(&nd->root);
1721 nd->root.mnt = NULL;
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001722
Al Viroee0827c2011-02-21 23:38:09 -05001723 return result;
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001724}
1725
Christoph Hellwigeead1912007-10-16 23:25:38 -07001726static struct dentry *__lookup_hash(struct qstr *name,
1727 struct dentry *base, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728{
Christoph Hellwig81fca442010-10-06 10:47:47 +02001729 struct inode *inode = base->d_inode;
James Morris057f6c02007-04-26 00:12:05 -07001730 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 int err;
1732
Nick Pigginb74c79e2011-01-07 17:49:58 +11001733 err = exec_permission(inode, 0);
Christoph Hellwig81fca442010-10-06 10:47:47 +02001734 if (err)
1735 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
1737 /*
1738 * See if the low-level filesystem might want
1739 * to use its own hash..
1740 */
Nick Pigginfb045ad2011-01-07 17:49:55 +11001741 if (base->d_flags & DCACHE_OP_HASH) {
Nick Pigginb1e6a012011-01-07 17:49:28 +11001742 err = base->d_op->d_hash(base, inode, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 dentry = ERR_PTR(err);
1744 if (err < 0)
1745 goto out;
1746 }
1747
Nick Pigginb04f7842010-08-18 04:37:34 +10001748 /*
1749 * Don't bother with __d_lookup: callers are for creat as
1750 * well as unlink, so a lot of the time it would cost
1751 * a double lookup.
Al Viro6e6b1bd2009-08-13 23:38:37 +04001752 */
Nick Pigginb04f7842010-08-18 04:37:34 +10001753 dentry = d_lookup(base, name);
Al Viro6e6b1bd2009-08-13 23:38:37 +04001754
Nick Pigginfb045ad2011-01-07 17:49:55 +11001755 if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE))
Al Viro6e6b1bd2009-08-13 23:38:37 +04001756 dentry = do_revalidate(dentry, nd);
1757
Nick Pigginbaa03892010-08-18 04:37:31 +10001758 if (!dentry)
1759 dentry = d_alloc_and_lookup(base, name, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760out:
1761 return dentry;
1762}
1763
James Morris057f6c02007-04-26 00:12:05 -07001764/*
1765 * Restricted form of lookup. Doesn't follow links, single-component only,
1766 * needs parent already locked. Doesn't follow mounts.
1767 * SMP-safe.
1768 */
Adrian Bunka244e162006-03-31 02:32:11 -08001769static struct dentry *lookup_hash(struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770{
Jan Blunck4ac91372008-02-14 19:34:32 -08001771 return __lookup_hash(&nd->last, nd->path.dentry, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772}
1773
Christoph Hellwigeead1912007-10-16 23:25:38 -07001774static int __lookup_one_len(const char *name, struct qstr *this,
1775 struct dentry *base, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776{
1777 unsigned long hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 unsigned int c;
1779
James Morris057f6c02007-04-26 00:12:05 -07001780 this->name = name;
1781 this->len = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 if (!len)
James Morris057f6c02007-04-26 00:12:05 -07001783 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785 hash = init_name_hash();
1786 while (len--) {
1787 c = *(const unsigned char *)name++;
1788 if (c == '/' || c == '\0')
James Morris057f6c02007-04-26 00:12:05 -07001789 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 hash = partial_name_hash(c, hash);
1791 }
James Morris057f6c02007-04-26 00:12:05 -07001792 this->hash = end_name_hash(hash);
1793 return 0;
1794}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795
Christoph Hellwigeead1912007-10-16 23:25:38 -07001796/**
Randy Dunlapa6b91912008-03-19 17:01:00 -07001797 * lookup_one_len - filesystem helper to lookup single pathname component
Christoph Hellwigeead1912007-10-16 23:25:38 -07001798 * @name: pathname component to lookup
1799 * @base: base directory to lookup from
1800 * @len: maximum length @len should be interpreted to
1801 *
Randy Dunlapa6b91912008-03-19 17:01:00 -07001802 * Note that this routine is purely a helper for filesystem usage and should
1803 * not be called by generic code. Also note that by using this function the
Christoph Hellwigeead1912007-10-16 23:25:38 -07001804 * nameidata argument is passed to the filesystem methods and a filesystem
1805 * using this helper needs to be prepared for that.
1806 */
James Morris057f6c02007-04-26 00:12:05 -07001807struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1808{
1809 int err;
1810 struct qstr this;
1811
David Woodhouse2f9092e2009-04-20 23:18:37 +01001812 WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1813
James Morris057f6c02007-04-26 00:12:05 -07001814 err = __lookup_one_len(name, &this, base, len);
1815 if (err)
1816 return ERR_PTR(err);
Christoph Hellwigeead1912007-10-16 23:25:38 -07001817
Christoph Hellwig49705b72005-11-08 21:35:06 -08001818 return __lookup_hash(&this, base, NULL);
James Morris057f6c02007-04-26 00:12:05 -07001819}
1820
Al Viro2d8f3032008-07-22 09:59:21 -04001821int user_path_at(int dfd, const char __user *name, unsigned flags,
1822 struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823{
Al Viro2d8f3032008-07-22 09:59:21 -04001824 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 char *tmp = getname(name);
1826 int err = PTR_ERR(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 if (!IS_ERR(tmp)) {
Al Viro2d8f3032008-07-22 09:59:21 -04001828
1829 BUG_ON(flags & LOOKUP_PARENT);
1830
1831 err = do_path_lookup(dfd, tmp, flags, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 putname(tmp);
Al Viro2d8f3032008-07-22 09:59:21 -04001833 if (!err)
1834 *path = nd.path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 }
1836 return err;
1837}
1838
Al Viro2ad94ae2008-07-21 09:32:51 -04001839static int user_path_parent(int dfd, const char __user *path,
1840 struct nameidata *nd, char **name)
1841{
1842 char *s = getname(path);
1843 int error;
1844
1845 if (IS_ERR(s))
1846 return PTR_ERR(s);
1847
1848 error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1849 if (error)
1850 putname(s);
1851 else
1852 *name = s;
1853
1854 return error;
1855}
1856
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857/*
1858 * It's inline, so penalty for filesystems that don't use sticky bit is
1859 * minimal.
1860 */
1861static inline int check_sticky(struct inode *dir, struct inode *inode)
1862{
David Howellsda9592e2008-11-14 10:39:05 +11001863 uid_t fsuid = current_fsuid();
1864
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 if (!(dir->i_mode & S_ISVTX))
1866 return 0;
David Howellsda9592e2008-11-14 10:39:05 +11001867 if (inode->i_uid == fsuid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 return 0;
David Howellsda9592e2008-11-14 10:39:05 +11001869 if (dir->i_uid == fsuid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return 0;
1871 return !capable(CAP_FOWNER);
1872}
1873
1874/*
1875 * Check whether we can remove a link victim from directory dir, check
1876 * whether the type of victim is right.
1877 * 1. We can't do it if dir is read-only (done in permission())
1878 * 2. We should have write and exec permissions on dir
1879 * 3. We can't remove anything from append-only dir
1880 * 4. We can't do anything with immutable dir (done in permission())
1881 * 5. If the sticky bit on dir is set we should either
1882 * a. be owner of dir, or
1883 * b. be owner of victim, or
1884 * c. have CAP_FOWNER capability
1885 * 6. If the victim is append-only or immutable we can't do antyhing with
1886 * links pointing to it.
1887 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1888 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1889 * 9. We can't remove a root or mountpoint.
1890 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1891 * nfs_async_unlink().
1892 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08001893static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894{
1895 int error;
1896
1897 if (!victim->d_inode)
1898 return -ENOENT;
1899
1900 BUG_ON(victim->d_parent->d_inode != dir);
Al Virocccc6bb2009-12-25 05:07:33 -05001901 audit_inode_child(victim, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
Al Virof419a2e2008-07-22 00:07:17 -04001903 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 if (error)
1905 return error;
1906 if (IS_APPEND(dir))
1907 return -EPERM;
1908 if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
Hugh Dickinsf9454542008-11-19 15:36:38 -08001909 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 return -EPERM;
1911 if (isdir) {
1912 if (!S_ISDIR(victim->d_inode->i_mode))
1913 return -ENOTDIR;
1914 if (IS_ROOT(victim))
1915 return -EBUSY;
1916 } else if (S_ISDIR(victim->d_inode->i_mode))
1917 return -EISDIR;
1918 if (IS_DEADDIR(dir))
1919 return -ENOENT;
1920 if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1921 return -EBUSY;
1922 return 0;
1923}
1924
1925/* Check whether we can create an object with dentry child in directory
1926 * dir.
1927 * 1. We can't do it if child already exists (open has special treatment for
1928 * this case, but since we are inlined it's OK)
1929 * 2. We can't do it if dir is read-only (done in permission())
1930 * 3. We should have write and exec permissions on dir
1931 * 4. We can't do it if dir is immutable (done in permission())
1932 */
Miklos Szeredia95164d2008-07-30 15:08:48 +02001933static inline int may_create(struct inode *dir, struct dentry *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
1935 if (child->d_inode)
1936 return -EEXIST;
1937 if (IS_DEADDIR(dir))
1938 return -ENOENT;
Al Virof419a2e2008-07-22 00:07:17 -04001939 return inode_permission(dir, MAY_WRITE | MAY_EXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940}
1941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942/*
1943 * p1 and p2 should be directories on the same fs.
1944 */
1945struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1946{
1947 struct dentry *p;
1948
1949 if (p1 == p2) {
Ingo Molnarf2eace22006-07-03 00:25:05 -07001950 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 return NULL;
1952 }
1953
Arjan van de Vena11f3a02006-03-23 03:00:33 -08001954 mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001956 p = d_ancestor(p2, p1);
1957 if (p) {
1958 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1959 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1960 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 }
1962
OGAWA Hirofumie2761a12008-10-16 07:50:28 +09001963 p = d_ancestor(p1, p2);
1964 if (p) {
1965 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1966 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1967 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 }
1969
Ingo Molnarf2eace22006-07-03 00:25:05 -07001970 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1971 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 return NULL;
1973}
1974
1975void unlock_rename(struct dentry *p1, struct dentry *p2)
1976{
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001977 mutex_unlock(&p1->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 if (p1 != p2) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001979 mutex_unlock(&p2->d_inode->i_mutex);
Arjan van de Vena11f3a02006-03-23 03:00:33 -08001980 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 }
1982}
1983
1984int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1985 struct nameidata *nd)
1986{
Miklos Szeredia95164d2008-07-30 15:08:48 +02001987 int error = may_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988
1989 if (error)
1990 return error;
1991
Al Viroacfa4382008-12-04 10:06:33 -05001992 if (!dir->i_op->create)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 return -EACCES; /* shouldn't it be ENOSYS? */
1994 mode &= S_IALLUGO;
1995 mode |= S_IFREG;
1996 error = security_inode_create(dir, dentry, mode);
1997 if (error)
1998 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 error = dir->i_op->create(dir, dentry, mode, nd);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002000 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002001 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 return error;
2003}
2004
Christoph Hellwig3fb64192008-10-24 09:58:10 +02002005int may_open(struct path *path, int acc_mode, int flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006{
Christoph Hellwig3fb64192008-10-24 09:58:10 +02002007 struct dentry *dentry = path->dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 struct inode *inode = dentry->d_inode;
2009 int error;
2010
2011 if (!inode)
2012 return -ENOENT;
2013
Christoph Hellwigc8fe8f32009-01-05 19:27:23 +01002014 switch (inode->i_mode & S_IFMT) {
2015 case S_IFLNK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 return -ELOOP;
Christoph Hellwigc8fe8f32009-01-05 19:27:23 +01002017 case S_IFDIR:
2018 if (acc_mode & MAY_WRITE)
2019 return -EISDIR;
2020 break;
2021 case S_IFBLK:
2022 case S_IFCHR:
Christoph Hellwig3fb64192008-10-24 09:58:10 +02002023 if (path->mnt->mnt_flags & MNT_NODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 return -EACCES;
Christoph Hellwigc8fe8f32009-01-05 19:27:23 +01002025 /*FALLTHRU*/
2026 case S_IFIFO:
2027 case S_IFSOCK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 flag &= ~O_TRUNC;
Christoph Hellwigc8fe8f32009-01-05 19:27:23 +01002029 break;
Dave Hansen4a3fd212008-02-15 14:37:48 -08002030 }
Dave Hansenb41572e2007-10-16 23:31:14 -07002031
Christoph Hellwig3fb64192008-10-24 09:58:10 +02002032 error = inode_permission(inode, acc_mode);
Dave Hansenb41572e2007-10-16 23:31:14 -07002033 if (error)
2034 return error;
Mimi Zohar6146f0d2009-02-04 09:06:57 -05002035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 /*
2037 * An append-only file must be opened in append mode for writing.
2038 */
2039 if (IS_APPEND(inode)) {
Al Viro8737c932009-12-24 06:47:55 -05002040 if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
Al Viro7715b522009-12-16 03:54:00 -05002041 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 if (flag & O_TRUNC)
Al Viro7715b522009-12-16 03:54:00 -05002043 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 }
2045
2046 /* O_NOATIME can only be set by the owner or superuser */
Al Viro7715b522009-12-16 03:54:00 -05002047 if (flag & O_NOATIME && !is_owner_or_cap(inode))
2048 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
2050 /*
2051 * Ensure there are no outstanding leases on the file.
2052 */
Al Virob65a9cf2009-12-16 06:27:40 -05002053 return break_lease(inode, flag);
Al Viro7715b522009-12-16 03:54:00 -05002054}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055
Jeff Laytone1181ee2010-12-07 16:19:50 -05002056static int handle_truncate(struct file *filp)
Al Viro7715b522009-12-16 03:54:00 -05002057{
Jeff Laytone1181ee2010-12-07 16:19:50 -05002058 struct path *path = &filp->f_path;
Al Viro7715b522009-12-16 03:54:00 -05002059 struct inode *inode = path->dentry->d_inode;
2060 int error = get_write_access(inode);
2061 if (error)
2062 return error;
2063 /*
2064 * Refuse to truncate files with mandatory locks held on them.
2065 */
2066 error = locks_verify_locked(inode);
2067 if (!error)
Tetsuo Handaea0d3ab2010-06-02 13:24:43 +09002068 error = security_path_truncate(path);
Al Viro7715b522009-12-16 03:54:00 -05002069 if (!error) {
2070 error = do_truncate(path->dentry, 0,
2071 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
Jeff Laytone1181ee2010-12-07 16:19:50 -05002072 filp);
Al Viro7715b522009-12-16 03:54:00 -05002073 }
2074 put_write_access(inode);
Mimi Zoharacd0c932009-09-04 13:08:46 -04002075 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076}
2077
Dave Hansend57999e2008-02-15 14:37:27 -08002078/*
2079 * Be careful about ever adding any more callers of this
2080 * function. Its flags must be in the namei format, not
2081 * what get passed to sys_open().
2082 */
2083static int __open_namei_create(struct nameidata *nd, struct path *path,
Al Viro8737c932009-12-24 06:47:55 -05002084 int open_flag, int mode)
Dave Hansenaab520e2006-09-30 23:29:02 -07002085{
2086 int error;
Jan Blunck4ac91372008-02-14 19:34:32 -08002087 struct dentry *dir = nd->path.dentry;
Dave Hansenaab520e2006-09-30 23:29:02 -07002088
2089 if (!IS_POSIXACL(dir->d_inode))
Al Viroce3b0f82009-03-29 19:08:22 -04002090 mode &= ~current_umask();
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002091 error = security_path_mknod(&nd->path, path->dentry, mode, 0);
2092 if (error)
2093 goto out_unlock;
Dave Hansenaab520e2006-09-30 23:29:02 -07002094 error = vfs_create(dir->d_inode, path->dentry, mode, nd);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002095out_unlock:
Dave Hansenaab520e2006-09-30 23:29:02 -07002096 mutex_unlock(&dir->d_inode->i_mutex);
Jan Blunck4ac91372008-02-14 19:34:32 -08002097 dput(nd->path.dentry);
2098 nd->path.dentry = path->dentry;
Nick Piggin31e6b012011-01-07 17:49:52 +11002099
Dave Hansenaab520e2006-09-30 23:29:02 -07002100 if (error)
2101 return error;
2102 /* Don't check for write permission, don't truncate */
Al Viro8737c932009-12-24 06:47:55 -05002103 return may_open(&nd->path, 0, open_flag & ~O_TRUNC);
Dave Hansenaab520e2006-09-30 23:29:02 -07002104}
2105
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106/*
Dave Hansend57999e2008-02-15 14:37:27 -08002107 * Note that while the flag value (low two bits) for sys_open means:
2108 * 00 - read-only
2109 * 01 - write-only
2110 * 10 - read-write
2111 * 11 - special
2112 * it is changed into
2113 * 00 - no permissions needed
2114 * 01 - read-permission
2115 * 10 - write-permission
2116 * 11 - read-write
2117 * for the internal routines (ie open_namei()/follow_link() etc)
2118 * This is more logical, and also allows the 00 "no perm needed"
2119 * to be used for symlinks (where the permissions are checked
2120 * later).
2121 *
2122*/
2123static inline int open_to_namei_flags(int flag)
2124{
2125 if ((flag+1) & O_ACCMODE)
2126 flag++;
2127 return flag;
2128}
2129
Al Viro7715b522009-12-16 03:54:00 -05002130static int open_will_truncate(int flag, struct inode *inode)
Dave Hansen4a3fd212008-02-15 14:37:48 -08002131{
2132 /*
2133 * We'll never write to the fs underlying
2134 * a device file.
2135 */
2136 if (special_file(inode->i_mode))
2137 return 0;
2138 return (flag & O_TRUNC);
2139}
2140
Al Viro648fa862009-12-24 01:26:48 -05002141static struct file *finish_open(struct nameidata *nd,
Al Viro9a661792009-12-24 06:49:47 -05002142 int open_flag, int acc_mode)
Al Viro648fa862009-12-24 01:26:48 -05002143{
2144 struct file *filp;
2145 int will_truncate;
2146 int error;
2147
Al Viro9a661792009-12-24 06:49:47 -05002148 will_truncate = open_will_truncate(open_flag, nd->path.dentry->d_inode);
Al Viro648fa862009-12-24 01:26:48 -05002149 if (will_truncate) {
2150 error = mnt_want_write(nd->path.mnt);
2151 if (error)
2152 goto exit;
2153 }
2154 error = may_open(&nd->path, acc_mode, open_flag);
2155 if (error) {
2156 if (will_truncate)
2157 mnt_drop_write(nd->path.mnt);
2158 goto exit;
2159 }
2160 filp = nameidata_to_filp(nd);
2161 if (!IS_ERR(filp)) {
2162 error = ima_file_check(filp, acc_mode);
2163 if (error) {
2164 fput(filp);
2165 filp = ERR_PTR(error);
2166 }
2167 }
2168 if (!IS_ERR(filp)) {
Al Viro648fa862009-12-24 01:26:48 -05002169 if (will_truncate) {
Jeff Laytone1181ee2010-12-07 16:19:50 -05002170 error = handle_truncate(filp);
Al Viro648fa862009-12-24 01:26:48 -05002171 if (error) {
2172 fput(filp);
2173 filp = ERR_PTR(error);
2174 }
2175 }
2176 }
2177 /*
2178 * It is now safe to drop the mnt write
2179 * because the filp has had a write taken
2180 * on its behalf.
2181 */
2182 if (will_truncate)
2183 mnt_drop_write(nd->path.mnt);
Al Virod893f1b2010-10-29 03:30:42 -04002184 path_put(&nd->path);
Al Viro648fa862009-12-24 01:26:48 -05002185 return filp;
2186
2187exit:
Al Viro648fa862009-12-24 01:26:48 -05002188 path_put(&nd->path);
2189 return ERR_PTR(error);
2190}
2191
Nick Piggin31e6b012011-01-07 17:49:52 +11002192/*
2193 * Handle O_CREAT case for do_filp_open
2194 */
Al Virofb1cc552009-12-24 01:58:28 -05002195static struct file *do_last(struct nameidata *nd, struct path *path,
Al Viro5b369df2009-12-24 06:51:13 -05002196 int open_flag, int acc_mode,
Al Viro3e297b62010-03-26 12:40:13 -04002197 int mode, const char *pathname)
Al Virofb1cc552009-12-24 01:58:28 -05002198{
Al Viroa1e28032009-12-24 02:12:06 -05002199 struct dentry *dir = nd->path.dentry;
Al Virofb1cc552009-12-24 01:58:28 -05002200 struct file *filp;
Al Viro1f36f772009-12-26 10:56:19 -05002201 int error = -EISDIR;
Al Virofb1cc552009-12-24 01:58:28 -05002202
Al Viro1f36f772009-12-26 10:56:19 -05002203 switch (nd->last_type) {
2204 case LAST_DOTDOT:
2205 follow_dotdot(nd);
2206 dir = nd->path.dentry;
Neil Brown176306f2010-05-24 16:57:56 +10002207 case LAST_DOT:
Nick Pigginfb045ad2011-01-07 17:49:55 +11002208 if (need_reval_dot(dir)) {
J. R. Okajimaf20877d2011-01-14 03:56:04 +00002209 int status = d_revalidate(nd->path.dentry, nd);
2210 if (!status)
2211 status = -ESTALE;
2212 if (status < 0) {
2213 error = status;
Al Viro1f36f772009-12-26 10:56:19 -05002214 goto exit;
J. R. Okajimaf20877d2011-01-14 03:56:04 +00002215 }
Al Viro1f36f772009-12-26 10:56:19 -05002216 }
2217 /* fallthrough */
Al Viro1f36f772009-12-26 10:56:19 -05002218 case LAST_ROOT:
Nick Piggin31e6b012011-01-07 17:49:52 +11002219 goto exit;
Al Viro1f36f772009-12-26 10:56:19 -05002220 case LAST_BIND:
2221 audit_inode(pathname, dir);
Al Viro67ee3ad2009-12-26 07:01:01 -05002222 goto ok;
Al Viro1f36f772009-12-26 10:56:19 -05002223 }
Al Viro67ee3ad2009-12-26 07:01:01 -05002224
Al Viro1f36f772009-12-26 10:56:19 -05002225 /* trailing slashes? */
Nick Piggin31e6b012011-01-07 17:49:52 +11002226 if (nd->last.name[nd->last.len])
2227 goto exit;
Al Viroa2c36b42009-12-24 03:39:50 -05002228
Al Viroa1e28032009-12-24 02:12:06 -05002229 mutex_lock(&dir->d_inode->i_mutex);
2230
2231 path->dentry = lookup_hash(nd);
2232 path->mnt = nd->path.mnt;
2233
Al Virofb1cc552009-12-24 01:58:28 -05002234 error = PTR_ERR(path->dentry);
2235 if (IS_ERR(path->dentry)) {
2236 mutex_unlock(&dir->d_inode->i_mutex);
2237 goto exit;
2238 }
2239
2240 if (IS_ERR(nd->intent.open.file)) {
2241 error = PTR_ERR(nd->intent.open.file);
2242 goto exit_mutex_unlock;
2243 }
2244
2245 /* Negative dentry, just create the file */
2246 if (!path->dentry->d_inode) {
2247 /*
2248 * This write is needed to ensure that a
2249 * ro->rw transition does not occur between
2250 * the time when the file is created and when
2251 * a permanent write count is taken through
2252 * the 'struct file' in nameidata_to_filp().
2253 */
2254 error = mnt_want_write(nd->path.mnt);
2255 if (error)
2256 goto exit_mutex_unlock;
2257 error = __open_namei_create(nd, path, open_flag, mode);
2258 if (error) {
2259 mnt_drop_write(nd->path.mnt);
2260 goto exit;
2261 }
2262 filp = nameidata_to_filp(nd);
2263 mnt_drop_write(nd->path.mnt);
Al Virod893f1b2010-10-29 03:30:42 -04002264 path_put(&nd->path);
Al Virofb1cc552009-12-24 01:58:28 -05002265 if (!IS_ERR(filp)) {
2266 error = ima_file_check(filp, acc_mode);
2267 if (error) {
2268 fput(filp);
2269 filp = ERR_PTR(error);
2270 }
2271 }
2272 return filp;
2273 }
2274
2275 /*
2276 * It already exists.
2277 */
2278 mutex_unlock(&dir->d_inode->i_mutex);
2279 audit_inode(pathname, path->dentry);
2280
2281 error = -EEXIST;
Al Viro5b369df2009-12-24 06:51:13 -05002282 if (open_flag & O_EXCL)
Al Virofb1cc552009-12-24 01:58:28 -05002283 goto exit_dput;
2284
David Howells9875cf82011-01-14 18:45:21 +00002285 error = follow_managed(path, nd->flags);
2286 if (error < 0)
2287 goto exit_dput;
Al Virofb1cc552009-12-24 01:58:28 -05002288
2289 error = -ENOENT;
2290 if (!path->dentry->d_inode)
2291 goto exit_dput;
Al Viro9e67f362009-12-26 07:04:50 -05002292
2293 if (path->dentry->d_inode->i_op->follow_link)
Al Virofb1cc552009-12-24 01:58:28 -05002294 return NULL;
Al Virofb1cc552009-12-24 01:58:28 -05002295
2296 path_to_nameidata(path, nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11002297 nd->inode = path->dentry->d_inode;
Al Virofb1cc552009-12-24 01:58:28 -05002298 error = -EISDIR;
Nick Piggin31e6b012011-01-07 17:49:52 +11002299 if (S_ISDIR(nd->inode->i_mode))
Al Virofb1cc552009-12-24 01:58:28 -05002300 goto exit;
Al Viro67ee3ad2009-12-26 07:01:01 -05002301ok:
Al Viro9a661792009-12-24 06:49:47 -05002302 filp = finish_open(nd, open_flag, acc_mode);
Al Virofb1cc552009-12-24 01:58:28 -05002303 return filp;
2304
2305exit_mutex_unlock:
2306 mutex_unlock(&dir->d_inode->i_mutex);
2307exit_dput:
2308 path_put_conditional(path, nd);
2309exit:
Al Virofb1cc552009-12-24 01:58:28 -05002310 path_put(&nd->path);
2311 return ERR_PTR(error);
2312}
2313
Dave Hansend57999e2008-02-15 14:37:27 -08002314/*
Dave Hansen4a3fd212008-02-15 14:37:48 -08002315 * Note that the low bits of the passed in "open_flag"
2316 * are not the same as in the local variable "flag". See
2317 * open_to_namei_flags() for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08002319struct file *do_filp_open(int dfd, const char *pathname,
Al Viro6e8341a2009-04-06 11:16:22 -04002320 int open_flag, int mode, int acc_mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321{
Dave Hansen4a3fd212008-02-15 14:37:48 -08002322 struct file *filp;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08002323 struct nameidata nd;
Al Viro6e8341a2009-04-06 11:16:22 -04002324 int error;
Al Viro9850c052010-01-13 15:01:15 -05002325 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 int count = 0;
Dave Hansend57999e2008-02-15 14:37:27 -08002327 int flag = open_to_namei_flags(open_flag);
Nick Piggin31e6b012011-01-07 17:49:52 +11002328 int flags;
Al Viro1f36f772009-12-26 10:56:19 -05002329
2330 if (!(open_flag & O_CREAT))
2331 mode = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332
Lino Sanfilippob1085ba2010-11-05 17:05:27 +01002333 /* Must never be set by userspace */
2334 open_flag &= ~FMODE_NONOTIFY;
2335
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +01002336 /*
2337 * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only
2338 * check for O_DSYNC if the need any syncing at all we enforce it's
2339 * always set instead of having to deal with possibly weird behaviour
2340 * for malicious applications setting only __O_SYNC.
2341 */
2342 if (open_flag & __O_SYNC)
2343 open_flag |= O_DSYNC;
2344
Al Viro6e8341a2009-04-06 11:16:22 -04002345 if (!acc_mode)
Al Viro6d125522009-12-24 06:58:56 -05002346 acc_mode = MAY_OPEN | ACC_MODE(open_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347
Trond Myklebust834f2a42005-10-18 14:20:16 -07002348 /* O_TRUNC implies we need access checks for write permissions */
Al Viro4296e2c2009-12-24 07:15:41 -05002349 if (open_flag & O_TRUNC)
Trond Myklebust834f2a42005-10-18 14:20:16 -07002350 acc_mode |= MAY_WRITE;
2351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 /* Allow the LSM permission hook to distinguish append
2353 access from general write access. */
Al Viro4296e2c2009-12-24 07:15:41 -05002354 if (open_flag & O_APPEND)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 acc_mode |= MAY_APPEND;
2356
Nick Piggin31e6b012011-01-07 17:49:52 +11002357 flags = LOOKUP_OPEN;
2358 if (open_flag & O_CREAT) {
2359 flags |= LOOKUP_CREATE;
2360 if (open_flag & O_EXCL)
2361 flags |= LOOKUP_EXCL;
J. R. Okajima654f5622009-06-18 23:30:15 +09002362 }
Nick Piggin31e6b012011-01-07 17:49:52 +11002363 if (open_flag & O_DIRECTORY)
2364 flags |= LOOKUP_DIRECTORY;
2365 if (!(open_flag & O_NOFOLLOW))
2366 flags |= LOOKUP_FOLLOW;
2367
2368 filp = get_empty_filp();
2369 if (!filp)
2370 return ERR_PTR(-ENFILE);
2371
2372 filp->f_flags = open_flag;
2373 nd.intent.open.file = filp;
2374 nd.intent.open.flags = flag;
2375 nd.intent.open.create_mode = mode;
2376
2377 if (open_flag & O_CREAT)
2378 goto creat;
2379
2380 /* !O_CREAT, simple open */
2381 error = do_path_lookup(dfd, pathname, flags, &nd);
2382 if (unlikely(error))
Al Viro1858efd2011-03-04 13:14:21 -05002383 goto out_filp2;
Nick Piggin31e6b012011-01-07 17:49:52 +11002384 error = -ELOOP;
2385 if (!(nd.flags & LOOKUP_FOLLOW)) {
2386 if (nd.inode->i_op->follow_link)
Al Viro1858efd2011-03-04 13:14:21 -05002387 goto out_path2;
Nick Piggin31e6b012011-01-07 17:49:52 +11002388 }
2389 error = -ENOTDIR;
2390 if (nd.flags & LOOKUP_DIRECTORY) {
2391 if (!nd.inode->i_op->lookup)
Al Viro1858efd2011-03-04 13:14:21 -05002392 goto out_path2;
Nick Piggin31e6b012011-01-07 17:49:52 +11002393 }
2394 audit_inode(pathname, nd.path.dentry);
2395 filp = finish_open(&nd, open_flag, acc_mode);
Al Viro1858efd2011-03-04 13:14:21 -05002396out2:
Linus Torvalds2dab5972011-02-11 15:53:38 -08002397 release_open_intent(&nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11002398 return filp;
2399
Al Viro1858efd2011-03-04 13:14:21 -05002400out_path2:
2401 path_put(&nd.path);
2402out_filp2:
2403 filp = ERR_PTR(error);
2404 goto out2;
2405
Nick Piggin31e6b012011-01-07 17:49:52 +11002406creat:
2407 /* OK, have to create the file. Find the parent. */
Al Viroee0827c2011-02-21 23:38:09 -05002408 error = path_lookupat(dfd, pathname, LOOKUP_PARENT | LOOKUP_RCU, &nd);
2409 if (unlikely(error == -ECHILD))
2410 error = path_lookupat(dfd, pathname, LOOKUP_PARENT, &nd);
2411 if (unlikely(error == -ESTALE)) {
Nick Piggin31e6b012011-01-07 17:49:52 +11002412reval:
Al Viroee0827c2011-02-21 23:38:09 -05002413 flags |= LOOKUP_REVAL;
2414 error = path_lookupat(dfd, pathname,
2415 LOOKUP_PARENT | LOOKUP_REVAL, &nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11002416 }
2417 if (unlikely(error))
2418 goto out_filp;
2419 if (unlikely(!audit_dummy_context()))
Al Viro9b4a9b12009-04-07 11:44:16 -04002420 audit_inode(pathname, nd.path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
2422 /*
Al Viroa2c36b42009-12-24 03:39:50 -05002423 * We have the parent and last component.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 */
Nick Piggin31e6b012011-01-07 17:49:52 +11002425 nd.flags = flags;
Al Viro3e297b62010-03-26 12:40:13 -04002426 filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
Al Viro806b6812009-12-26 07:16:40 -05002427 while (unlikely(!filp)) { /* trailing symlink */
Nick Piggin7b9337a2011-01-14 08:42:43 +00002428 struct path link = path;
2429 struct inode *linki = link.dentry->d_inode;
Al Virodef4af32009-12-26 08:37:05 -05002430 void *cookie;
Al Viro806b6812009-12-26 07:16:40 -05002431 error = -ELOOP;
David Howellsdb372912011-01-14 18:45:53 +00002432 if (!(nd.flags & LOOKUP_FOLLOW))
Al Viro1f36f772009-12-26 10:56:19 -05002433 goto exit_dput;
2434 if (count++ == 32)
Al Viro806b6812009-12-26 07:16:40 -05002435 goto exit_dput;
2436 /*
2437 * This is subtle. Instead of calling do_follow_link() we do
2438 * the thing by hands. The reason is that this way we have zero
2439 * link_count and path_walk() (called from ->follow_link)
2440 * honoring LOOKUP_PARENT. After that we have the parent and
2441 * last component, i.e. we are in the same situation as after
2442 * the first path_walk(). Well, almost - if the last component
2443 * is normal we get its copy stored in nd->last.name and we will
2444 * have to putname() it when we are done. Procfs-like symlinks
2445 * just set LAST_BIND.
2446 */
2447 nd.flags |= LOOKUP_PARENT;
Nick Piggin7b9337a2011-01-14 08:42:43 +00002448 error = security_inode_follow_link(link.dentry, &nd);
Al Viro806b6812009-12-26 07:16:40 -05002449 if (error)
2450 goto exit_dput;
Nick Piggin7b9337a2011-01-14 08:42:43 +00002451 error = __do_follow_link(&link, &nd, &cookie);
Al Virodef4af32009-12-26 08:37:05 -05002452 if (unlikely(error)) {
Nick Piggin7b9337a2011-01-14 08:42:43 +00002453 if (!IS_ERR(cookie) && linki->i_op->put_link)
2454 linki->i_op->put_link(link.dentry, &nd, cookie);
Al Viro806b6812009-12-26 07:16:40 -05002455 /* nd.path had been dropped */
Nick Piggin7b9337a2011-01-14 08:42:43 +00002456 nd.path = link;
Nick Piggin31e6b012011-01-07 17:49:52 +11002457 goto out_path;
Al Viro806b6812009-12-26 07:16:40 -05002458 }
2459 nd.flags &= ~LOOKUP_PARENT;
Al Viro3e297b62010-03-26 12:40:13 -04002460 filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
Nick Piggin7b9337a2011-01-14 08:42:43 +00002461 if (linki->i_op->put_link)
2462 linki->i_op->put_link(link.dentry, &nd, cookie);
2463 path_put(&link);
Al Viro806b6812009-12-26 07:16:40 -05002464 }
Al Viro10fa8e62009-12-26 07:09:49 -05002465out:
Al Viro2a737872009-04-07 11:49:53 -04002466 if (nd.root.mnt)
2467 path_put(&nd.root);
Nick Piggin31e6b012011-01-07 17:49:52 +11002468 if (filp == ERR_PTR(-ESTALE) && !(flags & LOOKUP_REVAL))
Al Viro10fa8e62009-12-26 07:09:49 -05002469 goto reval;
Linus Torvalds2dab5972011-02-11 15:53:38 -08002470 release_open_intent(&nd);
Al Viro10fa8e62009-12-26 07:09:49 -05002471 return filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472
Al Viro806b6812009-12-26 07:16:40 -05002473exit_dput:
2474 path_put_conditional(&path, &nd);
Nick Piggin31e6b012011-01-07 17:49:52 +11002475out_path:
2476 path_put(&nd.path);
2477out_filp:
Al Viro806b6812009-12-26 07:16:40 -05002478 filp = ERR_PTR(error);
Al Viro10fa8e62009-12-26 07:09:49 -05002479 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480}
2481
2482/**
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08002483 * filp_open - open file and return file pointer
2484 *
2485 * @filename: path to open
2486 * @flags: open flags as per the open(2) second argument
2487 * @mode: mode for the new file if O_CREAT is set, else ignored
2488 *
2489 * This is the helper to open a file from kernelspace if you really
2490 * have to. But in generally you should not do this, so please move
2491 * along, nothing to see here..
2492 */
2493struct file *filp_open(const char *filename, int flags, int mode)
2494{
Al Viro6e8341a2009-04-06 11:16:22 -04002495 return do_filp_open(AT_FDCWD, filename, flags, mode, 0);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08002496}
2497EXPORT_SYMBOL(filp_open);
2498
2499/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 * lookup_create - lookup a dentry, creating it if it doesn't exist
2501 * @nd: nameidata info
2502 * @is_dir: directory flag
2503 *
2504 * Simple function to lookup and return a dentry and create it
2505 * if it doesn't exist. Is SMP-safe.
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002506 *
Jan Blunck4ac91372008-02-14 19:34:32 -08002507 * Returns with nd->path.dentry->d_inode->i_mutex locked.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 */
2509struct dentry *lookup_create(struct nameidata *nd, int is_dir)
2510{
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002511 struct dentry *dentry = ERR_PTR(-EEXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512
Jan Blunck4ac91372008-02-14 19:34:32 -08002513 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002514 /*
2515 * Yucky last component or no last component at all?
2516 * (foo/., foo/.., /////)
2517 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 if (nd->last_type != LAST_NORM)
2519 goto fail;
2520 nd->flags &= ~LOOKUP_PARENT;
Al Viro35165862008-08-05 03:00:49 -04002521 nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
ASANO Masahiroa6349042006-08-22 20:06:02 -04002522 nd->intent.open.flags = O_EXCL;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002523
2524 /*
2525 * Do the final lookup.
2526 */
Christoph Hellwig49705b72005-11-08 21:35:06 -08002527 dentry = lookup_hash(nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 if (IS_ERR(dentry))
2529 goto fail;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002530
Al Viroe9baf6e2008-05-15 04:49:12 -04002531 if (dentry->d_inode)
2532 goto eexist;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002533 /*
2534 * Special case - lookup gave negative, but... we had foo/bar/
2535 * From the vfs_mknod() POV we just have a negative dentry -
2536 * all is fine. Let's be bastards - you had / on the end, you've
2537 * been asking for (non-existent) directory. -ENOENT for you.
2538 */
Al Viroe9baf6e2008-05-15 04:49:12 -04002539 if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2540 dput(dentry);
2541 dentry = ERR_PTR(-ENOENT);
2542 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 return dentry;
Al Viroe9baf6e2008-05-15 04:49:12 -04002544eexist:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 dput(dentry);
Al Viroe9baf6e2008-05-15 04:49:12 -04002546 dentry = ERR_PTR(-EEXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547fail:
2548 return dentry;
2549}
Christoph Hellwigf81a0bf2005-05-19 12:26:43 -07002550EXPORT_SYMBOL_GPL(lookup_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551
2552int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2553{
Miklos Szeredia95164d2008-07-30 15:08:48 +02002554 int error = may_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555
2556 if (error)
2557 return error;
2558
2559 if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
2560 return -EPERM;
2561
Al Viroacfa4382008-12-04 10:06:33 -05002562 if (!dir->i_op->mknod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563 return -EPERM;
2564
Serge E. Hallyn08ce5f12008-04-29 01:00:10 -07002565 error = devcgroup_inode_mknod(mode, dev);
2566 if (error)
2567 return error;
2568
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 error = security_inode_mknod(dir, dentry, mode, dev);
2570 if (error)
2571 return error;
2572
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 error = dir->i_op->mknod(dir, dentry, mode, dev);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002574 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002575 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 return error;
2577}
2578
Dave Hansen463c3192008-02-15 14:37:57 -08002579static int may_mknod(mode_t mode)
2580{
2581 switch (mode & S_IFMT) {
2582 case S_IFREG:
2583 case S_IFCHR:
2584 case S_IFBLK:
2585 case S_IFIFO:
2586 case S_IFSOCK:
2587 case 0: /* zero mode translates to S_IFREG */
2588 return 0;
2589 case S_IFDIR:
2590 return -EPERM;
2591 default:
2592 return -EINVAL;
2593 }
2594}
2595
Heiko Carstens2e4d0922009-01-14 14:14:31 +01002596SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2597 unsigned, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598{
Al Viro2ad94ae2008-07-21 09:32:51 -04002599 int error;
2600 char *tmp;
2601 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602 struct nameidata nd;
2603
2604 if (S_ISDIR(mode))
2605 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606
Al Viro2ad94ae2008-07-21 09:32:51 -04002607 error = user_path_parent(dfd, filename, &nd, &tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 if (error)
Al Viro2ad94ae2008-07-21 09:32:51 -04002609 return error;
2610
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 dentry = lookup_create(&nd, 0);
Dave Hansen463c3192008-02-15 14:37:57 -08002612 if (IS_ERR(dentry)) {
2613 error = PTR_ERR(dentry);
2614 goto out_unlock;
2615 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002616 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Al Viroce3b0f82009-03-29 19:08:22 -04002617 mode &= ~current_umask();
Dave Hansen463c3192008-02-15 14:37:57 -08002618 error = may_mknod(mode);
2619 if (error)
2620 goto out_dput;
2621 error = mnt_want_write(nd.path.mnt);
2622 if (error)
2623 goto out_dput;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002624 error = security_path_mknod(&nd.path, dentry, mode, dev);
2625 if (error)
2626 goto out_drop_write;
Dave Hansen463c3192008-02-15 14:37:57 -08002627 switch (mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628 case 0: case S_IFREG:
Jan Blunck4ac91372008-02-14 19:34:32 -08002629 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 break;
2631 case S_IFCHR: case S_IFBLK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002632 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 new_decode_dev(dev));
2634 break;
2635 case S_IFIFO: case S_IFSOCK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002636 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 }
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002639out_drop_write:
Dave Hansen463c3192008-02-15 14:37:57 -08002640 mnt_drop_write(nd.path.mnt);
2641out_dput:
2642 dput(dentry);
2643out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002644 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002645 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 putname(tmp);
2647
2648 return error;
2649}
2650
Heiko Carstens3480b252009-01-14 14:14:16 +01002651SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002652{
2653 return sys_mknodat(AT_FDCWD, filename, mode, dev);
2654}
2655
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2657{
Miklos Szeredia95164d2008-07-30 15:08:48 +02002658 int error = may_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659
2660 if (error)
2661 return error;
2662
Al Viroacfa4382008-12-04 10:06:33 -05002663 if (!dir->i_op->mkdir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 return -EPERM;
2665
2666 mode &= (S_IRWXUGO|S_ISVTX);
2667 error = security_inode_mkdir(dir, dentry, mode);
2668 if (error)
2669 return error;
2670
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 error = dir->i_op->mkdir(dir, dentry, mode);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002672 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002673 fsnotify_mkdir(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 return error;
2675}
2676
Heiko Carstens2e4d0922009-01-14 14:14:31 +01002677SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678{
2679 int error = 0;
2680 char * tmp;
Dave Hansen6902d922006-09-30 23:29:01 -07002681 struct dentry *dentry;
2682 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683
Al Viro2ad94ae2008-07-21 09:32:51 -04002684 error = user_path_parent(dfd, pathname, &nd, &tmp);
2685 if (error)
Dave Hansen6902d922006-09-30 23:29:01 -07002686 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687
Dave Hansen6902d922006-09-30 23:29:01 -07002688 dentry = lookup_create(&nd, 1);
2689 error = PTR_ERR(dentry);
2690 if (IS_ERR(dentry))
2691 goto out_unlock;
2692
Jan Blunck4ac91372008-02-14 19:34:32 -08002693 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Al Viroce3b0f82009-03-29 19:08:22 -04002694 mode &= ~current_umask();
Dave Hansen463c3192008-02-15 14:37:57 -08002695 error = mnt_want_write(nd.path.mnt);
2696 if (error)
2697 goto out_dput;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002698 error = security_path_mkdir(&nd.path, dentry, mode);
2699 if (error)
2700 goto out_drop_write;
Jan Blunck4ac91372008-02-14 19:34:32 -08002701 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002702out_drop_write:
Dave Hansen463c3192008-02-15 14:37:57 -08002703 mnt_drop_write(nd.path.mnt);
2704out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002705 dput(dentry);
2706out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002707 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002708 path_put(&nd.path);
Dave Hansen6902d922006-09-30 23:29:01 -07002709 putname(tmp);
2710out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 return error;
2712}
2713
Heiko Carstens3cdad422009-01-14 14:14:22 +01002714SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002715{
2716 return sys_mkdirat(AT_FDCWD, pathname, mode);
2717}
2718
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719/*
2720 * We try to drop the dentry early: we should have
2721 * a usage count of 2 if we're the only user of this
2722 * dentry, and if that is true (possibly after pruning
2723 * the dcache), then we drop the dentry now.
2724 *
2725 * A low-level filesystem can, if it choses, legally
2726 * do a
2727 *
2728 * if (!d_unhashed(dentry))
2729 * return -EBUSY;
2730 *
2731 * if it cannot handle the case of removing a directory
2732 * that is still in use by something else..
2733 */
2734void dentry_unhash(struct dentry *dentry)
2735{
2736 dget(dentry);
Vasily Averindc168422006-12-06 20:37:07 -08002737 shrink_dcache_parent(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 spin_lock(&dentry->d_lock);
Nick Pigginb7ab39f2011-01-07 17:49:32 +11002739 if (dentry->d_count == 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 __d_drop(dentry);
2741 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742}
2743
2744int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2745{
2746 int error = may_delete(dir, dentry, 1);
2747
2748 if (error)
2749 return error;
2750
Al Viroacfa4382008-12-04 10:06:33 -05002751 if (!dir->i_op->rmdir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 return -EPERM;
2753
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002754 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 dentry_unhash(dentry);
2756 if (d_mountpoint(dentry))
2757 error = -EBUSY;
2758 else {
2759 error = security_inode_rmdir(dir, dentry);
2760 if (!error) {
2761 error = dir->i_op->rmdir(dir, dentry);
Al Virod83c49f2010-04-30 17:17:09 -04002762 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 dentry->d_inode->i_flags |= S_DEAD;
Al Virod83c49f2010-04-30 17:17:09 -04002764 dont_mount(dentry);
2765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 }
2767 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002768 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 d_delete(dentry);
2771 }
2772 dput(dentry);
2773
2774 return error;
2775}
2776
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002777static long do_rmdir(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778{
2779 int error = 0;
2780 char * name;
2781 struct dentry *dentry;
2782 struct nameidata nd;
2783
Al Viro2ad94ae2008-07-21 09:32:51 -04002784 error = user_path_parent(dfd, pathname, &nd, &name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 if (error)
Al Viro2ad94ae2008-07-21 09:32:51 -04002786 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787
2788 switch(nd.last_type) {
OGAWA Hirofumi0612d9f2008-10-16 07:50:29 +09002789 case LAST_DOTDOT:
2790 error = -ENOTEMPTY;
2791 goto exit1;
2792 case LAST_DOT:
2793 error = -EINVAL;
2794 goto exit1;
2795 case LAST_ROOT:
2796 error = -EBUSY;
2797 goto exit1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 }
OGAWA Hirofumi0612d9f2008-10-16 07:50:29 +09002799
2800 nd.flags &= ~LOOKUP_PARENT;
2801
Jan Blunck4ac91372008-02-14 19:34:32 -08002802 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002803 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 error = PTR_ERR(dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07002805 if (IS_ERR(dentry))
2806 goto exit2;
Dave Hansen06227532008-02-15 14:37:34 -08002807 error = mnt_want_write(nd.path.mnt);
2808 if (error)
2809 goto exit3;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002810 error = security_path_rmdir(&nd.path, dentry);
2811 if (error)
2812 goto exit4;
Jan Blunck4ac91372008-02-14 19:34:32 -08002813 error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002814exit4:
Dave Hansen06227532008-02-15 14:37:34 -08002815 mnt_drop_write(nd.path.mnt);
2816exit3:
Dave Hansen6902d922006-09-30 23:29:01 -07002817 dput(dentry);
2818exit2:
Jan Blunck4ac91372008-02-14 19:34:32 -08002819 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002821 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 putname(name);
2823 return error;
2824}
2825
Heiko Carstens3cdad422009-01-14 14:14:22 +01002826SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002827{
2828 return do_rmdir(AT_FDCWD, pathname);
2829}
2830
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831int vfs_unlink(struct inode *dir, struct dentry *dentry)
2832{
2833 int error = may_delete(dir, dentry, 0);
2834
2835 if (error)
2836 return error;
2837
Al Viroacfa4382008-12-04 10:06:33 -05002838 if (!dir->i_op->unlink)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 return -EPERM;
2840
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002841 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 if (d_mountpoint(dentry))
2843 error = -EBUSY;
2844 else {
2845 error = security_inode_unlink(dir, dentry);
Al Virobec10522010-03-03 14:12:08 -05002846 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 error = dir->i_op->unlink(dir, dentry);
Al Virobec10522010-03-03 14:12:08 -05002848 if (!error)
Al Virod83c49f2010-04-30 17:17:09 -04002849 dont_mount(dentry);
Al Virobec10522010-03-03 14:12:08 -05002850 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002852 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853
2854 /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2855 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
Jan Karaece95912008-02-06 01:37:13 -08002856 fsnotify_link_count(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857 d_delete(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 }
Robert Love0eeca282005-07-12 17:06:03 -04002859
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 return error;
2861}
2862
2863/*
2864 * Make sure that the actual truncation of the file will occur outside its
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002865 * directory's i_mutex. Truncate can take a long time if there is a lot of
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 * writeout happening, and we don't want to prevent access to the directory
2867 * while waiting on the I/O.
2868 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002869static long do_unlinkat(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870{
Al Viro2ad94ae2008-07-21 09:32:51 -04002871 int error;
2872 char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 struct dentry *dentry;
2874 struct nameidata nd;
2875 struct inode *inode = NULL;
2876
Al Viro2ad94ae2008-07-21 09:32:51 -04002877 error = user_path_parent(dfd, pathname, &nd, &name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 if (error)
Al Viro2ad94ae2008-07-21 09:32:51 -04002879 return error;
2880
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 error = -EISDIR;
2882 if (nd.last_type != LAST_NORM)
2883 goto exit1;
OGAWA Hirofumi0612d9f2008-10-16 07:50:29 +09002884
2885 nd.flags &= ~LOOKUP_PARENT;
2886
Jan Blunck4ac91372008-02-14 19:34:32 -08002887 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002888 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 error = PTR_ERR(dentry);
2890 if (!IS_ERR(dentry)) {
2891 /* Why not before? Because we want correct error value */
2892 if (nd.last.name[nd.last.len])
2893 goto slashes;
2894 inode = dentry->d_inode;
2895 if (inode)
Al Viro7de9c6ee2010-10-23 11:11:40 -04002896 ihold(inode);
Dave Hansen06227532008-02-15 14:37:34 -08002897 error = mnt_want_write(nd.path.mnt);
2898 if (error)
2899 goto exit2;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002900 error = security_path_unlink(&nd.path, dentry);
2901 if (error)
2902 goto exit3;
Jan Blunck4ac91372008-02-14 19:34:32 -08002903 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002904exit3:
Dave Hansen06227532008-02-15 14:37:34 -08002905 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 exit2:
2907 dput(dentry);
2908 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002909 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 if (inode)
2911 iput(inode); /* truncate the inode here */
2912exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002913 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 putname(name);
2915 return error;
2916
2917slashes:
2918 error = !dentry->d_inode ? -ENOENT :
2919 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2920 goto exit2;
2921}
2922
Heiko Carstens2e4d0922009-01-14 14:14:31 +01002923SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002924{
2925 if ((flag & ~AT_REMOVEDIR) != 0)
2926 return -EINVAL;
2927
2928 if (flag & AT_REMOVEDIR)
2929 return do_rmdir(dfd, pathname);
2930
2931 return do_unlinkat(dfd, pathname);
2932}
2933
Heiko Carstens3480b252009-01-14 14:14:16 +01002934SYSCALL_DEFINE1(unlink, const char __user *, pathname)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002935{
2936 return do_unlinkat(AT_FDCWD, pathname);
2937}
2938
Miklos Szeredidb2e7472008-06-24 16:50:16 +02002939int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940{
Miklos Szeredia95164d2008-07-30 15:08:48 +02002941 int error = may_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942
2943 if (error)
2944 return error;
2945
Al Viroacfa4382008-12-04 10:06:33 -05002946 if (!dir->i_op->symlink)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 return -EPERM;
2948
2949 error = security_inode_symlink(dir, dentry, oldname);
2950 if (error)
2951 return error;
2952
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 error = dir->i_op->symlink(dir, dentry, oldname);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002954 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002955 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 return error;
2957}
2958
Heiko Carstens2e4d0922009-01-14 14:14:31 +01002959SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2960 int, newdfd, const char __user *, newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961{
Al Viro2ad94ae2008-07-21 09:32:51 -04002962 int error;
2963 char *from;
2964 char *to;
Dave Hansen6902d922006-09-30 23:29:01 -07002965 struct dentry *dentry;
2966 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
2968 from = getname(oldname);
Al Viro2ad94ae2008-07-21 09:32:51 -04002969 if (IS_ERR(from))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 return PTR_ERR(from);
Al Viro2ad94ae2008-07-21 09:32:51 -04002971
2972 error = user_path_parent(newdfd, newname, &nd, &to);
2973 if (error)
Dave Hansen6902d922006-09-30 23:29:01 -07002974 goto out_putname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975
Dave Hansen6902d922006-09-30 23:29:01 -07002976 dentry = lookup_create(&nd, 0);
2977 error = PTR_ERR(dentry);
2978 if (IS_ERR(dentry))
2979 goto out_unlock;
2980
Dave Hansen75c3f292008-02-15 14:37:45 -08002981 error = mnt_want_write(nd.path.mnt);
2982 if (error)
2983 goto out_dput;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002984 error = security_path_symlink(&nd.path, dentry, from);
2985 if (error)
2986 goto out_drop_write;
Miklos Szeredidb2e7472008-06-24 16:50:16 +02002987 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09002988out_drop_write:
Dave Hansen75c3f292008-02-15 14:37:45 -08002989 mnt_drop_write(nd.path.mnt);
2990out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002991 dput(dentry);
2992out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002993 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002994 path_put(&nd.path);
Dave Hansen6902d922006-09-30 23:29:01 -07002995 putname(to);
2996out_putname:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 putname(from);
2998 return error;
2999}
3000
Heiko Carstens3480b252009-01-14 14:14:16 +01003001SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08003002{
3003 return sys_symlinkat(oldname, AT_FDCWD, newname);
3004}
3005
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
3007{
3008 struct inode *inode = old_dentry->d_inode;
3009 int error;
3010
3011 if (!inode)
3012 return -ENOENT;
3013
Miklos Szeredia95164d2008-07-30 15:08:48 +02003014 error = may_create(dir, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 if (error)
3016 return error;
3017
3018 if (dir->i_sb != inode->i_sb)
3019 return -EXDEV;
3020
3021 /*
3022 * A link to an append-only or immutable file cannot be created.
3023 */
3024 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3025 return -EPERM;
Al Viroacfa4382008-12-04 10:06:33 -05003026 if (!dir->i_op->link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 return -EPERM;
Tetsuo Handa7e79eed2008-06-24 16:50:15 +02003028 if (S_ISDIR(inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029 return -EPERM;
3030
3031 error = security_inode_link(old_dentry, dir, new_dentry);
3032 if (error)
3033 return error;
3034
Tetsuo Handa7e79eed2008-06-24 16:50:15 +02003035 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 error = dir->i_op->link(old_dentry, dir, new_dentry);
Tetsuo Handa7e79eed2008-06-24 16:50:15 +02003037 mutex_unlock(&inode->i_mutex);
Stephen Smalleye31e14e2005-09-09 13:01:45 -07003038 if (!error)
Tetsuo Handa7e79eed2008-06-24 16:50:15 +02003039 fsnotify_link(dir, inode, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 return error;
3041}
3042
3043/*
3044 * Hardlinks are often used in delicate situations. We avoid
3045 * security-related surprises by not following symlinks on the
3046 * newname. --KAB
3047 *
3048 * We don't follow them on the oldname either to be compatible
3049 * with linux 2.0, and to avoid hard-linking to directories
3050 * and other special files. --ADM
3051 */
Heiko Carstens2e4d0922009-01-14 14:14:31 +01003052SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
3053 int, newdfd, const char __user *, newname, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054{
3055 struct dentry *new_dentry;
Al Viro2d8f3032008-07-22 09:59:21 -04003056 struct nameidata nd;
3057 struct path old_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 int error;
Al Viro2ad94ae2008-07-21 09:32:51 -04003059 char *to;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060
Ulrich Drepper45c9b11a2006-06-25 05:49:11 -07003061 if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
Ulrich Drepperc04030e2006-02-24 13:04:21 -08003062 return -EINVAL;
3063
Al Viro2d8f3032008-07-22 09:59:21 -04003064 error = user_path_at(olddfd, oldname,
3065 flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
3066 &old_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 if (error)
Al Viro2ad94ae2008-07-21 09:32:51 -04003068 return error;
3069
3070 error = user_path_parent(newdfd, newname, &nd, &to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 if (error)
3072 goto out;
3073 error = -EXDEV;
Al Viro2d8f3032008-07-22 09:59:21 -04003074 if (old_path.mnt != nd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075 goto out_release;
3076 new_dentry = lookup_create(&nd, 0);
3077 error = PTR_ERR(new_dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07003078 if (IS_ERR(new_dentry))
3079 goto out_unlock;
Dave Hansen75c3f292008-02-15 14:37:45 -08003080 error = mnt_want_write(nd.path.mnt);
3081 if (error)
3082 goto out_dput;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09003083 error = security_path_link(old_path.dentry, &nd.path, new_dentry);
3084 if (error)
3085 goto out_drop_write;
Al Viro2d8f3032008-07-22 09:59:21 -04003086 error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09003087out_drop_write:
Dave Hansen75c3f292008-02-15 14:37:45 -08003088 mnt_drop_write(nd.path.mnt);
3089out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07003090 dput(new_dentry);
3091out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08003092 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093out_release:
Jan Blunck1d957f92008-02-14 19:34:35 -08003094 path_put(&nd.path);
Al Viro2ad94ae2008-07-21 09:32:51 -04003095 putname(to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096out:
Al Viro2d8f3032008-07-22 09:59:21 -04003097 path_put(&old_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098
3099 return error;
3100}
3101
Heiko Carstens3480b252009-01-14 14:14:16 +01003102SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08003103{
Ulrich Drepperc04030e2006-02-24 13:04:21 -08003104 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08003105}
3106
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107/*
3108 * The worst of all namespace operations - renaming directory. "Perverted"
3109 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
3110 * Problems:
3111 * a) we can get into loop creation. Check is done in is_subdir().
3112 * b) race potential - two innocent renames can create a loop together.
3113 * That's where 4.4 screws up. Current fix: serialization on
Arjan van de Vena11f3a02006-03-23 03:00:33 -08003114 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 * story.
3116 * c) we have to lock _three_ objects - parents and victim (if it exists).
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003117 * And that - after we got ->i_mutex on parents (until then we don't know
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 * whether the target exists). Solution: try to be smart with locking
3119 * order for inodes. We rely on the fact that tree topology may change
Arjan van de Vena11f3a02006-03-23 03:00:33 -08003120 * only under ->s_vfs_rename_mutex _and_ that parent of the object we
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 * move will be locked. Thus we can rank directories by the tree
3122 * (ancestors first) and rank all non-directories after them.
3123 * That works since everybody except rename does "lock parent, lookup,
Arjan van de Vena11f3a02006-03-23 03:00:33 -08003124 * lock child" and rename is under ->s_vfs_rename_mutex.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 * HOWEVER, it relies on the assumption that any object with ->lookup()
3126 * has no more than 1 dentry. If "hybrid" objects will ever appear,
3127 * we'd better make sure that there's no link(2) for them.
3128 * d) some filesystems don't support opened-but-unlinked directories,
3129 * either because of layout or because they are not ready to deal with
3130 * all cases correctly. The latter will be fixed (taking this sort of
3131 * stuff into VFS), but the former is not going away. Solution: the same
3132 * trick as in rmdir().
3133 * e) conversion from fhandle to dentry may come in the wrong moment - when
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003134 * we are removing the target. Solution: we will have to grab ->i_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
Adam Buchbinderc41b20e2009-12-11 16:35:39 -05003136 * ->i_mutex on parents, which works but leads to some truly excessive
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 * locking].
3138 */
Adrian Bunk75c96f82005-05-05 16:16:09 -07003139static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
3140 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141{
3142 int error = 0;
3143 struct inode *target;
3144
3145 /*
3146 * If we are going to change the parent - check write permissions,
3147 * we'll need to flip '..'.
3148 */
3149 if (new_dir != old_dir) {
Al Virof419a2e2008-07-22 00:07:17 -04003150 error = inode_permission(old_dentry->d_inode, MAY_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 if (error)
3152 return error;
3153 }
3154
3155 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3156 if (error)
3157 return error;
3158
3159 target = new_dentry->d_inode;
Al Virod83c49f2010-04-30 17:17:09 -04003160 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003161 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3163 error = -EBUSY;
Al Virod83c49f2010-04-30 17:17:09 -04003164 else {
3165 if (target)
3166 dentry_unhash(new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
Al Virod83c49f2010-04-30 17:17:09 -04003168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 if (target) {
Al Virod83c49f2010-04-30 17:17:09 -04003170 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 target->i_flags |= S_DEAD;
Al Virod83c49f2010-04-30 17:17:09 -04003172 dont_mount(new_dentry);
3173 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003174 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175 if (d_unhashed(new_dentry))
3176 d_rehash(new_dentry);
3177 dput(new_dentry);
3178 }
Stephen Smalleye31e14e2005-09-09 13:01:45 -07003179 if (!error)
Mark Fasheh349457c2006-09-08 14:22:21 -07003180 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3181 d_move(old_dentry,new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 return error;
3183}
3184
Adrian Bunk75c96f82005-05-05 16:16:09 -07003185static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
3186 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187{
3188 struct inode *target;
3189 int error;
3190
3191 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3192 if (error)
3193 return error;
3194
3195 dget(new_dentry);
3196 target = new_dentry->d_inode;
3197 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003198 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3200 error = -EBUSY;
3201 else
3202 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3203 if (!error) {
Al Virobec10522010-03-03 14:12:08 -05003204 if (target)
Al Virod83c49f2010-04-30 17:17:09 -04003205 dont_mount(new_dentry);
Mark Fasheh349457c2006-09-08 14:22:21 -07003206 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 d_move(old_dentry, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 }
3209 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08003210 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 dput(new_dentry);
3212 return error;
3213}
3214
3215int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
3216 struct inode *new_dir, struct dentry *new_dentry)
3217{
3218 int error;
3219 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
Eric Paris59b0df22010-02-08 12:53:52 -05003220 const unsigned char *old_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221
3222 if (old_dentry->d_inode == new_dentry->d_inode)
3223 return 0;
3224
3225 error = may_delete(old_dir, old_dentry, is_dir);
3226 if (error)
3227 return error;
3228
3229 if (!new_dentry->d_inode)
Miklos Szeredia95164d2008-07-30 15:08:48 +02003230 error = may_create(new_dir, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 else
3232 error = may_delete(new_dir, new_dentry, is_dir);
3233 if (error)
3234 return error;
3235
Al Viroacfa4382008-12-04 10:06:33 -05003236 if (!old_dir->i_op->rename)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 return -EPERM;
3238
Robert Love0eeca282005-07-12 17:06:03 -04003239 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
3240
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241 if (is_dir)
3242 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
3243 else
3244 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
Al Viro123df292009-12-25 04:57:57 -05003245 if (!error)
3246 fsnotify_move(old_dir, new_dir, old_name, is_dir,
Al Viro5a190ae2007-06-07 12:19:32 -04003247 new_dentry->d_inode, old_dentry);
Robert Love0eeca282005-07-12 17:06:03 -04003248 fsnotify_oldname_free(old_name);
3249
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250 return error;
3251}
3252
Heiko Carstens2e4d0922009-01-14 14:14:31 +01003253SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
3254 int, newdfd, const char __user *, newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255{
Al Viro2ad94ae2008-07-21 09:32:51 -04003256 struct dentry *old_dir, *new_dir;
3257 struct dentry *old_dentry, *new_dentry;
3258 struct dentry *trap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 struct nameidata oldnd, newnd;
Al Viro2ad94ae2008-07-21 09:32:51 -04003260 char *from;
3261 char *to;
3262 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263
Al Viro2ad94ae2008-07-21 09:32:51 -04003264 error = user_path_parent(olddfd, oldname, &oldnd, &from);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265 if (error)
3266 goto exit;
3267
Al Viro2ad94ae2008-07-21 09:32:51 -04003268 error = user_path_parent(newdfd, newname, &newnd, &to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269 if (error)
3270 goto exit1;
3271
3272 error = -EXDEV;
Jan Blunck4ac91372008-02-14 19:34:32 -08003273 if (oldnd.path.mnt != newnd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003274 goto exit2;
3275
Jan Blunck4ac91372008-02-14 19:34:32 -08003276 old_dir = oldnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277 error = -EBUSY;
3278 if (oldnd.last_type != LAST_NORM)
3279 goto exit2;
3280
Jan Blunck4ac91372008-02-14 19:34:32 -08003281 new_dir = newnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282 if (newnd.last_type != LAST_NORM)
3283 goto exit2;
3284
OGAWA Hirofumi0612d9f2008-10-16 07:50:29 +09003285 oldnd.flags &= ~LOOKUP_PARENT;
3286 newnd.flags &= ~LOOKUP_PARENT;
OGAWA Hirofumi4e9ed2f2008-10-16 07:50:29 +09003287 newnd.flags |= LOOKUP_RENAME_TARGET;
OGAWA Hirofumi0612d9f2008-10-16 07:50:29 +09003288
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 trap = lock_rename(new_dir, old_dir);
3290
Christoph Hellwig49705b72005-11-08 21:35:06 -08003291 old_dentry = lookup_hash(&oldnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 error = PTR_ERR(old_dentry);
3293 if (IS_ERR(old_dentry))
3294 goto exit3;
3295 /* source must exist */
3296 error = -ENOENT;
3297 if (!old_dentry->d_inode)
3298 goto exit4;
3299 /* unless the source is a directory trailing slashes give -ENOTDIR */
3300 if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
3301 error = -ENOTDIR;
3302 if (oldnd.last.name[oldnd.last.len])
3303 goto exit4;
3304 if (newnd.last.name[newnd.last.len])
3305 goto exit4;
3306 }
3307 /* source should not be ancestor of target */
3308 error = -EINVAL;
3309 if (old_dentry == trap)
3310 goto exit4;
Christoph Hellwig49705b72005-11-08 21:35:06 -08003311 new_dentry = lookup_hash(&newnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 error = PTR_ERR(new_dentry);
3313 if (IS_ERR(new_dentry))
3314 goto exit4;
3315 /* target should not be an ancestor of source */
3316 error = -ENOTEMPTY;
3317 if (new_dentry == trap)
3318 goto exit5;
3319
Dave Hansen9079b1e2008-02-15 14:37:49 -08003320 error = mnt_want_write(oldnd.path.mnt);
3321 if (error)
3322 goto exit5;
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09003323 error = security_path_rename(&oldnd.path, old_dentry,
3324 &newnd.path, new_dentry);
3325 if (error)
3326 goto exit6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327 error = vfs_rename(old_dir->d_inode, old_dentry,
3328 new_dir->d_inode, new_dentry);
Kentaro Takedabe6d3e52008-12-17 13:24:15 +09003329exit6:
Dave Hansen9079b1e2008-02-15 14:37:49 -08003330 mnt_drop_write(oldnd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331exit5:
3332 dput(new_dentry);
3333exit4:
3334 dput(old_dentry);
3335exit3:
3336 unlock_rename(new_dir, old_dir);
3337exit2:
Jan Blunck1d957f92008-02-14 19:34:35 -08003338 path_put(&newnd.path);
Al Viro2ad94ae2008-07-21 09:32:51 -04003339 putname(to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08003341 path_put(&oldnd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342 putname(from);
Al Viro2ad94ae2008-07-21 09:32:51 -04003343exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344 return error;
3345}
3346
Heiko Carstensa26eab22009-01-14 14:14:17 +01003347SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08003348{
3349 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
3350}
3351
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
3353{
3354 int len;
3355
3356 len = PTR_ERR(link);
3357 if (IS_ERR(link))
3358 goto out;
3359
3360 len = strlen(link);
3361 if (len > (unsigned) buflen)
3362 len = buflen;
3363 if (copy_to_user(buffer, link, len))
3364 len = -EFAULT;
3365out:
3366 return len;
3367}
3368
3369/*
3370 * A helper for ->readlink(). This should be used *ONLY* for symlinks that
3371 * have ->follow_link() touching nd only in nd_set_link(). Using (or not
3372 * using) it for any given inode is up to filesystem.
3373 */
3374int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3375{
3376 struct nameidata nd;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003377 void *cookie;
Marcin Slusarz694a1762008-06-09 16:40:37 -07003378 int res;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003379
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 nd.depth = 0;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003381 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
Marcin Slusarz694a1762008-06-09 16:40:37 -07003382 if (IS_ERR(cookie))
3383 return PTR_ERR(cookie);
3384
3385 res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
3386 if (dentry->d_inode->i_op->put_link)
3387 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
3388 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003389}
3390
3391int vfs_follow_link(struct nameidata *nd, const char *link)
3392{
3393 return __vfs_follow_link(nd, link);
3394}
3395
3396/* get the link contents into pagecache */
3397static char *page_getlink(struct dentry * dentry, struct page **ppage)
3398{
Duane Griffinebd09ab2008-12-19 20:47:12 +00003399 char *kaddr;
3400 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 struct address_space *mapping = dentry->d_inode->i_mapping;
Pekka Enberg090d2b12006-06-23 02:05:08 -07003402 page = read_mapping_page(mapping, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 if (IS_ERR(page))
Nick Piggin6fe69002007-05-06 14:49:04 -07003404 return (char*)page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003405 *ppage = page;
Duane Griffinebd09ab2008-12-19 20:47:12 +00003406 kaddr = kmap(page);
3407 nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
3408 return kaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409}
3410
3411int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3412{
3413 struct page *page = NULL;
3414 char *s = page_getlink(dentry, &page);
3415 int res = vfs_readlink(dentry,buffer,buflen,s);
3416 if (page) {
3417 kunmap(page);
3418 page_cache_release(page);
3419 }
3420 return res;
3421}
3422
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003423void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003425 struct page *page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 nd_set_link(nd, page_getlink(dentry, &page));
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003427 return page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428}
3429
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003430void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003431{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07003432 struct page *page = cookie;
3433
3434 if (page) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435 kunmap(page);
3436 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 }
3438}
3439
Nick Piggin54566b22009-01-04 12:00:53 -08003440/*
3441 * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
3442 */
3443int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444{
3445 struct address_space *mapping = inode->i_mapping;
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08003446 struct page *page;
Nick Pigginafddba42007-10-16 01:25:01 -07003447 void *fsdata;
Dmitriy Monakhovbeb497a2007-02-16 01:27:18 -08003448 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 char *kaddr;
Nick Piggin54566b22009-01-04 12:00:53 -08003450 unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
3451 if (nofs)
3452 flags |= AOP_FLAG_NOFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453
NeilBrown7e53cac2006-03-25 03:07:57 -08003454retry:
Nick Pigginafddba42007-10-16 01:25:01 -07003455 err = pagecache_write_begin(NULL, mapping, 0, len-1,
Nick Piggin54566b22009-01-04 12:00:53 -08003456 flags, &page, &fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 if (err)
Nick Pigginafddba42007-10-16 01:25:01 -07003458 goto fail;
3459
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460 kaddr = kmap_atomic(page, KM_USER0);
3461 memcpy(kaddr, symname, len-1);
3462 kunmap_atomic(kaddr, KM_USER0);
Nick Pigginafddba42007-10-16 01:25:01 -07003463
3464 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
3465 page, fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466 if (err < 0)
3467 goto fail;
Nick Pigginafddba42007-10-16 01:25:01 -07003468 if (err < len-1)
3469 goto retry;
3470
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471 mark_inode_dirty(inode);
3472 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473fail:
3474 return err;
3475}
3476
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08003477int page_symlink(struct inode *inode, const char *symname, int len)
3478{
3479 return __page_symlink(inode, symname, len,
Nick Piggin54566b22009-01-04 12:00:53 -08003480 !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08003481}
3482
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08003483const struct inode_operations page_symlink_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 .readlink = generic_readlink,
3485 .follow_link = page_follow_link_light,
3486 .put_link = page_put_link,
3487};
3488
Al Viro2d8f3032008-07-22 09:59:21 -04003489EXPORT_SYMBOL(user_path_at);
David Howellscc53ce52011-01-14 18:45:26 +00003490EXPORT_SYMBOL(follow_down_one);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491EXPORT_SYMBOL(follow_down);
3492EXPORT_SYMBOL(follow_up);
3493EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
3494EXPORT_SYMBOL(getname);
3495EXPORT_SYMBOL(lock_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496EXPORT_SYMBOL(lookup_one_len);
3497EXPORT_SYMBOL(page_follow_link_light);
3498EXPORT_SYMBOL(page_put_link);
3499EXPORT_SYMBOL(page_readlink);
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08003500EXPORT_SYMBOL(__page_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501EXPORT_SYMBOL(page_symlink);
3502EXPORT_SYMBOL(page_symlink_inode_operations);
Al Viroc9c6cac2011-02-16 15:15:47 -05003503EXPORT_SYMBOL(kern_path_parent);
Al Virod1811462008-08-02 00:49:18 -04003504EXPORT_SYMBOL(kern_path);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07003505EXPORT_SYMBOL(vfs_path_lookup);
Al Virof419a2e2008-07-22 00:07:17 -04003506EXPORT_SYMBOL(inode_permission);
Christoph Hellwig8c744fb2005-11-08 21:35:04 -08003507EXPORT_SYMBOL(file_permission);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508EXPORT_SYMBOL(unlock_rename);
3509EXPORT_SYMBOL(vfs_create);
3510EXPORT_SYMBOL(vfs_follow_link);
3511EXPORT_SYMBOL(vfs_link);
3512EXPORT_SYMBOL(vfs_mkdir);
3513EXPORT_SYMBOL(vfs_mknod);
3514EXPORT_SYMBOL(generic_permission);
3515EXPORT_SYMBOL(vfs_readlink);
3516EXPORT_SYMBOL(vfs_rename);
3517EXPORT_SYMBOL(vfs_rmdir);
3518EXPORT_SYMBOL(vfs_symlink);
3519EXPORT_SYMBOL(vfs_unlink);
3520EXPORT_SYMBOL(dentry_unhash);
3521EXPORT_SYMBOL(generic_readlink);