blob: 00df735fb50978c88f8267b769c86da6c860b6d9 [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>
22#include <linux/quotaops.h>
23#include <linux/pagemap.h>
Robert Love0eeca282005-07-12 17:06:03 -040024#include <linux/fsnotify.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/personality.h>
26#include <linux/security.h>
27#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/namei.h>
34#include <asm/uaccess.h>
35
36#define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
37
38/* [Feb-1997 T. Schoebel-Theuer]
39 * Fundamental changes in the pathname lookup mechanisms (namei)
40 * were necessary because of omirr. The reason is that omirr needs
41 * to know the _real_ pathname, not the user-supplied one, in case
42 * of symlinks (and also when transname replacements occur).
43 *
44 * The new code replaces the old recursive symlink resolution with
45 * an iterative one (in case of non-nested symlink chains). It does
46 * this with calls to <fs>_follow_link().
47 * As a side effect, dir_namei(), _namei() and follow_link() are now
48 * replaced with a single function lookup_dentry() that can handle all
49 * the special cases of the former code.
50 *
51 * With the new dcache, the pathname is stored at each inode, at least as
52 * long as the refcount of the inode is positive. As a side effect, the
53 * size of the dcache depends on the inode cache and thus is dynamic.
54 *
55 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
56 * resolution to correspond with current state of the code.
57 *
58 * Note that the symlink resolution is not *completely* iterative.
59 * There is still a significant amount of tail- and mid- recursion in
60 * the algorithm. Also, note that <fs>_readlink() is not used in
61 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
62 * may return different results than <fs>_follow_link(). Many virtual
63 * filesystems (including /proc) exhibit this behavior.
64 */
65
66/* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
67 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
68 * and the name already exists in form of a symlink, try to create the new
69 * name indicated by the symlink. The old code always complained that the
70 * name already exists, due to not following the symlink even if its target
71 * is nonexistent. The new semantics affects also mknod() and link() when
72 * the name is a symlink pointing to a non-existant name.
73 *
74 * I don't know which semantics is the right one, since I have no access
75 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
76 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
77 * "old" one. Personally, I think the new semantics is much more logical.
78 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
79 * file does succeed in both HP-UX and SunOs, but not in Solaris
80 * and in the old Linux semantics.
81 */
82
83/* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
84 * semantics. See the comments in "open_namei" and "do_link" below.
85 *
86 * [10-Sep-98 Alan Modra] Another symlink change.
87 */
88
89/* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
90 * inside the path - always follow.
91 * in the last component in creation/removal/renaming - never follow.
92 * if LOOKUP_FOLLOW passed - follow.
93 * if the pathname has trailing slashes - follow.
94 * otherwise - don't follow.
95 * (applied in that order).
96 *
97 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
98 * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
99 * During the 2.4 we need to fix the userland stuff depending on it -
100 * hopefully we will be able to get rid of that wart in 2.5. So far only
101 * XEmacs seems to be relying on it...
102 */
103/*
104 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
Arjan van de Vena11f3a02006-03-23 03:00:33 -0800105 * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 * any extra contention...
107 */
108
Al Viroa02f76c2008-02-23 15:14:28 +0000109static int __link_path_walk(const char *name, struct nameidata *nd);
Josef 'Jeff' Sipekc4a78082007-07-19 01:48:22 -0700110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111/* In order to reduce some races, while at the same time doing additional
112 * checking and hopefully speeding things up, we copy filenames to the
113 * kernel data space before using them..
114 *
115 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
116 * PATH_MAX includes the nul terminator --RR.
117 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800118static int do_getname(const char __user *filename, char *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
120 int retval;
121 unsigned long len = PATH_MAX;
122
123 if (!segment_eq(get_fs(), KERNEL_DS)) {
124 if ((unsigned long) filename >= TASK_SIZE)
125 return -EFAULT;
126 if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
127 len = TASK_SIZE - (unsigned long) filename;
128 }
129
130 retval = strncpy_from_user(page, filename, len);
131 if (retval > 0) {
132 if (retval < len)
133 return 0;
134 return -ENAMETOOLONG;
135 } else if (!retval)
136 retval = -ENOENT;
137 return retval;
138}
139
140char * getname(const char __user * filename)
141{
142 char *tmp, *result;
143
144 result = ERR_PTR(-ENOMEM);
145 tmp = __getname();
146 if (tmp) {
147 int retval = do_getname(filename, tmp);
148
149 result = tmp;
150 if (retval < 0) {
151 __putname(tmp);
152 result = ERR_PTR(retval);
153 }
154 }
155 audit_getname(result);
156 return result;
157}
158
159#ifdef CONFIG_AUDITSYSCALL
160void putname(const char *name)
161{
Al Viro5ac3a9c2006-07-16 06:38:45 -0400162 if (unlikely(!audit_dummy_context()))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 audit_putname(name);
164 else
165 __putname(name);
166}
167EXPORT_SYMBOL(putname);
168#endif
169
170
171/**
172 * generic_permission - check for access rights on a Posix-like filesystem
173 * @inode: inode to check access rights for
174 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
175 * @check_acl: optional callback to check for Posix ACLs
176 *
177 * Used to check for read/write/execute permissions on a file.
178 * We use "fsuid" for this, letting us set arbitrary permissions
179 * for filesystem access without changing the "normal" uids which
180 * are used for other things..
181 */
182int generic_permission(struct inode *inode, int mask,
183 int (*check_acl)(struct inode *inode, int mask))
184{
185 umode_t mode = inode->i_mode;
186
187 if (current->fsuid == inode->i_uid)
188 mode >>= 6;
189 else {
190 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
191 int error = check_acl(inode, mask);
192 if (error == -EACCES)
193 goto check_capabilities;
194 else if (error != -EAGAIN)
195 return error;
196 }
197
198 if (in_group_p(inode->i_gid))
199 mode >>= 3;
200 }
201
202 /*
203 * If the DACs are ok we don't need any capability check.
204 */
205 if (((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask))
206 return 0;
207
208 check_capabilities:
209 /*
210 * Read/write DACs are always overridable.
211 * Executable DACs are overridable if at least one exec bit is set.
212 */
213 if (!(mask & MAY_EXEC) ||
214 (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
215 if (capable(CAP_DAC_OVERRIDE))
216 return 0;
217
218 /*
219 * Searching includes executable on directories, else just read.
220 */
221 if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
222 if (capable(CAP_DAC_READ_SEARCH))
223 return 0;
224
225 return -EACCES;
226}
227
228int permission(struct inode *inode, int mask, struct nameidata *nd)
229{
230 int retval, submask;
Dave Hansenc7eb2662007-10-16 23:31:14 -0700231 struct vfsmount *mnt = NULL;
232
233 if (nd)
Jan Blunck4ac91372008-02-14 19:34:32 -0800234 mnt = nd->path.mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 if (mask & MAY_WRITE) {
Miklos Szeredi22590e42007-10-16 23:27:08 -0700237 umode_t mode = inode->i_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239 /*
240 * Nobody gets write access to a read-only fs.
241 */
242 if (IS_RDONLY(inode) &&
243 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
244 return -EROFS;
245
246 /*
247 * Nobody gets write access to an immutable file.
248 */
249 if (IS_IMMUTABLE(inode))
250 return -EACCES;
251 }
252
Miklos Szeredi22590e42007-10-16 23:27:08 -0700253 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
254 /*
255 * MAY_EXEC on regular files is denied if the fs is mounted
256 * with the "noexec" flag.
257 */
Dave Hansenc7eb2662007-10-16 23:31:14 -0700258 if (mnt && (mnt->mnt_flags & MNT_NOEXEC))
Miklos Szeredi22590e42007-10-16 23:27:08 -0700259 return -EACCES;
260 }
Trond Myklebusta343bb72006-08-22 20:06:03 -0400261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 /* Ordinary permission routines do not understand MAY_APPEND. */
263 submask = mask & ~MAY_APPEND;
Miklos Szeredi22590e42007-10-16 23:27:08 -0700264 if (inode->i_op && inode->i_op->permission) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 retval = inode->i_op->permission(inode, submask, nd);
Miklos Szeredi22590e42007-10-16 23:27:08 -0700266 if (!retval) {
267 /*
268 * Exec permission on a regular file is denied if none
269 * of the execute bits are set.
270 *
271 * This check should be done by the ->permission()
272 * method.
273 */
274 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode) &&
275 !(inode->i_mode & S_IXUGO))
276 return -EACCES;
277 }
278 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 retval = generic_permission(inode, submask, NULL);
Miklos Szeredi22590e42007-10-16 23:27:08 -0700280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (retval)
282 return retval;
283
284 return security_inode_permission(inode, mask, nd);
285}
286
Christoph Hellwige4543ed2005-11-08 21:35:04 -0800287/**
288 * vfs_permission - check for access rights to a given path
289 * @nd: lookup result that describes the path
290 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
291 *
292 * Used to check for read/write/execute permissions on a path.
293 * We use "fsuid" for this, letting us set arbitrary permissions
294 * for filesystem access without changing the "normal" uids which
295 * are used for other things.
296 */
297int vfs_permission(struct nameidata *nd, int mask)
298{
Jan Blunck4ac91372008-02-14 19:34:32 -0800299 return permission(nd->path.dentry->d_inode, mask, nd);
Christoph Hellwige4543ed2005-11-08 21:35:04 -0800300}
301
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800302/**
303 * file_permission - check for additional access rights to a given file
304 * @file: file to check access rights for
305 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
306 *
307 * Used to check for read/write/execute permissions on an already opened
308 * file.
309 *
310 * Note:
311 * Do not use this function in new code. All access checks should
312 * be done using vfs_permission().
313 */
314int file_permission(struct file *file, int mask)
315{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800316 return permission(file->f_path.dentry->d_inode, mask, NULL);
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319/*
320 * get_write_access() gets write permission for a file.
321 * put_write_access() releases this write permission.
322 * This is used for regular files.
323 * We cannot support write (and maybe mmap read-write shared) accesses and
324 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
325 * can have the following values:
326 * 0: no writers, no VM_DENYWRITE mappings
327 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
328 * > 0: (i_writecount) users are writing to the file.
329 *
330 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
331 * except for the cases where we don't hold i_writecount yet. Then we need to
332 * use {get,deny}_write_access() - these functions check the sign and refuse
333 * to do the change if sign is wrong. Exclusion between them is provided by
334 * the inode->i_lock spinlock.
335 */
336
337int get_write_access(struct inode * inode)
338{
339 spin_lock(&inode->i_lock);
340 if (atomic_read(&inode->i_writecount) < 0) {
341 spin_unlock(&inode->i_lock);
342 return -ETXTBSY;
343 }
344 atomic_inc(&inode->i_writecount);
345 spin_unlock(&inode->i_lock);
346
347 return 0;
348}
349
350int deny_write_access(struct file * file)
351{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800352 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 spin_lock(&inode->i_lock);
355 if (atomic_read(&inode->i_writecount) > 0) {
356 spin_unlock(&inode->i_lock);
357 return -ETXTBSY;
358 }
359 atomic_dec(&inode->i_writecount);
360 spin_unlock(&inode->i_lock);
361
362 return 0;
363}
364
Jan Blunck1d957f92008-02-14 19:34:35 -0800365/**
Jan Blunck5dd784d2008-02-14 19:34:38 -0800366 * path_get - get a reference to a path
367 * @path: path to get the reference to
368 *
369 * Given a path increment the reference count to the dentry and the vfsmount.
370 */
371void path_get(struct path *path)
372{
373 mntget(path->mnt);
374 dget(path->dentry);
375}
376EXPORT_SYMBOL(path_get);
377
378/**
Jan Blunck1d957f92008-02-14 19:34:35 -0800379 * path_put - put a reference to a path
380 * @path: path to put the reference to
381 *
382 * Given a path decrement the reference count to the dentry and the vfsmount.
383 */
384void path_put(struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
Jan Blunck1d957f92008-02-14 19:34:35 -0800386 dput(path->dentry);
387 mntput(path->mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388}
Jan Blunck1d957f92008-02-14 19:34:35 -0800389EXPORT_SYMBOL(path_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Trond Myklebust834f2a42005-10-18 14:20:16 -0700391/**
392 * release_open_intent - free up open intent resources
393 * @nd: pointer to nameidata
394 */
395void release_open_intent(struct nameidata *nd)
396{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800397 if (nd->intent.open.file->f_path.dentry == NULL)
Trond Myklebust834f2a42005-10-18 14:20:16 -0700398 put_filp(nd->intent.open.file);
399 else
400 fput(nd->intent.open.file);
401}
402
Ian Kentbcdc5e02006-09-27 01:50:44 -0700403static inline struct dentry *
404do_revalidate(struct dentry *dentry, struct nameidata *nd)
405{
406 int status = dentry->d_op->d_revalidate(dentry, nd);
407 if (unlikely(status <= 0)) {
408 /*
409 * The dentry failed validation.
410 * If d_revalidate returned 0 attempt to invalidate
411 * the dentry otherwise d_revalidate is asking us
412 * to return a fail status.
413 */
414 if (!status) {
415 if (!d_invalidate(dentry)) {
416 dput(dentry);
417 dentry = NULL;
418 }
419 } else {
420 dput(dentry);
421 dentry = ERR_PTR(status);
422 }
423 }
424 return dentry;
425}
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427/*
428 * Internal lookup() using the new generic dcache.
429 * SMP-safe
430 */
431static struct dentry * cached_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
432{
433 struct dentry * dentry = __d_lookup(parent, name);
434
435 /* lockess __d_lookup may fail due to concurrent d_move()
436 * in some unrelated directory, so try with d_lookup
437 */
438 if (!dentry)
439 dentry = d_lookup(parent, name);
440
Ian Kentbcdc5e02006-09-27 01:50:44 -0700441 if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
442 dentry = do_revalidate(dentry, nd);
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return dentry;
445}
446
447/*
448 * Short-cut version of permission(), for calling by
449 * path_walk(), when dcache lock is held. Combines parts
450 * of permission() and generic_permission(), and tests ONLY for
451 * MAY_EXEC permission.
452 *
453 * If appropriate, check DAC only. If not appropriate, or
454 * short-cut DAC fails, then call permission() to do more
455 * complete permission check.
456 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800457static int exec_permission_lite(struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 struct nameidata *nd)
459{
460 umode_t mode = inode->i_mode;
461
462 if (inode->i_op && inode->i_op->permission)
463 return -EAGAIN;
464
465 if (current->fsuid == inode->i_uid)
466 mode >>= 6;
467 else if (in_group_p(inode->i_gid))
468 mode >>= 3;
469
470 if (mode & MAY_EXEC)
471 goto ok;
472
473 if ((inode->i_mode & S_IXUGO) && capable(CAP_DAC_OVERRIDE))
474 goto ok;
475
476 if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_OVERRIDE))
477 goto ok;
478
479 if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_READ_SEARCH))
480 goto ok;
481
482 return -EACCES;
483ok:
484 return security_inode_permission(inode, MAY_EXEC, nd);
485}
486
487/*
488 * This is called when everything else fails, and we actually have
489 * to go to the low-level filesystem to find out what we should do..
490 *
491 * We get the directory semaphore, and after getting that we also
492 * make sure that nobody added the entry to the dcache in the meantime..
493 * SMP-safe
494 */
495static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
496{
497 struct dentry * result;
498 struct inode *dir = parent->d_inode;
499
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800500 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 /*
502 * First re-do the cached lookup just in case it was created
503 * while we waited for the directory semaphore..
504 *
505 * FIXME! This could use version numbering or similar to
506 * avoid unnecessary cache lookups.
507 *
508 * The "dcache_lock" is purely to protect the RCU list walker
509 * from concurrent renames at this point (we mustn't get false
510 * negatives from the RCU list walk here, unlike the optimistic
511 * fast walk).
512 *
513 * so doing d_lookup() (with seqlock), instead of lockfree __d_lookup
514 */
515 result = d_lookup(parent, name);
516 if (!result) {
517 struct dentry * dentry = d_alloc(parent, name);
518 result = ERR_PTR(-ENOMEM);
519 if (dentry) {
520 result = dir->i_op->lookup(dir, dentry, nd);
521 if (result)
522 dput(dentry);
523 else
524 result = dentry;
525 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800526 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return result;
528 }
529
530 /*
531 * Uhhuh! Nasty case: the cache was re-populated while
532 * we waited on the semaphore. Need to revalidate.
533 */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800534 mutex_unlock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (result->d_op && result->d_op->d_revalidate) {
Ian Kentbcdc5e02006-09-27 01:50:44 -0700536 result = do_revalidate(result, nd);
537 if (!result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 result = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 }
540 return result;
541}
542
543static int __emul_lookup_dentry(const char *, struct nameidata *);
544
545/* SMP-safe */
Arjan van de Venf1662352006-01-14 13:21:31 -0800546static __always_inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547walk_init_root(const char *name, struct nameidata *nd)
548{
Andreas Mohre518ddb2006-09-29 02:01:22 -0700549 struct fs_struct *fs = current->fs;
550
551 read_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -0800552 if (fs->altroot.dentry && !(nd->flags & LOOKUP_NOALT)) {
553 nd->path = fs->altroot;
554 path_get(&fs->altroot);
Andreas Mohre518ddb2006-09-29 02:01:22 -0700555 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (__emul_lookup_dentry(name,nd))
557 return 0;
Andreas Mohre518ddb2006-09-29 02:01:22 -0700558 read_lock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
Jan Blunck6ac08c32008-02-14 19:34:38 -0800560 nd->path = fs->root;
561 path_get(&fs->root);
Andreas Mohre518ddb2006-09-29 02:01:22 -0700562 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 return 1;
564}
565
Al Viroa02f76c2008-02-23 15:14:28 +0000566/*
567 * Wrapper to retry pathname resolution whenever the underlying
568 * file system returns an ESTALE.
569 *
570 * Retry the whole path once, forcing real lookup requests
571 * instead of relying on the dcache.
572 */
573static __always_inline int link_path_walk(const char *name, struct nameidata *nd)
574{
575 struct path save = nd->path;
576 int result;
577
578 /* make sure the stuff we saved doesn't go away */
579 dget(save.dentry);
580 mntget(save.mnt);
581
582 result = __link_path_walk(name, nd);
583 if (result == -ESTALE) {
584 /* nd->path had been dropped */
585 nd->path = save;
586 dget(nd->path.dentry);
587 mntget(nd->path.mnt);
588 nd->flags |= LOOKUP_REVAL;
589 result = __link_path_walk(name, nd);
590 }
591
592 path_put(&save);
593
594 return result;
595}
596
Arjan van de Venf1662352006-01-14 13:21:31 -0800597static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
599 int res = 0;
600 char *name;
601 if (IS_ERR(link))
602 goto fail;
603
604 if (*link == '/') {
Jan Blunck1d957f92008-02-14 19:34:35 -0800605 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (!walk_init_root(link, nd))
607 /* weird __emul_prefix() stuff did it */
608 goto out;
609 }
610 res = link_path_walk(link, nd);
611out:
612 if (nd->depth || res || nd->last_type!=LAST_NORM)
613 return res;
614 /*
615 * If it is an iterative symlinks resolution in open_namei() we
616 * have to copy the last component. And all that crap because of
617 * bloody create() on broken symlinks. Furrfu...
618 */
619 name = __getname();
620 if (unlikely(!name)) {
Jan Blunck1d957f92008-02-14 19:34:35 -0800621 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 return -ENOMEM;
623 }
624 strcpy(name, nd->last.name);
625 nd->last.name = name;
626 return 0;
627fail:
Jan Blunck1d957f92008-02-14 19:34:35 -0800628 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 return PTR_ERR(link);
630}
631
Jan Blunck1d957f92008-02-14 19:34:35 -0800632static void path_put_conditional(struct path *path, struct nameidata *nd)
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700633{
634 dput(path->dentry);
Jan Blunck4ac91372008-02-14 19:34:32 -0800635 if (path->mnt != nd->path.mnt)
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700636 mntput(path->mnt);
637}
638
639static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
640{
Jan Blunck4ac91372008-02-14 19:34:32 -0800641 dput(nd->path.dentry);
642 if (nd->path.mnt != path->mnt)
643 mntput(nd->path.mnt);
644 nd->path.mnt = path->mnt;
645 nd->path.dentry = path->dentry;
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700646}
647
Ian Kent051d3812006-03-27 01:14:53 -0800648static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
649{
650 int error;
651 void *cookie;
652 struct dentry *dentry = path->dentry;
653
654 touch_atime(path->mnt, dentry);
655 nd_set_link(nd, NULL);
656
Jan Blunck4ac91372008-02-14 19:34:32 -0800657 if (path->mnt != nd->path.mnt) {
Ian Kent051d3812006-03-27 01:14:53 -0800658 path_to_nameidata(path, nd);
659 dget(dentry);
660 }
661 mntget(path->mnt);
662 cookie = dentry->d_inode->i_op->follow_link(dentry, nd);
663 error = PTR_ERR(cookie);
664 if (!IS_ERR(cookie)) {
665 char *s = nd_get_link(nd);
666 error = 0;
667 if (s)
668 error = __vfs_follow_link(nd, s);
669 if (dentry->d_inode->i_op->put_link)
670 dentry->d_inode->i_op->put_link(dentry, nd, cookie);
671 }
Jan Blunck09da59162008-02-14 19:34:37 -0800672 path_put(path);
Ian Kent051d3812006-03-27 01:14:53 -0800673
674 return error;
675}
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677/*
678 * This limits recursive symlink follows to 8, while
679 * limiting consecutive symlinks to 40.
680 *
681 * Without that kind of total limit, nasty chains of consecutive
682 * symlinks can cause almost arbitrarily long lookups.
683 */
Al Viro90ebe562005-06-06 13:35:58 -0700684static inline int do_follow_link(struct path *path, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
686 int err = -ELOOP;
687 if (current->link_count >= MAX_NESTED_LINKS)
688 goto loop;
689 if (current->total_link_count >= 40)
690 goto loop;
691 BUG_ON(nd->depth >= MAX_NESTED_LINKS);
692 cond_resched();
Al Viro90ebe562005-06-06 13:35:58 -0700693 err = security_inode_follow_link(path->dentry, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (err)
695 goto loop;
696 current->link_count++;
697 current->total_link_count++;
698 nd->depth++;
Al Virocd4e91d2005-06-06 13:36:03 -0700699 err = __do_follow_link(path, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 current->link_count--;
701 nd->depth--;
702 return err;
703loop:
Jan Blunck1d957f92008-02-14 19:34:35 -0800704 path_put_conditional(path, nd);
705 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return err;
707}
708
709int follow_up(struct vfsmount **mnt, struct dentry **dentry)
710{
711 struct vfsmount *parent;
712 struct dentry *mountpoint;
713 spin_lock(&vfsmount_lock);
714 parent=(*mnt)->mnt_parent;
715 if (parent == *mnt) {
716 spin_unlock(&vfsmount_lock);
717 return 0;
718 }
719 mntget(parent);
720 mountpoint=dget((*mnt)->mnt_mountpoint);
721 spin_unlock(&vfsmount_lock);
722 dput(*dentry);
723 *dentry = mountpoint;
724 mntput(*mnt);
725 *mnt = parent;
726 return 1;
727}
728
729/* no need for dcache_lock, as serialization is taken care in
730 * namespace.c
731 */
Al Viro463ffb22005-06-06 13:36:05 -0700732static int __follow_mount(struct path *path)
733{
734 int res = 0;
735 while (d_mountpoint(path->dentry)) {
736 struct vfsmount *mounted = lookup_mnt(path->mnt, path->dentry);
737 if (!mounted)
738 break;
739 dput(path->dentry);
740 if (res)
741 mntput(path->mnt);
742 path->mnt = mounted;
743 path->dentry = dget(mounted->mnt_root);
744 res = 1;
745 }
746 return res;
747}
748
Al Viro58c465e2005-06-06 13:36:13 -0700749static void follow_mount(struct vfsmount **mnt, struct dentry **dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 while (d_mountpoint(*dentry)) {
752 struct vfsmount *mounted = lookup_mnt(*mnt, *dentry);
753 if (!mounted)
754 break;
Al Viro58c465e2005-06-06 13:36:13 -0700755 dput(*dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 mntput(*mnt);
757 *mnt = mounted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 *dentry = dget(mounted->mnt_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760}
761
762/* no need for dcache_lock, as serialization is taken care in
763 * namespace.c
764 */
Al Viroe13b2102005-06-06 13:36:06 -0700765int follow_down(struct vfsmount **mnt, struct dentry **dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
767 struct vfsmount *mounted;
768
769 mounted = lookup_mnt(*mnt, *dentry);
770 if (mounted) {
Al Viroe13b2102005-06-06 13:36:06 -0700771 dput(*dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 mntput(*mnt);
773 *mnt = mounted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 *dentry = dget(mounted->mnt_root);
775 return 1;
776 }
777 return 0;
778}
779
Arjan van de Venf1662352006-01-14 13:21:31 -0800780static __always_inline void follow_dotdot(struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
Andreas Mohre518ddb2006-09-29 02:01:22 -0700782 struct fs_struct *fs = current->fs;
783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 while(1) {
785 struct vfsmount *parent;
Jan Blunck4ac91372008-02-14 19:34:32 -0800786 struct dentry *old = nd->path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Andreas Mohre518ddb2006-09-29 02:01:22 -0700788 read_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -0800789 if (nd->path.dentry == fs->root.dentry &&
790 nd->path.mnt == fs->root.mnt) {
Andreas Mohre518ddb2006-09-29 02:01:22 -0700791 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 break;
793 }
Andreas Mohre518ddb2006-09-29 02:01:22 -0700794 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 spin_lock(&dcache_lock);
Jan Blunck4ac91372008-02-14 19:34:32 -0800796 if (nd->path.dentry != nd->path.mnt->mnt_root) {
797 nd->path.dentry = dget(nd->path.dentry->d_parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 spin_unlock(&dcache_lock);
799 dput(old);
800 break;
801 }
802 spin_unlock(&dcache_lock);
803 spin_lock(&vfsmount_lock);
Jan Blunck4ac91372008-02-14 19:34:32 -0800804 parent = nd->path.mnt->mnt_parent;
805 if (parent == nd->path.mnt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 spin_unlock(&vfsmount_lock);
807 break;
808 }
809 mntget(parent);
Jan Blunck4ac91372008-02-14 19:34:32 -0800810 nd->path.dentry = dget(nd->path.mnt->mnt_mountpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 spin_unlock(&vfsmount_lock);
812 dput(old);
Jan Blunck4ac91372008-02-14 19:34:32 -0800813 mntput(nd->path.mnt);
814 nd->path.mnt = parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
Jan Blunck4ac91372008-02-14 19:34:32 -0800816 follow_mount(&nd->path.mnt, &nd->path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817}
818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819/*
820 * It's more convoluted than I'd like it to be, but... it's still fairly
821 * small and for now I'd prefer to have fast path as straight as possible.
822 * It _is_ time-critical.
823 */
824static int do_lookup(struct nameidata *nd, struct qstr *name,
825 struct path *path)
826{
Jan Blunck4ac91372008-02-14 19:34:32 -0800827 struct vfsmount *mnt = nd->path.mnt;
828 struct dentry *dentry = __d_lookup(nd->path.dentry, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 if (!dentry)
831 goto need_lookup;
832 if (dentry->d_op && dentry->d_op->d_revalidate)
833 goto need_revalidate;
834done:
835 path->mnt = mnt;
836 path->dentry = dentry;
Al Viro634ee702005-06-06 13:36:13 -0700837 __follow_mount(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 return 0;
839
840need_lookup:
Jan Blunck4ac91372008-02-14 19:34:32 -0800841 dentry = real_lookup(nd->path.dentry, name, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if (IS_ERR(dentry))
843 goto fail;
844 goto done;
845
846need_revalidate:
Ian Kentbcdc5e02006-09-27 01:50:44 -0700847 dentry = do_revalidate(dentry, nd);
848 if (!dentry)
849 goto need_lookup;
850 if (IS_ERR(dentry))
851 goto fail;
852 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854fail:
855 return PTR_ERR(dentry);
856}
857
858/*
859 * Name resolution.
Prasanna Medaea3834d2005-04-29 16:00:17 +0100860 * This is the basic name resolution function, turning a pathname into
861 * the final dentry. We expect 'base' to be positive and a directory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 *
Prasanna Medaea3834d2005-04-29 16:00:17 +0100863 * Returns 0 and nd will have valid dentry and mnt on success.
864 * Returns error and drops reference to input namei data on failure.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 */
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -0800866static int __link_path_walk(const char *name, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
868 struct path next;
869 struct inode *inode;
870 int err;
871 unsigned int lookup_flags = nd->flags;
872
873 while (*name=='/')
874 name++;
875 if (!*name)
876 goto return_reval;
877
Jan Blunck4ac91372008-02-14 19:34:32 -0800878 inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (nd->depth)
Trond Myklebustf55eab82006-02-04 23:28:01 -0800880 lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 /* At this point we know we have a real path component. */
883 for(;;) {
884 unsigned long hash;
885 struct qstr this;
886 unsigned int c;
887
Trond Myklebustcdce5d62005-10-18 14:20:18 -0700888 nd->flags |= LOOKUP_CONTINUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 err = exec_permission_lite(inode, nd);
Christoph Hellwige4543ed2005-11-08 21:35:04 -0800890 if (err == -EAGAIN)
891 err = vfs_permission(nd, MAY_EXEC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if (err)
893 break;
894
895 this.name = name;
896 c = *(const unsigned char *)name;
897
898 hash = init_name_hash();
899 do {
900 name++;
901 hash = partial_name_hash(c, hash);
902 c = *(const unsigned char *)name;
903 } while (c && (c != '/'));
904 this.len = name - (const char *) this.name;
905 this.hash = end_name_hash(hash);
906
907 /* remove trailing slashes? */
908 if (!c)
909 goto last_component;
910 while (*++name == '/');
911 if (!*name)
912 goto last_with_slashes;
913
914 /*
915 * "." and ".." are special - ".." especially so because it has
916 * to be able to know about the current root directory and
917 * parent relationships.
918 */
919 if (this.name[0] == '.') switch (this.len) {
920 default:
921 break;
922 case 2:
923 if (this.name[1] != '.')
924 break;
Al Viro58c465e2005-06-06 13:36:13 -0700925 follow_dotdot(nd);
Jan Blunck4ac91372008-02-14 19:34:32 -0800926 inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 /* fallthrough */
928 case 1:
929 continue;
930 }
931 /*
932 * See if the low-level filesystem might want
933 * to use its own hash..
934 */
Jan Blunck4ac91372008-02-14 19:34:32 -0800935 if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
936 err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
937 &this);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (err < 0)
939 break;
940 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 /* This does the actual lookups.. */
942 err = do_lookup(nd, &this, &next);
943 if (err)
944 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 err = -ENOENT;
947 inode = next.dentry->d_inode;
948 if (!inode)
949 goto out_dput;
950 err = -ENOTDIR;
951 if (!inode->i_op)
952 goto out_dput;
953
954 if (inode->i_op->follow_link) {
Al Viro90ebe562005-06-06 13:35:58 -0700955 err = do_follow_link(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 if (err)
957 goto return_err;
958 err = -ENOENT;
Jan Blunck4ac91372008-02-14 19:34:32 -0800959 inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 if (!inode)
961 break;
962 err = -ENOTDIR;
963 if (!inode->i_op)
964 break;
Miklos Szeredi09dd17d2005-09-06 15:18:21 -0700965 } else
966 path_to_nameidata(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 err = -ENOTDIR;
968 if (!inode->i_op->lookup)
969 break;
970 continue;
971 /* here ends the main loop */
972
973last_with_slashes:
974 lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
975last_component:
Trond Myklebustf55eab82006-02-04 23:28:01 -0800976 /* Clear LOOKUP_CONTINUE iff it was previously unset */
977 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (lookup_flags & LOOKUP_PARENT)
979 goto lookup_parent;
980 if (this.name[0] == '.') switch (this.len) {
981 default:
982 break;
983 case 2:
984 if (this.name[1] != '.')
985 break;
Al Viro58c465e2005-06-06 13:36:13 -0700986 follow_dotdot(nd);
Jan Blunck4ac91372008-02-14 19:34:32 -0800987 inode = nd->path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 /* fallthrough */
989 case 1:
990 goto return_reval;
991 }
Jan Blunck4ac91372008-02-14 19:34:32 -0800992 if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
993 err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
994 &this);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 if (err < 0)
996 break;
997 }
998 err = do_lookup(nd, &this, &next);
999 if (err)
1000 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 inode = next.dentry->d_inode;
1002 if ((lookup_flags & LOOKUP_FOLLOW)
1003 && inode && inode->i_op && inode->i_op->follow_link) {
Al Viro90ebe562005-06-06 13:35:58 -07001004 err = do_follow_link(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 if (err)
1006 goto return_err;
Jan Blunck4ac91372008-02-14 19:34:32 -08001007 inode = nd->path.dentry->d_inode;
Miklos Szeredi09dd17d2005-09-06 15:18:21 -07001008 } else
1009 path_to_nameidata(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 err = -ENOENT;
1011 if (!inode)
1012 break;
1013 if (lookup_flags & LOOKUP_DIRECTORY) {
1014 err = -ENOTDIR;
1015 if (!inode->i_op || !inode->i_op->lookup)
1016 break;
1017 }
1018 goto return_base;
1019lookup_parent:
1020 nd->last = this;
1021 nd->last_type = LAST_NORM;
1022 if (this.name[0] != '.')
1023 goto return_base;
1024 if (this.len == 1)
1025 nd->last_type = LAST_DOT;
1026 else if (this.len == 2 && this.name[1] == '.')
1027 nd->last_type = LAST_DOTDOT;
1028 else
1029 goto return_base;
1030return_reval:
1031 /*
1032 * We bypassed the ordinary revalidation routines.
1033 * We may need to check the cached dentry for staleness.
1034 */
Jan Blunck4ac91372008-02-14 19:34:32 -08001035 if (nd->path.dentry && nd->path.dentry->d_sb &&
1036 (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 err = -ESTALE;
1038 /* Note: we do not d_invalidate() */
Jan Blunck4ac91372008-02-14 19:34:32 -08001039 if (!nd->path.dentry->d_op->d_revalidate(
1040 nd->path.dentry, nd))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 break;
1042 }
1043return_base:
1044 return 0;
1045out_dput:
Jan Blunck1d957f92008-02-14 19:34:35 -08001046 path_put_conditional(&next, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 break;
1048 }
Jan Blunck1d957f92008-02-14 19:34:35 -08001049 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050return_err:
1051 return err;
1052}
1053
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001054static int path_walk(const char *name, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
1056 current->total_link_count = 0;
1057 return link_path_walk(name, nd);
1058}
1059
Prasanna Medaea3834d2005-04-29 16:00:17 +01001060/*
1061 * SMP-safe: Returns 1 and nd will have valid dentry and mnt, if
1062 * everything is done. Returns 0 and drops input nd, if lookup failed;
1063 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064static int __emul_lookup_dentry(const char *name, struct nameidata *nd)
1065{
1066 if (path_walk(name, nd))
1067 return 0; /* something went wrong... */
1068
Jan Blunck4ac91372008-02-14 19:34:32 -08001069 if (!nd->path.dentry->d_inode ||
1070 S_ISDIR(nd->path.dentry->d_inode->i_mode)) {
Jan Blunck09da59162008-02-14 19:34:37 -08001071 struct path old_path = nd->path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 struct qstr last = nd->last;
1073 int last_type = nd->last_type;
Andreas Mohre518ddb2006-09-29 02:01:22 -07001074 struct fs_struct *fs = current->fs;
1075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 /*
Andreas Mohre518ddb2006-09-29 02:01:22 -07001077 * NAME was not found in alternate root or it's a directory.
1078 * Try to find it in the normal root:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 */
1080 nd->last_type = LAST_ROOT;
Andreas Mohre518ddb2006-09-29 02:01:22 -07001081 read_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001082 nd->path = fs->root;
1083 path_get(&fs->root);
Andreas Mohre518ddb2006-09-29 02:01:22 -07001084 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 if (path_walk(name, nd) == 0) {
Jan Blunck4ac91372008-02-14 19:34:32 -08001086 if (nd->path.dentry->d_inode) {
Jan Blunck09da59162008-02-14 19:34:37 -08001087 path_put(&old_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 return 1;
1089 }
Jan Blunck1d957f92008-02-14 19:34:35 -08001090 path_put(&nd->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
Jan Blunck09da59162008-02-14 19:34:37 -08001092 nd->path = old_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 nd->last = last;
1094 nd->last_type = last_type;
1095 }
1096 return 1;
1097}
1098
1099void set_fs_altroot(void)
1100{
1101 char *emul = __emul_prefix();
1102 struct nameidata nd;
Jan Blunck6ac08c32008-02-14 19:34:38 -08001103 struct path path = {}, old_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 int err;
Andreas Mohre518ddb2006-09-29 02:01:22 -07001105 struct fs_struct *fs = current->fs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107 if (!emul)
1108 goto set_it;
1109 err = path_lookup(emul, LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_NOALT, &nd);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001110 if (!err)
1111 path = nd.path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112set_it:
Andreas Mohre518ddb2006-09-29 02:01:22 -07001113 write_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001114 old_path = fs->altroot;
1115 fs->altroot = path;
Andreas Mohre518ddb2006-09-29 02:01:22 -07001116 write_unlock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001117 if (old_path.dentry)
1118 path_put(&old_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119}
1120
Prasanna Medaea3834d2005-04-29 16:00:17 +01001121/* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001122static int do_path_lookup(int dfd, const char *name,
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001123 unsigned int flags, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124{
Prasanna Medaea3834d2005-04-29 16:00:17 +01001125 int retval = 0;
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001126 int fput_needed;
1127 struct file *file;
Andreas Mohre518ddb2006-09-29 02:01:22 -07001128 struct fs_struct *fs = current->fs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 nd->last_type = LAST_ROOT; /* if there are only slashes... */
1131 nd->flags = flags;
1132 nd->depth = 0;
1133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 if (*name=='/') {
Andreas Mohre518ddb2006-09-29 02:01:22 -07001135 read_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001136 if (fs->altroot.dentry && !(nd->flags & LOOKUP_NOALT)) {
1137 nd->path = fs->altroot;
1138 path_get(&fs->altroot);
Andreas Mohre518ddb2006-09-29 02:01:22 -07001139 read_unlock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (__emul_lookup_dentry(name,nd))
Prasanna Medaea3834d2005-04-29 16:00:17 +01001141 goto out; /* found in altroot */
Andreas Mohre518ddb2006-09-29 02:01:22 -07001142 read_lock(&fs->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 }
Jan Blunck6ac08c32008-02-14 19:34:38 -08001144 nd->path = fs->root;
1145 path_get(&fs->root);
Andreas Mohre518ddb2006-09-29 02:01:22 -07001146 read_unlock(&fs->lock);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001147 } else if (dfd == AT_FDCWD) {
Andreas Mohre518ddb2006-09-29 02:01:22 -07001148 read_lock(&fs->lock);
Jan Blunck6ac08c32008-02-14 19:34:38 -08001149 nd->path = fs->pwd;
1150 path_get(&fs->pwd);
Andreas Mohre518ddb2006-09-29 02:01:22 -07001151 read_unlock(&fs->lock);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001152 } else {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001153 struct dentry *dentry;
1154
1155 file = fget_light(dfd, &fput_needed);
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001156 retval = -EBADF;
1157 if (!file)
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001158 goto out_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001159
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -08001160 dentry = file->f_path.dentry;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001161
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001162 retval = -ENOTDIR;
1163 if (!S_ISDIR(dentry->d_inode->i_mode))
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001164 goto fput_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001165
1166 retval = file_permission(file, MAY_EXEC);
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001167 if (retval)
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001168 goto fput_fail;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001169
Jan Blunck5dd784d2008-02-14 19:34:38 -08001170 nd->path = file->f_path;
1171 path_get(&file->f_path);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001172
1173 fput_light(file, fput_needed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 }
Josef 'Jeff' Sipek2dfdd262007-05-09 02:33:41 -07001175
1176 retval = path_walk(name, nd);
Prasanna Medaea3834d2005-04-29 16:00:17 +01001177out:
Jan Blunck4ac91372008-02-14 19:34:32 -08001178 if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1179 nd->path.dentry->d_inode))
1180 audit_inode(name, nd->path.dentry);
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001181out_fail:
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001182 return retval;
1183
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001184fput_fail:
Ulrich Drepper170aa3d2006-02-04 23:28:02 -08001185 fput_light(file, fput_needed);
Trond Myklebust6d09bb62006-06-04 02:51:37 -07001186 goto out_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187}
1188
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001189int path_lookup(const char *name, unsigned int flags,
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001190 struct nameidata *nd)
1191{
1192 return do_path_lookup(AT_FDCWD, name, flags, nd);
1193}
1194
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001195/**
1196 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1197 * @dentry: pointer to dentry of the base directory
1198 * @mnt: pointer to vfs mount of the base directory
1199 * @name: pointer to file name
1200 * @flags: lookup flags
1201 * @nd: pointer to nameidata
1202 */
1203int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1204 const char *name, unsigned int flags,
1205 struct nameidata *nd)
1206{
1207 int retval;
1208
1209 /* same as do_path_lookup */
1210 nd->last_type = LAST_ROOT;
1211 nd->flags = flags;
1212 nd->depth = 0;
1213
Jan Blunck4ac91372008-02-14 19:34:32 -08001214 nd->path.mnt = mntget(mnt);
1215 nd->path.dentry = dget(dentry);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001216
1217 retval = path_walk(name, nd);
Jan Blunck4ac91372008-02-14 19:34:32 -08001218 if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1219 nd->path.dentry->d_inode))
1220 audit_inode(name, nd->path.dentry);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07001221
1222 return retval;
1223
1224}
1225
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001226static int __path_lookup_intent_open(int dfd, const char *name,
1227 unsigned int lookup_flags, struct nameidata *nd,
1228 int open_flags, int create_mode)
Trond Myklebust834f2a42005-10-18 14:20:16 -07001229{
1230 struct file *filp = get_empty_filp();
1231 int err;
1232
1233 if (filp == NULL)
1234 return -ENFILE;
1235 nd->intent.open.file = filp;
1236 nd->intent.open.flags = open_flags;
1237 nd->intent.open.create_mode = create_mode;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001238 err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
Trond Myklebust834f2a42005-10-18 14:20:16 -07001239 if (IS_ERR(nd->intent.open.file)) {
1240 if (err == 0) {
1241 err = PTR_ERR(nd->intent.open.file);
Jan Blunck1d957f92008-02-14 19:34:35 -08001242 path_put(&nd->path);
Trond Myklebust834f2a42005-10-18 14:20:16 -07001243 }
1244 } else if (err != 0)
1245 release_open_intent(nd);
1246 return err;
1247}
1248
1249/**
1250 * path_lookup_open - lookup a file path with open intent
Martin Waitz7045f372006-02-01 03:06:57 -08001251 * @dfd: the directory to use as base, or AT_FDCWD
Trond Myklebust834f2a42005-10-18 14:20:16 -07001252 * @name: pointer to file name
1253 * @lookup_flags: lookup intent flags
1254 * @nd: pointer to nameidata
1255 * @open_flags: open intent flags
1256 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001257int path_lookup_open(int dfd, const char *name, unsigned int lookup_flags,
Trond Myklebust834f2a42005-10-18 14:20:16 -07001258 struct nameidata *nd, int open_flags)
1259{
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001260 return __path_lookup_intent_open(dfd, name, lookup_flags, nd,
Trond Myklebust834f2a42005-10-18 14:20:16 -07001261 open_flags, 0);
1262}
1263
1264/**
1265 * path_lookup_create - lookup a file path with open + create intent
Martin Waitz7045f372006-02-01 03:06:57 -08001266 * @dfd: the directory to use as base, or AT_FDCWD
Trond Myklebust834f2a42005-10-18 14:20:16 -07001267 * @name: pointer to file name
1268 * @lookup_flags: lookup intent flags
1269 * @nd: pointer to nameidata
1270 * @open_flags: open intent flags
1271 * @create_mode: create intent flags
1272 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001273static int path_lookup_create(int dfd, const char *name,
1274 unsigned int lookup_flags, struct nameidata *nd,
1275 int open_flags, int create_mode)
Trond Myklebust834f2a42005-10-18 14:20:16 -07001276{
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001277 return __path_lookup_intent_open(dfd, name, lookup_flags|LOOKUP_CREATE,
1278 nd, open_flags, create_mode);
Trond Myklebust834f2a42005-10-18 14:20:16 -07001279}
1280
1281int __user_path_lookup_open(const char __user *name, unsigned int lookup_flags,
1282 struct nameidata *nd, int open_flags)
1283{
1284 char *tmp = getname(name);
1285 int err = PTR_ERR(tmp);
1286
1287 if (!IS_ERR(tmp)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001288 err = __path_lookup_intent_open(AT_FDCWD, tmp, lookup_flags, nd, open_flags, 0);
Trond Myklebust834f2a42005-10-18 14:20:16 -07001289 putname(tmp);
1290 }
1291 return err;
1292}
1293
Christoph Hellwigeead1912007-10-16 23:25:38 -07001294static struct dentry *__lookup_hash(struct qstr *name,
1295 struct dentry *base, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
James Morris057f6c02007-04-26 00:12:05 -07001297 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 struct inode *inode;
1299 int err;
1300
1301 inode = base->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 /*
1304 * See if the low-level filesystem might want
1305 * to use its own hash..
1306 */
1307 if (base->d_op && base->d_op->d_hash) {
1308 err = base->d_op->d_hash(base, name);
1309 dentry = ERR_PTR(err);
1310 if (err < 0)
1311 goto out;
1312 }
1313
1314 dentry = cached_lookup(base, name, nd);
1315 if (!dentry) {
1316 struct dentry *new = d_alloc(base, name);
1317 dentry = ERR_PTR(-ENOMEM);
1318 if (!new)
1319 goto out;
1320 dentry = inode->i_op->lookup(inode, new, nd);
1321 if (!dentry)
1322 dentry = new;
1323 else
1324 dput(new);
1325 }
1326out:
1327 return dentry;
1328}
1329
James Morris057f6c02007-04-26 00:12:05 -07001330/*
1331 * Restricted form of lookup. Doesn't follow links, single-component only,
1332 * needs parent already locked. Doesn't follow mounts.
1333 * SMP-safe.
1334 */
Adrian Bunka244e162006-03-31 02:32:11 -08001335static struct dentry *lookup_hash(struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
Christoph Hellwigeead1912007-10-16 23:25:38 -07001337 int err;
1338
Jan Blunck4ac91372008-02-14 19:34:32 -08001339 err = permission(nd->path.dentry->d_inode, MAY_EXEC, nd);
Christoph Hellwigeead1912007-10-16 23:25:38 -07001340 if (err)
1341 return ERR_PTR(err);
Jan Blunck4ac91372008-02-14 19:34:32 -08001342 return __lookup_hash(&nd->last, nd->path.dentry, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343}
1344
Christoph Hellwigeead1912007-10-16 23:25:38 -07001345static int __lookup_one_len(const char *name, struct qstr *this,
1346 struct dentry *base, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347{
1348 unsigned long hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 unsigned int c;
1350
James Morris057f6c02007-04-26 00:12:05 -07001351 this->name = name;
1352 this->len = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 if (!len)
James Morris057f6c02007-04-26 00:12:05 -07001354 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
1356 hash = init_name_hash();
1357 while (len--) {
1358 c = *(const unsigned char *)name++;
1359 if (c == '/' || c == '\0')
James Morris057f6c02007-04-26 00:12:05 -07001360 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 hash = partial_name_hash(c, hash);
1362 }
James Morris057f6c02007-04-26 00:12:05 -07001363 this->hash = end_name_hash(hash);
1364 return 0;
1365}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
Christoph Hellwigeead1912007-10-16 23:25:38 -07001367/**
Randy Dunlapa6b91912008-03-19 17:01:00 -07001368 * lookup_one_len - filesystem helper to lookup single pathname component
Christoph Hellwigeead1912007-10-16 23:25:38 -07001369 * @name: pathname component to lookup
1370 * @base: base directory to lookup from
1371 * @len: maximum length @len should be interpreted to
1372 *
Randy Dunlapa6b91912008-03-19 17:01:00 -07001373 * Note that this routine is purely a helper for filesystem usage and should
1374 * not be called by generic code. Also note that by using this function the
Christoph Hellwigeead1912007-10-16 23:25:38 -07001375 * nameidata argument is passed to the filesystem methods and a filesystem
1376 * using this helper needs to be prepared for that.
1377 */
James Morris057f6c02007-04-26 00:12:05 -07001378struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1379{
1380 int err;
1381 struct qstr this;
1382
1383 err = __lookup_one_len(name, &this, base, len);
1384 if (err)
1385 return ERR_PTR(err);
Christoph Hellwigeead1912007-10-16 23:25:38 -07001386
1387 err = permission(base->d_inode, MAY_EXEC, NULL);
1388 if (err)
1389 return ERR_PTR(err);
Christoph Hellwig49705b72005-11-08 21:35:06 -08001390 return __lookup_hash(&this, base, NULL);
James Morris057f6c02007-04-26 00:12:05 -07001391}
1392
Christoph Hellwigeead1912007-10-16 23:25:38 -07001393/**
1394 * lookup_one_noperm - bad hack for sysfs
1395 * @name: pathname component to lookup
1396 * @base: base directory to lookup from
1397 *
1398 * This is a variant of lookup_one_len that doesn't perform any permission
1399 * checks. It's a horrible hack to work around the braindead sysfs
1400 * architecture and should not be used anywhere else.
1401 *
1402 * DON'T USE THIS FUNCTION EVER, thanks.
1403 */
1404struct dentry *lookup_one_noperm(const char *name, struct dentry *base)
James Morris057f6c02007-04-26 00:12:05 -07001405{
1406 int err;
1407 struct qstr this;
1408
Christoph Hellwigeead1912007-10-16 23:25:38 -07001409 err = __lookup_one_len(name, &this, base, strlen(name));
James Morris057f6c02007-04-26 00:12:05 -07001410 if (err)
1411 return ERR_PTR(err);
Christoph Hellwigeead1912007-10-16 23:25:38 -07001412 return __lookup_hash(&this, base, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413}
1414
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001415int __user_walk_fd(int dfd, const char __user *name, unsigned flags,
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001416 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
1418 char *tmp = getname(name);
1419 int err = PTR_ERR(tmp);
1420
1421 if (!IS_ERR(tmp)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001422 err = do_path_lookup(dfd, tmp, flags, nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 putname(tmp);
1424 }
1425 return err;
1426}
1427
Harvey Harrisonfc9b52c2008-02-08 04:19:52 -08001428int __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001429{
1430 return __user_walk_fd(AT_FDCWD, name, flags, nd);
1431}
1432
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433/*
1434 * It's inline, so penalty for filesystems that don't use sticky bit is
1435 * minimal.
1436 */
1437static inline int check_sticky(struct inode *dir, struct inode *inode)
1438{
1439 if (!(dir->i_mode & S_ISVTX))
1440 return 0;
1441 if (inode->i_uid == current->fsuid)
1442 return 0;
1443 if (dir->i_uid == current->fsuid)
1444 return 0;
1445 return !capable(CAP_FOWNER);
1446}
1447
1448/*
1449 * Check whether we can remove a link victim from directory dir, check
1450 * whether the type of victim is right.
1451 * 1. We can't do it if dir is read-only (done in permission())
1452 * 2. We should have write and exec permissions on dir
1453 * 3. We can't remove anything from append-only dir
1454 * 4. We can't do anything with immutable dir (done in permission())
1455 * 5. If the sticky bit on dir is set we should either
1456 * a. be owner of dir, or
1457 * b. be owner of victim, or
1458 * c. have CAP_FOWNER capability
1459 * 6. If the victim is append-only or immutable we can't do antyhing with
1460 * links pointing to it.
1461 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1462 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1463 * 9. We can't remove a root or mountpoint.
1464 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1465 * nfs_async_unlink().
1466 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08001467static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468{
1469 int error;
1470
1471 if (!victim->d_inode)
1472 return -ENOENT;
1473
1474 BUG_ON(victim->d_parent->d_inode != dir);
Al Viro5a190ae2007-06-07 12:19:32 -04001475 audit_inode_child(victim->d_name.name, victim, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
1477 error = permission(dir,MAY_WRITE | MAY_EXEC, NULL);
1478 if (error)
1479 return error;
1480 if (IS_APPEND(dir))
1481 return -EPERM;
1482 if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1483 IS_IMMUTABLE(victim->d_inode))
1484 return -EPERM;
1485 if (isdir) {
1486 if (!S_ISDIR(victim->d_inode->i_mode))
1487 return -ENOTDIR;
1488 if (IS_ROOT(victim))
1489 return -EBUSY;
1490 } else if (S_ISDIR(victim->d_inode->i_mode))
1491 return -EISDIR;
1492 if (IS_DEADDIR(dir))
1493 return -ENOENT;
1494 if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1495 return -EBUSY;
1496 return 0;
1497}
1498
1499/* Check whether we can create an object with dentry child in directory
1500 * dir.
1501 * 1. We can't do it if child already exists (open has special treatment for
1502 * this case, but since we are inlined it's OK)
1503 * 2. We can't do it if dir is read-only (done in permission())
1504 * 3. We should have write and exec permissions on dir
1505 * 4. We can't do it if dir is immutable (done in permission())
1506 */
1507static inline int may_create(struct inode *dir, struct dentry *child,
1508 struct nameidata *nd)
1509{
1510 if (child->d_inode)
1511 return -EEXIST;
1512 if (IS_DEADDIR(dir))
1513 return -ENOENT;
1514 return permission(dir,MAY_WRITE | MAY_EXEC, nd);
1515}
1516
1517/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 * O_DIRECTORY translates into forcing a directory lookup.
1519 */
1520static inline int lookup_flags(unsigned int f)
1521{
1522 unsigned long retval = LOOKUP_FOLLOW;
1523
1524 if (f & O_NOFOLLOW)
1525 retval &= ~LOOKUP_FOLLOW;
1526
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 if (f & O_DIRECTORY)
1528 retval |= LOOKUP_DIRECTORY;
1529
1530 return retval;
1531}
1532
1533/*
1534 * p1 and p2 should be directories on the same fs.
1535 */
1536struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1537{
1538 struct dentry *p;
1539
1540 if (p1 == p2) {
Ingo Molnarf2eace22006-07-03 00:25:05 -07001541 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 return NULL;
1543 }
1544
Arjan van de Vena11f3a02006-03-23 03:00:33 -08001545 mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
1547 for (p = p1; p->d_parent != p; p = p->d_parent) {
1548 if (p->d_parent == p2) {
Ingo Molnarf2eace22006-07-03 00:25:05 -07001549 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1550 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 return p;
1552 }
1553 }
1554
1555 for (p = p2; p->d_parent != p; p = p->d_parent) {
1556 if (p->d_parent == p1) {
Ingo Molnarf2eace22006-07-03 00:25:05 -07001557 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1558 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 return p;
1560 }
1561 }
1562
Ingo Molnarf2eace22006-07-03 00:25:05 -07001563 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1564 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 return NULL;
1566}
1567
1568void unlock_rename(struct dentry *p1, struct dentry *p2)
1569{
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001570 mutex_unlock(&p1->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 if (p1 != p2) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001572 mutex_unlock(&p2->d_inode->i_mutex);
Arjan van de Vena11f3a02006-03-23 03:00:33 -08001573 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 }
1575}
1576
1577int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1578 struct nameidata *nd)
1579{
1580 int error = may_create(dir, dentry, nd);
1581
1582 if (error)
1583 return error;
1584
1585 if (!dir->i_op || !dir->i_op->create)
1586 return -EACCES; /* shouldn't it be ENOSYS? */
1587 mode &= S_IALLUGO;
1588 mode |= S_IFREG;
1589 error = security_inode_create(dir, dentry, mode);
1590 if (error)
1591 return error;
1592 DQUOT_INIT(dir);
1593 error = dir->i_op->create(dir, dentry, mode, nd);
Stephen Smalleya74574a2005-09-09 13:01:44 -07001594 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00001595 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 return error;
1597}
1598
1599int may_open(struct nameidata *nd, int acc_mode, int flag)
1600{
Jan Blunck4ac91372008-02-14 19:34:32 -08001601 struct dentry *dentry = nd->path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 struct inode *inode = dentry->d_inode;
1603 int error;
1604
1605 if (!inode)
1606 return -ENOENT;
1607
1608 if (S_ISLNK(inode->i_mode))
1609 return -ELOOP;
1610
Linus Torvalds974a9f02008-01-12 14:06:34 -08001611 if (S_ISDIR(inode->i_mode) && (acc_mode & MAY_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 return -EISDIR;
1613
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 /*
1615 * FIFO's, sockets and device files are special: they don't
1616 * actually live on the filesystem itself, and as such you
1617 * can write to them even if the filesystem is read-only.
1618 */
1619 if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
1620 flag &= ~O_TRUNC;
1621 } else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
Jan Blunck4ac91372008-02-14 19:34:32 -08001622 if (nd->path.mnt->mnt_flags & MNT_NODEV)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 return -EACCES;
1624
1625 flag &= ~O_TRUNC;
Linus Torvalds974a9f02008-01-12 14:06:34 -08001626 } else if (IS_RDONLY(inode) && (acc_mode & MAY_WRITE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 return -EROFS;
Dave Hansenb41572e2007-10-16 23:31:14 -07001628
1629 error = vfs_permission(nd, acc_mode);
1630 if (error)
1631 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 /*
1633 * An append-only file must be opened in append mode for writing.
1634 */
1635 if (IS_APPEND(inode)) {
1636 if ((flag & FMODE_WRITE) && !(flag & O_APPEND))
1637 return -EPERM;
1638 if (flag & O_TRUNC)
1639 return -EPERM;
1640 }
1641
1642 /* O_NOATIME can only be set by the owner or superuser */
1643 if (flag & O_NOATIME)
Satyam Sharma3bd858a2007-07-17 15:00:08 +05301644 if (!is_owner_or_cap(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 return -EPERM;
1646
1647 /*
1648 * Ensure there are no outstanding leases on the file.
1649 */
1650 error = break_lease(inode, flag);
1651 if (error)
1652 return error;
1653
1654 if (flag & O_TRUNC) {
1655 error = get_write_access(inode);
1656 if (error)
1657 return error;
1658
1659 /*
1660 * Refuse to truncate files with mandatory locks held on them.
1661 */
1662 error = locks_verify_locked(inode);
1663 if (!error) {
1664 DQUOT_INIT(inode);
Miklos Szeredid139d7f2007-10-18 03:07:00 -07001665
1666 error = do_truncate(dentry, 0,
1667 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
1668 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
1670 put_write_access(inode);
1671 if (error)
1672 return error;
1673 } else
1674 if (flag & FMODE_WRITE)
1675 DQUOT_INIT(inode);
1676
1677 return 0;
1678}
1679
Dave Hansend57999e2008-02-15 14:37:27 -08001680/*
1681 * Be careful about ever adding any more callers of this
1682 * function. Its flags must be in the namei format, not
1683 * what get passed to sys_open().
1684 */
1685static int __open_namei_create(struct nameidata *nd, struct path *path,
Dave Hansenaab520e2006-09-30 23:29:02 -07001686 int flag, int mode)
1687{
1688 int error;
Jan Blunck4ac91372008-02-14 19:34:32 -08001689 struct dentry *dir = nd->path.dentry;
Dave Hansenaab520e2006-09-30 23:29:02 -07001690
1691 if (!IS_POSIXACL(dir->d_inode))
1692 mode &= ~current->fs->umask;
1693 error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1694 mutex_unlock(&dir->d_inode->i_mutex);
Jan Blunck4ac91372008-02-14 19:34:32 -08001695 dput(nd->path.dentry);
1696 nd->path.dentry = path->dentry;
Dave Hansenaab520e2006-09-30 23:29:02 -07001697 if (error)
1698 return error;
1699 /* Don't check for write permission, don't truncate */
1700 return may_open(nd, 0, flag & ~O_TRUNC);
1701}
1702
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703/*
Dave Hansend57999e2008-02-15 14:37:27 -08001704 * Note that while the flag value (low two bits) for sys_open means:
1705 * 00 - read-only
1706 * 01 - write-only
1707 * 10 - read-write
1708 * 11 - special
1709 * it is changed into
1710 * 00 - no permissions needed
1711 * 01 - read-permission
1712 * 10 - write-permission
1713 * 11 - read-write
1714 * for the internal routines (ie open_namei()/follow_link() etc)
1715 * This is more logical, and also allows the 00 "no perm needed"
1716 * to be used for symlinks (where the permissions are checked
1717 * later).
1718 *
1719*/
1720static inline int open_to_namei_flags(int flag)
1721{
1722 if ((flag+1) & O_ACCMODE)
1723 flag++;
1724 return flag;
1725}
1726
1727/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 * Note that the low bits of "flag" aren't the same as in the open
Dave Hansend57999e2008-02-15 14:37:27 -08001729 * system call. See open_to_namei_flags().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001731struct file *do_filp_open(int dfd, const char *pathname,
1732 int open_flag, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733{
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001734 struct nameidata nd;
Trond Myklebust834f2a42005-10-18 14:20:16 -07001735 int acc_mode, error;
Al Viro4e7506e2005-06-06 13:36:00 -07001736 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 struct dentry *dir;
1738 int count = 0;
Dave Hansend57999e2008-02-15 14:37:27 -08001739 int flag = open_to_namei_flags(open_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740
1741 acc_mode = ACC_MODE(flag);
1742
Trond Myklebust834f2a42005-10-18 14:20:16 -07001743 /* O_TRUNC implies we need access checks for write permissions */
1744 if (flag & O_TRUNC)
1745 acc_mode |= MAY_WRITE;
1746
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 /* Allow the LSM permission hook to distinguish append
1748 access from general write access. */
1749 if (flag & O_APPEND)
1750 acc_mode |= MAY_APPEND;
1751
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 /*
1753 * The simplest case - just a plain lookup.
1754 */
1755 if (!(flag & O_CREAT)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001756 error = path_lookup_open(dfd, pathname, lookup_flags(flag),
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001757 &nd, flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 if (error)
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001759 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 goto ok;
1761 }
1762
1763 /*
1764 * Create - we need to know the parent.
1765 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001766 error = path_lookup_create(dfd, pathname, LOOKUP_PARENT,
1767 &nd, flag, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 if (error)
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001769 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770
1771 /*
1772 * We have the parent and last component. First of all, check
1773 * that we are not asked to creat(2) an obvious directory - that
1774 * will not do.
1775 */
1776 error = -EISDIR;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001777 if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 goto exit;
1779
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001780 dir = nd.path.dentry;
1781 nd.flags &= ~LOOKUP_PARENT;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001782 mutex_lock(&dir->d_inode->i_mutex);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001783 path.dentry = lookup_hash(&nd);
1784 path.mnt = nd.path.mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
1786do_last:
Al Viro4e7506e2005-06-06 13:36:00 -07001787 error = PTR_ERR(path.dentry);
1788 if (IS_ERR(path.dentry)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001789 mutex_unlock(&dir->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 goto exit;
1791 }
1792
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001793 if (IS_ERR(nd.intent.open.file)) {
Oleg Drokin4af4c522006-03-25 03:06:54 -08001794 mutex_unlock(&dir->d_inode->i_mutex);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001795 error = PTR_ERR(nd.intent.open.file);
Oleg Drokin4af4c522006-03-25 03:06:54 -08001796 goto exit_dput;
1797 }
1798
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 /* Negative dentry, just create the file */
Al Viro4e7506e2005-06-06 13:36:00 -07001800 if (!path.dentry->d_inode) {
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001801 error = __open_namei_create(&nd, &path, flag, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 if (error)
1803 goto exit;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001804 return nameidata_to_filp(&nd, open_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 }
1806
1807 /*
1808 * It already exists.
1809 */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001810 mutex_unlock(&dir->d_inode->i_mutex);
Al Viro5a190ae2007-06-07 12:19:32 -04001811 audit_inode(pathname, path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812
1813 error = -EEXIST;
1814 if (flag & O_EXCL)
1815 goto exit_dput;
1816
Al Viroe13b2102005-06-06 13:36:06 -07001817 if (__follow_mount(&path)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 error = -ELOOP;
Al Viroba7a4c12005-06-06 13:36:08 -07001819 if (flag & O_NOFOLLOW)
1820 goto exit_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 }
Amy Griffis3e2efce2006-07-13 13:16:02 -04001822
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 error = -ENOENT;
Al Viro4e7506e2005-06-06 13:36:00 -07001824 if (!path.dentry->d_inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 goto exit_dput;
Al Viro4e7506e2005-06-06 13:36:00 -07001826 if (path.dentry->d_inode->i_op && path.dentry->d_inode->i_op->follow_link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 goto do_link;
1828
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001829 path_to_nameidata(&path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 error = -EISDIR;
Al Viro4e7506e2005-06-06 13:36:00 -07001831 if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 goto exit;
1833ok:
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001834 error = may_open(&nd, acc_mode, flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 if (error)
1836 goto exit;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001837 return nameidata_to_filp(&nd, open_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
1839exit_dput:
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001840 path_put_conditional(&path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841exit:
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001842 if (!IS_ERR(nd.intent.open.file))
1843 release_open_intent(&nd);
1844 path_put(&nd.path);
1845 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
1847do_link:
1848 error = -ELOOP;
1849 if (flag & O_NOFOLLOW)
1850 goto exit_dput;
1851 /*
1852 * This is subtle. Instead of calling do_follow_link() we do the
1853 * thing by hands. The reason is that this way we have zero link_count
1854 * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
1855 * After that we have the parent and last component, i.e.
1856 * we are in the same situation as after the first path_walk().
1857 * Well, almost - if the last component is normal we get its copy
1858 * stored in nd->last.name and we will have to putname() it when we
1859 * are done. Procfs-like symlinks just set LAST_BIND.
1860 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001861 nd.flags |= LOOKUP_PARENT;
1862 error = security_inode_follow_link(path.dentry, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 if (error)
1864 goto exit_dput;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001865 error = __do_follow_link(&path, &nd);
Kirill Korotaevde459212006-07-14 00:23:49 -07001866 if (error) {
1867 /* Does someone understand code flow here? Or it is only
1868 * me so stupid? Anathema to whoever designed this non-sense
1869 * with "intent.open".
1870 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001871 release_open_intent(&nd);
1872 return ERR_PTR(error);
Kirill Korotaevde459212006-07-14 00:23:49 -07001873 }
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001874 nd.flags &= ~LOOKUP_PARENT;
1875 if (nd.last_type == LAST_BIND)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 goto ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 error = -EISDIR;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001878 if (nd.last_type != LAST_NORM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 goto exit;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001880 if (nd.last.name[nd.last.len]) {
1881 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 goto exit;
1883 }
1884 error = -ELOOP;
1885 if (count++==32) {
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001886 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 goto exit;
1888 }
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001889 dir = nd.path.dentry;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001890 mutex_lock(&dir->d_inode->i_mutex);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001891 path.dentry = lookup_hash(&nd);
1892 path.mnt = nd.path.mnt;
1893 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 goto do_last;
1895}
1896
1897/**
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001898 * filp_open - open file and return file pointer
1899 *
1900 * @filename: path to open
1901 * @flags: open flags as per the open(2) second argument
1902 * @mode: mode for the new file if O_CREAT is set, else ignored
1903 *
1904 * This is the helper to open a file from kernelspace if you really
1905 * have to. But in generally you should not do this, so please move
1906 * along, nothing to see here..
1907 */
1908struct file *filp_open(const char *filename, int flags, int mode)
1909{
1910 return do_filp_open(AT_FDCWD, filename, flags, mode);
1911}
1912EXPORT_SYMBOL(filp_open);
1913
1914/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 * lookup_create - lookup a dentry, creating it if it doesn't exist
1916 * @nd: nameidata info
1917 * @is_dir: directory flag
1918 *
1919 * Simple function to lookup and return a dentry and create it
1920 * if it doesn't exist. Is SMP-safe.
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001921 *
Jan Blunck4ac91372008-02-14 19:34:32 -08001922 * Returns with nd->path.dentry->d_inode->i_mutex locked.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 */
1924struct dentry *lookup_create(struct nameidata *nd, int is_dir)
1925{
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001926 struct dentry *dentry = ERR_PTR(-EEXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
Jan Blunck4ac91372008-02-14 19:34:32 -08001928 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001929 /*
1930 * Yucky last component or no last component at all?
1931 * (foo/., foo/.., /////)
1932 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 if (nd->last_type != LAST_NORM)
1934 goto fail;
1935 nd->flags &= ~LOOKUP_PARENT;
ASANO Masahiroa6349042006-08-22 20:06:02 -04001936 nd->flags |= LOOKUP_CREATE;
1937 nd->intent.open.flags = O_EXCL;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001938
1939 /*
1940 * Do the final lookup.
1941 */
Christoph Hellwig49705b72005-11-08 21:35:06 -08001942 dentry = lookup_hash(nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 if (IS_ERR(dentry))
1944 goto fail;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001945
1946 /*
1947 * Special case - lookup gave negative, but... we had foo/bar/
1948 * From the vfs_mknod() POV we just have a negative dentry -
1949 * all is fine. Let's be bastards - you had / on the end, you've
1950 * been asking for (non-existent) directory. -ENOENT for you.
1951 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode)
1953 goto enoent;
1954 return dentry;
1955enoent:
1956 dput(dentry);
1957 dentry = ERR_PTR(-ENOENT);
1958fail:
1959 return dentry;
1960}
Christoph Hellwigf81a0bf2005-05-19 12:26:43 -07001961EXPORT_SYMBOL_GPL(lookup_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
1963int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
1964{
1965 int error = may_create(dir, dentry, NULL);
1966
1967 if (error)
1968 return error;
1969
1970 if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
1971 return -EPERM;
1972
1973 if (!dir->i_op || !dir->i_op->mknod)
1974 return -EPERM;
1975
1976 error = security_inode_mknod(dir, dentry, mode, dev);
1977 if (error)
1978 return error;
1979
1980 DQUOT_INIT(dir);
1981 error = dir->i_op->mknod(dir, dentry, mode, dev);
Stephen Smalleya74574a2005-09-09 13:01:44 -07001982 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00001983 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 return error;
1985}
1986
Dave Hansen463c3192008-02-15 14:37:57 -08001987static int may_mknod(mode_t mode)
1988{
1989 switch (mode & S_IFMT) {
1990 case S_IFREG:
1991 case S_IFCHR:
1992 case S_IFBLK:
1993 case S_IFIFO:
1994 case S_IFSOCK:
1995 case 0: /* zero mode translates to S_IFREG */
1996 return 0;
1997 case S_IFDIR:
1998 return -EPERM;
1999 default:
2000 return -EINVAL;
2001 }
2002}
2003
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002004asmlinkage long sys_mknodat(int dfd, const char __user *filename, int mode,
2005 unsigned dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006{
2007 int error = 0;
2008 char * tmp;
2009 struct dentry * dentry;
2010 struct nameidata nd;
2011
2012 if (S_ISDIR(mode))
2013 return -EPERM;
2014 tmp = getname(filename);
2015 if (IS_ERR(tmp))
2016 return PTR_ERR(tmp);
2017
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002018 error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 if (error)
2020 goto out;
2021 dentry = lookup_create(&nd, 0);
Dave Hansen463c3192008-02-15 14:37:57 -08002022 if (IS_ERR(dentry)) {
2023 error = PTR_ERR(dentry);
2024 goto out_unlock;
2025 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002026 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 mode &= ~current->fs->umask;
Dave Hansen463c3192008-02-15 14:37:57 -08002028 error = may_mknod(mode);
2029 if (error)
2030 goto out_dput;
2031 error = mnt_want_write(nd.path.mnt);
2032 if (error)
2033 goto out_dput;
2034 switch (mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 case 0: case S_IFREG:
Jan Blunck4ac91372008-02-14 19:34:32 -08002036 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 break;
2038 case S_IFCHR: case S_IFBLK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002039 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 new_decode_dev(dev));
2041 break;
2042 case S_IFIFO: case S_IFSOCK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002043 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 }
Dave Hansen463c3192008-02-15 14:37:57 -08002046 mnt_drop_write(nd.path.mnt);
2047out_dput:
2048 dput(dentry);
2049out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002050 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002051 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052out:
2053 putname(tmp);
2054
2055 return error;
2056}
2057
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002058asmlinkage long sys_mknod(const char __user *filename, int mode, unsigned dev)
2059{
2060 return sys_mknodat(AT_FDCWD, filename, mode, dev);
2061}
2062
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2064{
2065 int error = may_create(dir, dentry, NULL);
2066
2067 if (error)
2068 return error;
2069
2070 if (!dir->i_op || !dir->i_op->mkdir)
2071 return -EPERM;
2072
2073 mode &= (S_IRWXUGO|S_ISVTX);
2074 error = security_inode_mkdir(dir, dentry, mode);
2075 if (error)
2076 return error;
2077
2078 DQUOT_INIT(dir);
2079 error = dir->i_op->mkdir(dir, dentry, mode);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002080 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002081 fsnotify_mkdir(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 return error;
2083}
2084
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002085asmlinkage long sys_mkdirat(int dfd, const char __user *pathname, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086{
2087 int error = 0;
2088 char * tmp;
Dave Hansen6902d922006-09-30 23:29:01 -07002089 struct dentry *dentry;
2090 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091
2092 tmp = getname(pathname);
2093 error = PTR_ERR(tmp);
Dave Hansen6902d922006-09-30 23:29:01 -07002094 if (IS_ERR(tmp))
2095 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096
Dave Hansen6902d922006-09-30 23:29:01 -07002097 error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
2098 if (error)
2099 goto out;
2100 dentry = lookup_create(&nd, 1);
2101 error = PTR_ERR(dentry);
2102 if (IS_ERR(dentry))
2103 goto out_unlock;
2104
Jan Blunck4ac91372008-02-14 19:34:32 -08002105 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Dave Hansen6902d922006-09-30 23:29:01 -07002106 mode &= ~current->fs->umask;
Dave Hansen463c3192008-02-15 14:37:57 -08002107 error = mnt_want_write(nd.path.mnt);
2108 if (error)
2109 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002110 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
Dave Hansen463c3192008-02-15 14:37:57 -08002111 mnt_drop_write(nd.path.mnt);
2112out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002113 dput(dentry);
2114out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002115 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002116 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117out:
Dave Hansen6902d922006-09-30 23:29:01 -07002118 putname(tmp);
2119out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 return error;
2121}
2122
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002123asmlinkage long sys_mkdir(const char __user *pathname, int mode)
2124{
2125 return sys_mkdirat(AT_FDCWD, pathname, mode);
2126}
2127
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128/*
2129 * We try to drop the dentry early: we should have
2130 * a usage count of 2 if we're the only user of this
2131 * dentry, and if that is true (possibly after pruning
2132 * the dcache), then we drop the dentry now.
2133 *
2134 * A low-level filesystem can, if it choses, legally
2135 * do a
2136 *
2137 * if (!d_unhashed(dentry))
2138 * return -EBUSY;
2139 *
2140 * if it cannot handle the case of removing a directory
2141 * that is still in use by something else..
2142 */
2143void dentry_unhash(struct dentry *dentry)
2144{
2145 dget(dentry);
Vasily Averindc168422006-12-06 20:37:07 -08002146 shrink_dcache_parent(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 spin_lock(&dcache_lock);
2148 spin_lock(&dentry->d_lock);
2149 if (atomic_read(&dentry->d_count) == 2)
2150 __d_drop(dentry);
2151 spin_unlock(&dentry->d_lock);
2152 spin_unlock(&dcache_lock);
2153}
2154
2155int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2156{
2157 int error = may_delete(dir, dentry, 1);
2158
2159 if (error)
2160 return error;
2161
2162 if (!dir->i_op || !dir->i_op->rmdir)
2163 return -EPERM;
2164
2165 DQUOT_INIT(dir);
2166
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002167 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 dentry_unhash(dentry);
2169 if (d_mountpoint(dentry))
2170 error = -EBUSY;
2171 else {
2172 error = security_inode_rmdir(dir, dentry);
2173 if (!error) {
2174 error = dir->i_op->rmdir(dir, dentry);
2175 if (!error)
2176 dentry->d_inode->i_flags |= S_DEAD;
2177 }
2178 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002179 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 d_delete(dentry);
2182 }
2183 dput(dentry);
2184
2185 return error;
2186}
2187
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002188static long do_rmdir(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189{
2190 int error = 0;
2191 char * name;
2192 struct dentry *dentry;
2193 struct nameidata nd;
2194
2195 name = getname(pathname);
2196 if(IS_ERR(name))
2197 return PTR_ERR(name);
2198
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002199 error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 if (error)
2201 goto exit;
2202
2203 switch(nd.last_type) {
2204 case LAST_DOTDOT:
2205 error = -ENOTEMPTY;
2206 goto exit1;
2207 case LAST_DOT:
2208 error = -EINVAL;
2209 goto exit1;
2210 case LAST_ROOT:
2211 error = -EBUSY;
2212 goto exit1;
2213 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002214 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002215 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 error = PTR_ERR(dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07002217 if (IS_ERR(dentry))
2218 goto exit2;
Dave Hansen06227532008-02-15 14:37:34 -08002219 error = mnt_want_write(nd.path.mnt);
2220 if (error)
2221 goto exit3;
Jan Blunck4ac91372008-02-14 19:34:32 -08002222 error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
Dave Hansen06227532008-02-15 14:37:34 -08002223 mnt_drop_write(nd.path.mnt);
2224exit3:
Dave Hansen6902d922006-09-30 23:29:01 -07002225 dput(dentry);
2226exit2:
Jan Blunck4ac91372008-02-14 19:34:32 -08002227 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002229 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230exit:
2231 putname(name);
2232 return error;
2233}
2234
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002235asmlinkage long sys_rmdir(const char __user *pathname)
2236{
2237 return do_rmdir(AT_FDCWD, pathname);
2238}
2239
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240int vfs_unlink(struct inode *dir, struct dentry *dentry)
2241{
2242 int error = may_delete(dir, dentry, 0);
2243
2244 if (error)
2245 return error;
2246
2247 if (!dir->i_op || !dir->i_op->unlink)
2248 return -EPERM;
2249
2250 DQUOT_INIT(dir);
2251
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002252 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 if (d_mountpoint(dentry))
2254 error = -EBUSY;
2255 else {
2256 error = security_inode_unlink(dir, dentry);
2257 if (!error)
2258 error = dir->i_op->unlink(dir, dentry);
2259 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002260 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261
2262 /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2263 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
Jan Karaece95912008-02-06 01:37:13 -08002264 fsnotify_link_count(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 d_delete(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 }
Robert Love0eeca282005-07-12 17:06:03 -04002267
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 return error;
2269}
2270
2271/*
2272 * Make sure that the actual truncation of the file will occur outside its
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002273 * directory's i_mutex. Truncate can take a long time if there is a lot of
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 * writeout happening, and we don't want to prevent access to the directory
2275 * while waiting on the I/O.
2276 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002277static long do_unlinkat(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278{
2279 int error = 0;
2280 char * name;
2281 struct dentry *dentry;
2282 struct nameidata nd;
2283 struct inode *inode = NULL;
2284
2285 name = getname(pathname);
2286 if(IS_ERR(name))
2287 return PTR_ERR(name);
2288
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002289 error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 if (error)
2291 goto exit;
2292 error = -EISDIR;
2293 if (nd.last_type != LAST_NORM)
2294 goto exit1;
Jan Blunck4ac91372008-02-14 19:34:32 -08002295 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002296 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 error = PTR_ERR(dentry);
2298 if (!IS_ERR(dentry)) {
2299 /* Why not before? Because we want correct error value */
2300 if (nd.last.name[nd.last.len])
2301 goto slashes;
2302 inode = dentry->d_inode;
2303 if (inode)
2304 atomic_inc(&inode->i_count);
Dave Hansen06227532008-02-15 14:37:34 -08002305 error = mnt_want_write(nd.path.mnt);
2306 if (error)
2307 goto exit2;
Jan Blunck4ac91372008-02-14 19:34:32 -08002308 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
Dave Hansen06227532008-02-15 14:37:34 -08002309 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 exit2:
2311 dput(dentry);
2312 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002313 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 if (inode)
2315 iput(inode); /* truncate the inode here */
2316exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002317 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318exit:
2319 putname(name);
2320 return error;
2321
2322slashes:
2323 error = !dentry->d_inode ? -ENOENT :
2324 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2325 goto exit2;
2326}
2327
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002328asmlinkage long sys_unlinkat(int dfd, const char __user *pathname, int flag)
2329{
2330 if ((flag & ~AT_REMOVEDIR) != 0)
2331 return -EINVAL;
2332
2333 if (flag & AT_REMOVEDIR)
2334 return do_rmdir(dfd, pathname);
2335
2336 return do_unlinkat(dfd, pathname);
2337}
2338
2339asmlinkage long sys_unlink(const char __user *pathname)
2340{
2341 return do_unlinkat(AT_FDCWD, pathname);
2342}
2343
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname, int mode)
2345{
2346 int error = may_create(dir, dentry, NULL);
2347
2348 if (error)
2349 return error;
2350
2351 if (!dir->i_op || !dir->i_op->symlink)
2352 return -EPERM;
2353
2354 error = security_inode_symlink(dir, dentry, oldname);
2355 if (error)
2356 return error;
2357
2358 DQUOT_INIT(dir);
2359 error = dir->i_op->symlink(dir, dentry, oldname);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002360 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002361 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 return error;
2363}
2364
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002365asmlinkage long sys_symlinkat(const char __user *oldname,
2366 int newdfd, const char __user *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367{
2368 int error = 0;
2369 char * from;
2370 char * to;
Dave Hansen6902d922006-09-30 23:29:01 -07002371 struct dentry *dentry;
2372 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
2374 from = getname(oldname);
2375 if(IS_ERR(from))
2376 return PTR_ERR(from);
2377 to = getname(newname);
2378 error = PTR_ERR(to);
Dave Hansen6902d922006-09-30 23:29:01 -07002379 if (IS_ERR(to))
2380 goto out_putname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381
Dave Hansen6902d922006-09-30 23:29:01 -07002382 error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
2383 if (error)
2384 goto out;
2385 dentry = lookup_create(&nd, 0);
2386 error = PTR_ERR(dentry);
2387 if (IS_ERR(dentry))
2388 goto out_unlock;
2389
Dave Hansen75c3f292008-02-15 14:37:45 -08002390 error = mnt_want_write(nd.path.mnt);
2391 if (error)
2392 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002393 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from, S_IALLUGO);
Dave Hansen75c3f292008-02-15 14:37:45 -08002394 mnt_drop_write(nd.path.mnt);
2395out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002396 dput(dentry);
2397out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002398 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002399 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400out:
Dave Hansen6902d922006-09-30 23:29:01 -07002401 putname(to);
2402out_putname:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 putname(from);
2404 return error;
2405}
2406
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002407asmlinkage long sys_symlink(const char __user *oldname, const char __user *newname)
2408{
2409 return sys_symlinkat(oldname, AT_FDCWD, newname);
2410}
2411
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2413{
2414 struct inode *inode = old_dentry->d_inode;
2415 int error;
2416
2417 if (!inode)
2418 return -ENOENT;
2419
2420 error = may_create(dir, new_dentry, NULL);
2421 if (error)
2422 return error;
2423
2424 if (dir->i_sb != inode->i_sb)
2425 return -EXDEV;
2426
2427 /*
2428 * A link to an append-only or immutable file cannot be created.
2429 */
2430 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2431 return -EPERM;
2432 if (!dir->i_op || !dir->i_op->link)
2433 return -EPERM;
2434 if (S_ISDIR(old_dentry->d_inode->i_mode))
2435 return -EPERM;
2436
2437 error = security_inode_link(old_dentry, dir, new_dentry);
2438 if (error)
2439 return error;
2440
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002441 mutex_lock(&old_dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 DQUOT_INIT(dir);
2443 error = dir->i_op->link(old_dentry, dir, new_dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002444 mutex_unlock(&old_dentry->d_inode->i_mutex);
Stephen Smalleye31e14e2005-09-09 13:01:45 -07002445 if (!error)
Jan Karaece95912008-02-06 01:37:13 -08002446 fsnotify_link(dir, old_dentry->d_inode, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 return error;
2448}
2449
2450/*
2451 * Hardlinks are often used in delicate situations. We avoid
2452 * security-related surprises by not following symlinks on the
2453 * newname. --KAB
2454 *
2455 * We don't follow them on the oldname either to be compatible
2456 * with linux 2.0, and to avoid hard-linking to directories
2457 * and other special files. --ADM
2458 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002459asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002460 int newdfd, const char __user *newname,
2461 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462{
2463 struct dentry *new_dentry;
2464 struct nameidata nd, old_nd;
2465 int error;
2466 char * to;
2467
Ulrich Drepper45c9b112006-06-25 05:49:11 -07002468 if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002469 return -EINVAL;
2470
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 to = getname(newname);
2472 if (IS_ERR(to))
2473 return PTR_ERR(to);
2474
Ulrich Drepper45c9b112006-06-25 05:49:11 -07002475 error = __user_walk_fd(olddfd, oldname,
2476 flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
2477 &old_nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 if (error)
2479 goto exit;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002480 error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 if (error)
2482 goto out;
2483 error = -EXDEV;
Jan Blunck4ac91372008-02-14 19:34:32 -08002484 if (old_nd.path.mnt != nd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 goto out_release;
2486 new_dentry = lookup_create(&nd, 0);
2487 error = PTR_ERR(new_dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07002488 if (IS_ERR(new_dentry))
2489 goto out_unlock;
Dave Hansen75c3f292008-02-15 14:37:45 -08002490 error = mnt_want_write(nd.path.mnt);
2491 if (error)
2492 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002493 error = vfs_link(old_nd.path.dentry, nd.path.dentry->d_inode, new_dentry);
Dave Hansen75c3f292008-02-15 14:37:45 -08002494 mnt_drop_write(nd.path.mnt);
2495out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002496 dput(new_dentry);
2497out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002498 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499out_release:
Jan Blunck1d957f92008-02-14 19:34:35 -08002500 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501out:
Jan Blunck1d957f92008-02-14 19:34:35 -08002502 path_put(&old_nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503exit:
2504 putname(to);
2505
2506 return error;
2507}
2508
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002509asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
2510{
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002511 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002512}
2513
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514/*
2515 * The worst of all namespace operations - renaming directory. "Perverted"
2516 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2517 * Problems:
2518 * a) we can get into loop creation. Check is done in is_subdir().
2519 * b) race potential - two innocent renames can create a loop together.
2520 * That's where 4.4 screws up. Current fix: serialization on
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002521 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 * story.
2523 * c) we have to lock _three_ objects - parents and victim (if it exists).
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002524 * And that - after we got ->i_mutex on parents (until then we don't know
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 * whether the target exists). Solution: try to be smart with locking
2526 * order for inodes. We rely on the fact that tree topology may change
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002527 * only under ->s_vfs_rename_mutex _and_ that parent of the object we
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 * move will be locked. Thus we can rank directories by the tree
2529 * (ancestors first) and rank all non-directories after them.
2530 * That works since everybody except rename does "lock parent, lookup,
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002531 * lock child" and rename is under ->s_vfs_rename_mutex.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 * HOWEVER, it relies on the assumption that any object with ->lookup()
2533 * has no more than 1 dentry. If "hybrid" objects will ever appear,
2534 * we'd better make sure that there's no link(2) for them.
2535 * d) some filesystems don't support opened-but-unlinked directories,
2536 * either because of layout or because they are not ready to deal with
2537 * all cases correctly. The latter will be fixed (taking this sort of
2538 * stuff into VFS), but the former is not going away. Solution: the same
2539 * trick as in rmdir().
2540 * e) conversion from fhandle to dentry may come in the wrong moment - when
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002541 * we are removing the target. Solution: we will have to grab ->i_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002543 * ->i_mutex on parents, which works but leads to some truely excessive
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 * locking].
2545 */
Adrian Bunk75c96f82005-05-05 16:16:09 -07002546static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2547 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548{
2549 int error = 0;
2550 struct inode *target;
2551
2552 /*
2553 * If we are going to change the parent - check write permissions,
2554 * we'll need to flip '..'.
2555 */
2556 if (new_dir != old_dir) {
2557 error = permission(old_dentry->d_inode, MAY_WRITE, NULL);
2558 if (error)
2559 return error;
2560 }
2561
2562 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2563 if (error)
2564 return error;
2565
2566 target = new_dentry->d_inode;
2567 if (target) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002568 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 dentry_unhash(new_dentry);
2570 }
2571 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2572 error = -EBUSY;
2573 else
2574 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2575 if (target) {
2576 if (!error)
2577 target->i_flags |= S_DEAD;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002578 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 if (d_unhashed(new_dentry))
2580 d_rehash(new_dentry);
2581 dput(new_dentry);
2582 }
Stephen Smalleye31e14e2005-09-09 13:01:45 -07002583 if (!error)
Mark Fasheh349457c2006-09-08 14:22:21 -07002584 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2585 d_move(old_dentry,new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 return error;
2587}
2588
Adrian Bunk75c96f82005-05-05 16:16:09 -07002589static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
2590 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591{
2592 struct inode *target;
2593 int error;
2594
2595 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2596 if (error)
2597 return error;
2598
2599 dget(new_dentry);
2600 target = new_dentry->d_inode;
2601 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002602 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2604 error = -EBUSY;
2605 else
2606 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2607 if (!error) {
Mark Fasheh349457c2006-09-08 14:22:21 -07002608 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 d_move(old_dentry, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 }
2611 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002612 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613 dput(new_dentry);
2614 return error;
2615}
2616
2617int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2618 struct inode *new_dir, struct dentry *new_dentry)
2619{
2620 int error;
2621 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
Robert Love0eeca282005-07-12 17:06:03 -04002622 const char *old_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
2624 if (old_dentry->d_inode == new_dentry->d_inode)
2625 return 0;
2626
2627 error = may_delete(old_dir, old_dentry, is_dir);
2628 if (error)
2629 return error;
2630
2631 if (!new_dentry->d_inode)
2632 error = may_create(new_dir, new_dentry, NULL);
2633 else
2634 error = may_delete(new_dir, new_dentry, is_dir);
2635 if (error)
2636 return error;
2637
2638 if (!old_dir->i_op || !old_dir->i_op->rename)
2639 return -EPERM;
2640
2641 DQUOT_INIT(old_dir);
2642 DQUOT_INIT(new_dir);
2643
Robert Love0eeca282005-07-12 17:06:03 -04002644 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2645
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 if (is_dir)
2647 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
2648 else
2649 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
2650 if (!error) {
Robert Love0eeca282005-07-12 17:06:03 -04002651 const char *new_name = old_dentry->d_name.name;
John McCutchan89204c42005-08-15 12:13:28 -04002652 fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir,
Al Viro5a190ae2007-06-07 12:19:32 -04002653 new_dentry->d_inode, old_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 }
Robert Love0eeca282005-07-12 17:06:03 -04002655 fsnotify_oldname_free(old_name);
2656
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 return error;
2658}
2659
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002660static int do_rename(int olddfd, const char *oldname,
2661 int newdfd, const char *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662{
2663 int error = 0;
2664 struct dentry * old_dir, * new_dir;
2665 struct dentry * old_dentry, *new_dentry;
2666 struct dentry * trap;
2667 struct nameidata oldnd, newnd;
2668
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002669 error = do_path_lookup(olddfd, oldname, LOOKUP_PARENT, &oldnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 if (error)
2671 goto exit;
2672
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002673 error = do_path_lookup(newdfd, newname, LOOKUP_PARENT, &newnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 if (error)
2675 goto exit1;
2676
2677 error = -EXDEV;
Jan Blunck4ac91372008-02-14 19:34:32 -08002678 if (oldnd.path.mnt != newnd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 goto exit2;
2680
Jan Blunck4ac91372008-02-14 19:34:32 -08002681 old_dir = oldnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 error = -EBUSY;
2683 if (oldnd.last_type != LAST_NORM)
2684 goto exit2;
2685
Jan Blunck4ac91372008-02-14 19:34:32 -08002686 new_dir = newnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687 if (newnd.last_type != LAST_NORM)
2688 goto exit2;
2689
2690 trap = lock_rename(new_dir, old_dir);
2691
Christoph Hellwig49705b72005-11-08 21:35:06 -08002692 old_dentry = lookup_hash(&oldnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 error = PTR_ERR(old_dentry);
2694 if (IS_ERR(old_dentry))
2695 goto exit3;
2696 /* source must exist */
2697 error = -ENOENT;
2698 if (!old_dentry->d_inode)
2699 goto exit4;
2700 /* unless the source is a directory trailing slashes give -ENOTDIR */
2701 if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
2702 error = -ENOTDIR;
2703 if (oldnd.last.name[oldnd.last.len])
2704 goto exit4;
2705 if (newnd.last.name[newnd.last.len])
2706 goto exit4;
2707 }
2708 /* source should not be ancestor of target */
2709 error = -EINVAL;
2710 if (old_dentry == trap)
2711 goto exit4;
Christoph Hellwig49705b72005-11-08 21:35:06 -08002712 new_dentry = lookup_hash(&newnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 error = PTR_ERR(new_dentry);
2714 if (IS_ERR(new_dentry))
2715 goto exit4;
2716 /* target should not be an ancestor of source */
2717 error = -ENOTEMPTY;
2718 if (new_dentry == trap)
2719 goto exit5;
2720
2721 error = vfs_rename(old_dir->d_inode, old_dentry,
2722 new_dir->d_inode, new_dentry);
2723exit5:
2724 dput(new_dentry);
2725exit4:
2726 dput(old_dentry);
2727exit3:
2728 unlock_rename(new_dir, old_dir);
2729exit2:
Jan Blunck1d957f92008-02-14 19:34:35 -08002730 path_put(&newnd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002732 path_put(&oldnd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733exit:
2734 return error;
2735}
2736
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002737asmlinkage long sys_renameat(int olddfd, const char __user *oldname,
2738 int newdfd, const char __user *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739{
2740 int error;
2741 char * from;
2742 char * to;
2743
2744 from = getname(oldname);
2745 if(IS_ERR(from))
2746 return PTR_ERR(from);
2747 to = getname(newname);
2748 error = PTR_ERR(to);
2749 if (!IS_ERR(to)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002750 error = do_rename(olddfd, from, newdfd, to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 putname(to);
2752 }
2753 putname(from);
2754 return error;
2755}
2756
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002757asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)
2758{
2759 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
2760}
2761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
2763{
2764 int len;
2765
2766 len = PTR_ERR(link);
2767 if (IS_ERR(link))
2768 goto out;
2769
2770 len = strlen(link);
2771 if (len > (unsigned) buflen)
2772 len = buflen;
2773 if (copy_to_user(buffer, link, len))
2774 len = -EFAULT;
2775out:
2776 return len;
2777}
2778
2779/*
2780 * A helper for ->readlink(). This should be used *ONLY* for symlinks that
2781 * have ->follow_link() touching nd only in nd_set_link(). Using (or not
2782 * using) it for any given inode is up to filesystem.
2783 */
2784int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2785{
2786 struct nameidata nd;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002787 void *cookie;
2788
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789 nd.depth = 0;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002790 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2791 if (!IS_ERR(cookie)) {
2792 int res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 if (dentry->d_inode->i_op->put_link)
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002794 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
2795 cookie = ERR_PTR(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 }
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002797 return PTR_ERR(cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798}
2799
2800int vfs_follow_link(struct nameidata *nd, const char *link)
2801{
2802 return __vfs_follow_link(nd, link);
2803}
2804
2805/* get the link contents into pagecache */
2806static char *page_getlink(struct dentry * dentry, struct page **ppage)
2807{
2808 struct page * page;
2809 struct address_space *mapping = dentry->d_inode->i_mapping;
Pekka Enberg090d2b12006-06-23 02:05:08 -07002810 page = read_mapping_page(mapping, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 if (IS_ERR(page))
Nick Piggin6fe69002007-05-06 14:49:04 -07002812 return (char*)page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813 *ppage = page;
2814 return kmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815}
2816
2817int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2818{
2819 struct page *page = NULL;
2820 char *s = page_getlink(dentry, &page);
2821 int res = vfs_readlink(dentry,buffer,buflen,s);
2822 if (page) {
2823 kunmap(page);
2824 page_cache_release(page);
2825 }
2826 return res;
2827}
2828
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002829void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002831 struct page *page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 nd_set_link(nd, page_getlink(dentry, &page));
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002833 return page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834}
2835
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002836void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002838 struct page *page = cookie;
2839
2840 if (page) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 kunmap(page);
2842 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 }
2844}
2845
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002846int __page_symlink(struct inode *inode, const char *symname, int len,
2847 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848{
2849 struct address_space *mapping = inode->i_mapping;
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002850 struct page *page;
Nick Pigginafddba42007-10-16 01:25:01 -07002851 void *fsdata;
Dmitriy Monakhovbeb497a2007-02-16 01:27:18 -08002852 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 char *kaddr;
2854
NeilBrown7e53cac2006-03-25 03:07:57 -08002855retry:
Nick Pigginafddba42007-10-16 01:25:01 -07002856 err = pagecache_write_begin(NULL, mapping, 0, len-1,
2857 AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 if (err)
Nick Pigginafddba42007-10-16 01:25:01 -07002859 goto fail;
2860
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 kaddr = kmap_atomic(page, KM_USER0);
2862 memcpy(kaddr, symname, len-1);
2863 kunmap_atomic(kaddr, KM_USER0);
Nick Pigginafddba42007-10-16 01:25:01 -07002864
2865 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
2866 page, fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 if (err < 0)
2868 goto fail;
Nick Pigginafddba42007-10-16 01:25:01 -07002869 if (err < len-1)
2870 goto retry;
2871
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 mark_inode_dirty(inode);
2873 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874fail:
2875 return err;
2876}
2877
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002878int page_symlink(struct inode *inode, const char *symname, int len)
2879{
2880 return __page_symlink(inode, symname, len,
2881 mapping_gfp_mask(inode->i_mapping));
2882}
2883
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002884const struct inode_operations page_symlink_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885 .readlink = generic_readlink,
2886 .follow_link = page_follow_link_light,
2887 .put_link = page_put_link,
2888};
2889
2890EXPORT_SYMBOL(__user_walk);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002891EXPORT_SYMBOL(__user_walk_fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892EXPORT_SYMBOL(follow_down);
2893EXPORT_SYMBOL(follow_up);
2894EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
2895EXPORT_SYMBOL(getname);
2896EXPORT_SYMBOL(lock_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897EXPORT_SYMBOL(lookup_one_len);
2898EXPORT_SYMBOL(page_follow_link_light);
2899EXPORT_SYMBOL(page_put_link);
2900EXPORT_SYMBOL(page_readlink);
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002901EXPORT_SYMBOL(__page_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902EXPORT_SYMBOL(page_symlink);
2903EXPORT_SYMBOL(page_symlink_inode_operations);
2904EXPORT_SYMBOL(path_lookup);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07002905EXPORT_SYMBOL(vfs_path_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906EXPORT_SYMBOL(permission);
Christoph Hellwige4543ed2005-11-08 21:35:04 -08002907EXPORT_SYMBOL(vfs_permission);
Christoph Hellwig8c744fb2005-11-08 21:35:04 -08002908EXPORT_SYMBOL(file_permission);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909EXPORT_SYMBOL(unlock_rename);
2910EXPORT_SYMBOL(vfs_create);
2911EXPORT_SYMBOL(vfs_follow_link);
2912EXPORT_SYMBOL(vfs_link);
2913EXPORT_SYMBOL(vfs_mkdir);
2914EXPORT_SYMBOL(vfs_mknod);
2915EXPORT_SYMBOL(generic_permission);
2916EXPORT_SYMBOL(vfs_readlink);
2917EXPORT_SYMBOL(vfs_rename);
2918EXPORT_SYMBOL(vfs_rmdir);
2919EXPORT_SYMBOL(vfs_symlink);
2920EXPORT_SYMBOL(vfs_unlink);
2921EXPORT_SYMBOL(dentry_unhash);
2922EXPORT_SYMBOL(generic_readlink);