blob: e179f71bfcb058df613f83cb1ff923d47ffc4618 [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 Blunck5dd784d02008-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 Blunck5dd784d02008-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;
Dave Hansen4a3fd212008-02-15 14:37:48 -08001626 }
Dave Hansenb41572e2007-10-16 23:31:14 -07001627
1628 error = vfs_permission(nd, acc_mode);
1629 if (error)
1630 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 /*
1632 * An append-only file must be opened in append mode for writing.
1633 */
1634 if (IS_APPEND(inode)) {
1635 if ((flag & FMODE_WRITE) && !(flag & O_APPEND))
1636 return -EPERM;
1637 if (flag & O_TRUNC)
1638 return -EPERM;
1639 }
1640
1641 /* O_NOATIME can only be set by the owner or superuser */
1642 if (flag & O_NOATIME)
Satyam Sharma3bd858a2007-07-17 15:00:08 +05301643 if (!is_owner_or_cap(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 return -EPERM;
1645
1646 /*
1647 * Ensure there are no outstanding leases on the file.
1648 */
1649 error = break_lease(inode, flag);
1650 if (error)
1651 return error;
1652
1653 if (flag & O_TRUNC) {
1654 error = get_write_access(inode);
1655 if (error)
1656 return error;
1657
1658 /*
1659 * Refuse to truncate files with mandatory locks held on them.
1660 */
1661 error = locks_verify_locked(inode);
1662 if (!error) {
1663 DQUOT_INIT(inode);
Miklos Szeredid139d7f2007-10-18 03:07:00 -07001664
1665 error = do_truncate(dentry, 0,
1666 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
1667 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 }
1669 put_write_access(inode);
1670 if (error)
1671 return error;
1672 } else
1673 if (flag & FMODE_WRITE)
1674 DQUOT_INIT(inode);
1675
1676 return 0;
1677}
1678
Dave Hansend57999e2008-02-15 14:37:27 -08001679/*
1680 * Be careful about ever adding any more callers of this
1681 * function. Its flags must be in the namei format, not
1682 * what get passed to sys_open().
1683 */
1684static int __open_namei_create(struct nameidata *nd, struct path *path,
Dave Hansenaab520e2006-09-30 23:29:02 -07001685 int flag, int mode)
1686{
1687 int error;
Jan Blunck4ac91372008-02-14 19:34:32 -08001688 struct dentry *dir = nd->path.dentry;
Dave Hansenaab520e2006-09-30 23:29:02 -07001689
1690 if (!IS_POSIXACL(dir->d_inode))
1691 mode &= ~current->fs->umask;
1692 error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1693 mutex_unlock(&dir->d_inode->i_mutex);
Jan Blunck4ac91372008-02-14 19:34:32 -08001694 dput(nd->path.dentry);
1695 nd->path.dentry = path->dentry;
Dave Hansenaab520e2006-09-30 23:29:02 -07001696 if (error)
1697 return error;
1698 /* Don't check for write permission, don't truncate */
1699 return may_open(nd, 0, flag & ~O_TRUNC);
1700}
1701
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702/*
Dave Hansend57999e2008-02-15 14:37:27 -08001703 * Note that while the flag value (low two bits) for sys_open means:
1704 * 00 - read-only
1705 * 01 - write-only
1706 * 10 - read-write
1707 * 11 - special
1708 * it is changed into
1709 * 00 - no permissions needed
1710 * 01 - read-permission
1711 * 10 - write-permission
1712 * 11 - read-write
1713 * for the internal routines (ie open_namei()/follow_link() etc)
1714 * This is more logical, and also allows the 00 "no perm needed"
1715 * to be used for symlinks (where the permissions are checked
1716 * later).
1717 *
1718*/
1719static inline int open_to_namei_flags(int flag)
1720{
1721 if ((flag+1) & O_ACCMODE)
1722 flag++;
1723 return flag;
1724}
1725
Dave Hansen4a3fd212008-02-15 14:37:48 -08001726static int open_will_write_to_fs(int flag, struct inode *inode)
1727{
1728 /*
1729 * We'll never write to the fs underlying
1730 * a device file.
1731 */
1732 if (special_file(inode->i_mode))
1733 return 0;
1734 return (flag & O_TRUNC);
1735}
1736
Dave Hansend57999e2008-02-15 14:37:27 -08001737/*
Dave Hansen4a3fd212008-02-15 14:37:48 -08001738 * Note that the low bits of the passed in "open_flag"
1739 * are not the same as in the local variable "flag". See
1740 * open_to_namei_flags() for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001742struct file *do_filp_open(int dfd, const char *pathname,
1743 int open_flag, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744{
Dave Hansen4a3fd212008-02-15 14:37:48 -08001745 struct file *filp;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001746 struct nameidata nd;
Trond Myklebust834f2a42005-10-18 14:20:16 -07001747 int acc_mode, error;
Al Viro4e7506e2005-06-06 13:36:00 -07001748 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 struct dentry *dir;
1750 int count = 0;
Dave Hansen4a3fd212008-02-15 14:37:48 -08001751 int will_write;
Dave Hansend57999e2008-02-15 14:37:27 -08001752 int flag = open_to_namei_flags(open_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753
1754 acc_mode = ACC_MODE(flag);
1755
Trond Myklebust834f2a42005-10-18 14:20:16 -07001756 /* O_TRUNC implies we need access checks for write permissions */
1757 if (flag & O_TRUNC)
1758 acc_mode |= MAY_WRITE;
1759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 /* Allow the LSM permission hook to distinguish append
1761 access from general write access. */
1762 if (flag & O_APPEND)
1763 acc_mode |= MAY_APPEND;
1764
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 /*
1766 * The simplest case - just a plain lookup.
1767 */
1768 if (!(flag & O_CREAT)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08001769 error = path_lookup_open(dfd, pathname, lookup_flags(flag),
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001770 &nd, flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 if (error)
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001772 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 goto ok;
1774 }
1775
1776 /*
1777 * Create - we need to know the parent.
1778 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001779 error = path_lookup_create(dfd, pathname, LOOKUP_PARENT,
1780 &nd, flag, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 if (error)
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001782 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
1784 /*
1785 * We have the parent and last component. First of all, check
1786 * that we are not asked to creat(2) an obvious directory - that
1787 * will not do.
1788 */
1789 error = -EISDIR;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001790 if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 goto exit;
1792
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001793 dir = nd.path.dentry;
1794 nd.flags &= ~LOOKUP_PARENT;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001795 mutex_lock(&dir->d_inode->i_mutex);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001796 path.dentry = lookup_hash(&nd);
1797 path.mnt = nd.path.mnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
1799do_last:
Al Viro4e7506e2005-06-06 13:36:00 -07001800 error = PTR_ERR(path.dentry);
1801 if (IS_ERR(path.dentry)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001802 mutex_unlock(&dir->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 goto exit;
1804 }
1805
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001806 if (IS_ERR(nd.intent.open.file)) {
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001807 error = PTR_ERR(nd.intent.open.file);
Dave Hansen4a3fd212008-02-15 14:37:48 -08001808 goto exit_mutex_unlock;
Oleg Drokin4af4c522006-03-25 03:06:54 -08001809 }
1810
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 /* Negative dentry, just create the file */
Al Viro4e7506e2005-06-06 13:36:00 -07001812 if (!path.dentry->d_inode) {
Dave Hansen4a3fd212008-02-15 14:37:48 -08001813 /*
1814 * This write is needed to ensure that a
1815 * ro->rw transition does not occur between
1816 * the time when the file is created and when
1817 * a permanent write count is taken through
1818 * the 'struct file' in nameidata_to_filp().
1819 */
1820 error = mnt_want_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 if (error)
Dave Hansen4a3fd212008-02-15 14:37:48 -08001822 goto exit_mutex_unlock;
1823 error = __open_namei_create(&nd, &path, flag, mode);
1824 if (error) {
1825 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 goto exit;
Dave Hansen4a3fd212008-02-15 14:37:48 -08001827 }
1828 filp = nameidata_to_filp(&nd, open_flag);
1829 mnt_drop_write(nd.path.mnt);
1830 return filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 }
1832
1833 /*
1834 * It already exists.
1835 */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001836 mutex_unlock(&dir->d_inode->i_mutex);
Al Viro5a190ae2007-06-07 12:19:32 -04001837 audit_inode(pathname, path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
1839 error = -EEXIST;
1840 if (flag & O_EXCL)
1841 goto exit_dput;
1842
Al Viroe13b2102005-06-06 13:36:06 -07001843 if (__follow_mount(&path)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 error = -ELOOP;
Al Viroba7a4c12005-06-06 13:36:08 -07001845 if (flag & O_NOFOLLOW)
1846 goto exit_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 }
Amy Griffis3e2efce2006-07-13 13:16:02 -04001848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 error = -ENOENT;
Al Viro4e7506e2005-06-06 13:36:00 -07001850 if (!path.dentry->d_inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 goto exit_dput;
Al Viro4e7506e2005-06-06 13:36:00 -07001852 if (path.dentry->d_inode->i_op && path.dentry->d_inode->i_op->follow_link)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 goto do_link;
1854
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001855 path_to_nameidata(&path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 error = -EISDIR;
Al Viro4e7506e2005-06-06 13:36:00 -07001857 if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 goto exit;
1859ok:
Dave Hansen4a3fd212008-02-15 14:37:48 -08001860 /*
1861 * Consider:
1862 * 1. may_open() truncates a file
1863 * 2. a rw->ro mount transition occurs
1864 * 3. nameidata_to_filp() fails due to
1865 * the ro mount.
1866 * That would be inconsistent, and should
1867 * be avoided. Taking this mnt write here
1868 * ensures that (2) can not occur.
1869 */
1870 will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode);
1871 if (will_write) {
1872 error = mnt_want_write(nd.path.mnt);
1873 if (error)
1874 goto exit;
1875 }
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001876 error = may_open(&nd, acc_mode, flag);
Dave Hansen4a3fd212008-02-15 14:37:48 -08001877 if (error) {
1878 if (will_write)
1879 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 goto exit;
Dave Hansen4a3fd212008-02-15 14:37:48 -08001881 }
1882 filp = nameidata_to_filp(&nd, open_flag);
1883 /*
1884 * It is now safe to drop the mnt write
1885 * because the filp has had a write taken
1886 * on its behalf.
1887 */
1888 if (will_write)
1889 mnt_drop_write(nd.path.mnt);
1890 return filp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
Dave Hansen4a3fd212008-02-15 14:37:48 -08001892exit_mutex_unlock:
1893 mutex_unlock(&dir->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894exit_dput:
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001895 path_put_conditional(&path, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896exit:
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001897 if (!IS_ERR(nd.intent.open.file))
1898 release_open_intent(&nd);
1899 path_put(&nd.path);
1900 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
1902do_link:
1903 error = -ELOOP;
1904 if (flag & O_NOFOLLOW)
1905 goto exit_dput;
1906 /*
1907 * This is subtle. Instead of calling do_follow_link() we do the
1908 * thing by hands. The reason is that this way we have zero link_count
1909 * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
1910 * After that we have the parent and last component, i.e.
1911 * we are in the same situation as after the first path_walk().
1912 * Well, almost - if the last component is normal we get its copy
1913 * stored in nd->last.name and we will have to putname() it when we
1914 * are done. Procfs-like symlinks just set LAST_BIND.
1915 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001916 nd.flags |= LOOKUP_PARENT;
1917 error = security_inode_follow_link(path.dentry, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 if (error)
1919 goto exit_dput;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001920 error = __do_follow_link(&path, &nd);
Kirill Korotaevde459212006-07-14 00:23:49 -07001921 if (error) {
1922 /* Does someone understand code flow here? Or it is only
1923 * me so stupid? Anathema to whoever designed this non-sense
1924 * with "intent.open".
1925 */
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001926 release_open_intent(&nd);
1927 return ERR_PTR(error);
Kirill Korotaevde459212006-07-14 00:23:49 -07001928 }
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001929 nd.flags &= ~LOOKUP_PARENT;
1930 if (nd.last_type == LAST_BIND)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 goto ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 error = -EISDIR;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001933 if (nd.last_type != LAST_NORM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 goto exit;
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001935 if (nd.last.name[nd.last.len]) {
1936 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 goto exit;
1938 }
1939 error = -ELOOP;
1940 if (count++==32) {
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001941 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 goto exit;
1943 }
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001944 dir = nd.path.dentry;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001945 mutex_lock(&dir->d_inode->i_mutex);
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001946 path.dentry = lookup_hash(&nd);
1947 path.mnt = nd.path.mnt;
1948 __putname(nd.last.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 goto do_last;
1950}
1951
1952/**
Christoph Hellwiga70e65d2008-02-15 14:37:28 -08001953 * filp_open - open file and return file pointer
1954 *
1955 * @filename: path to open
1956 * @flags: open flags as per the open(2) second argument
1957 * @mode: mode for the new file if O_CREAT is set, else ignored
1958 *
1959 * This is the helper to open a file from kernelspace if you really
1960 * have to. But in generally you should not do this, so please move
1961 * along, nothing to see here..
1962 */
1963struct file *filp_open(const char *filename, int flags, int mode)
1964{
1965 return do_filp_open(AT_FDCWD, filename, flags, mode);
1966}
1967EXPORT_SYMBOL(filp_open);
1968
1969/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 * lookup_create - lookup a dentry, creating it if it doesn't exist
1971 * @nd: nameidata info
1972 * @is_dir: directory flag
1973 *
1974 * Simple function to lookup and return a dentry and create it
1975 * if it doesn't exist. Is SMP-safe.
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001976 *
Jan Blunck4ac91372008-02-14 19:34:32 -08001977 * Returns with nd->path.dentry->d_inode->i_mutex locked.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 */
1979struct dentry *lookup_create(struct nameidata *nd, int is_dir)
1980{
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001981 struct dentry *dentry = ERR_PTR(-EEXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982
Jan Blunck4ac91372008-02-14 19:34:32 -08001983 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001984 /*
1985 * Yucky last component or no last component at all?
1986 * (foo/., foo/.., /////)
1987 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 if (nd->last_type != LAST_NORM)
1989 goto fail;
1990 nd->flags &= ~LOOKUP_PARENT;
ASANO Masahiroa6349042006-08-22 20:06:02 -04001991 nd->flags |= LOOKUP_CREATE;
1992 nd->intent.open.flags = O_EXCL;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07001993
1994 /*
1995 * Do the final lookup.
1996 */
Christoph Hellwig49705b72005-11-08 21:35:06 -08001997 dentry = lookup_hash(nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 if (IS_ERR(dentry))
1999 goto fail;
Christoph Hellwigc663e5d2005-06-23 00:09:49 -07002000
2001 /*
2002 * Special case - lookup gave negative, but... we had foo/bar/
2003 * From the vfs_mknod() POV we just have a negative dentry -
2004 * all is fine. Let's be bastards - you had / on the end, you've
2005 * been asking for (non-existent) directory. -ENOENT for you.
2006 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode)
2008 goto enoent;
2009 return dentry;
2010enoent:
2011 dput(dentry);
2012 dentry = ERR_PTR(-ENOENT);
2013fail:
2014 return dentry;
2015}
Christoph Hellwigf81a0bf2005-05-19 12:26:43 -07002016EXPORT_SYMBOL_GPL(lookup_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
2018int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2019{
2020 int error = may_create(dir, dentry, NULL);
2021
2022 if (error)
2023 return error;
2024
2025 if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
2026 return -EPERM;
2027
2028 if (!dir->i_op || !dir->i_op->mknod)
2029 return -EPERM;
2030
2031 error = security_inode_mknod(dir, dentry, mode, dev);
2032 if (error)
2033 return error;
2034
2035 DQUOT_INIT(dir);
2036 error = dir->i_op->mknod(dir, dentry, mode, dev);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002037 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002038 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 return error;
2040}
2041
Dave Hansen463c3192008-02-15 14:37:57 -08002042static int may_mknod(mode_t mode)
2043{
2044 switch (mode & S_IFMT) {
2045 case S_IFREG:
2046 case S_IFCHR:
2047 case S_IFBLK:
2048 case S_IFIFO:
2049 case S_IFSOCK:
2050 case 0: /* zero mode translates to S_IFREG */
2051 return 0;
2052 case S_IFDIR:
2053 return -EPERM;
2054 default:
2055 return -EINVAL;
2056 }
2057}
2058
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002059asmlinkage long sys_mknodat(int dfd, const char __user *filename, int mode,
2060 unsigned dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061{
2062 int error = 0;
2063 char * tmp;
2064 struct dentry * dentry;
2065 struct nameidata nd;
2066
2067 if (S_ISDIR(mode))
2068 return -EPERM;
2069 tmp = getname(filename);
2070 if (IS_ERR(tmp))
2071 return PTR_ERR(tmp);
2072
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002073 error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 if (error)
2075 goto out;
2076 dentry = lookup_create(&nd, 0);
Dave Hansen463c3192008-02-15 14:37:57 -08002077 if (IS_ERR(dentry)) {
2078 error = PTR_ERR(dentry);
2079 goto out_unlock;
2080 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002081 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 mode &= ~current->fs->umask;
Dave Hansen463c3192008-02-15 14:37:57 -08002083 error = may_mknod(mode);
2084 if (error)
2085 goto out_dput;
2086 error = mnt_want_write(nd.path.mnt);
2087 if (error)
2088 goto out_dput;
2089 switch (mode & S_IFMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 case 0: case S_IFREG:
Jan Blunck4ac91372008-02-14 19:34:32 -08002091 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 break;
2093 case S_IFCHR: case S_IFBLK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002094 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 new_decode_dev(dev));
2096 break;
2097 case S_IFIFO: case S_IFSOCK:
Jan Blunck4ac91372008-02-14 19:34:32 -08002098 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 }
Dave Hansen463c3192008-02-15 14:37:57 -08002101 mnt_drop_write(nd.path.mnt);
2102out_dput:
2103 dput(dentry);
2104out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002105 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002106 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107out:
2108 putname(tmp);
2109
2110 return error;
2111}
2112
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002113asmlinkage long sys_mknod(const char __user *filename, int mode, unsigned dev)
2114{
2115 return sys_mknodat(AT_FDCWD, filename, mode, dev);
2116}
2117
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2119{
2120 int error = may_create(dir, dentry, NULL);
2121
2122 if (error)
2123 return error;
2124
2125 if (!dir->i_op || !dir->i_op->mkdir)
2126 return -EPERM;
2127
2128 mode &= (S_IRWXUGO|S_ISVTX);
2129 error = security_inode_mkdir(dir, dentry, mode);
2130 if (error)
2131 return error;
2132
2133 DQUOT_INIT(dir);
2134 error = dir->i_op->mkdir(dir, dentry, mode);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002135 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002136 fsnotify_mkdir(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 return error;
2138}
2139
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002140asmlinkage long sys_mkdirat(int dfd, const char __user *pathname, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141{
2142 int error = 0;
2143 char * tmp;
Dave Hansen6902d922006-09-30 23:29:01 -07002144 struct dentry *dentry;
2145 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
2147 tmp = getname(pathname);
2148 error = PTR_ERR(tmp);
Dave Hansen6902d922006-09-30 23:29:01 -07002149 if (IS_ERR(tmp))
2150 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
Dave Hansen6902d922006-09-30 23:29:01 -07002152 error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
2153 if (error)
2154 goto out;
2155 dentry = lookup_create(&nd, 1);
2156 error = PTR_ERR(dentry);
2157 if (IS_ERR(dentry))
2158 goto out_unlock;
2159
Jan Blunck4ac91372008-02-14 19:34:32 -08002160 if (!IS_POSIXACL(nd.path.dentry->d_inode))
Dave Hansen6902d922006-09-30 23:29:01 -07002161 mode &= ~current->fs->umask;
Dave Hansen463c3192008-02-15 14:37:57 -08002162 error = mnt_want_write(nd.path.mnt);
2163 if (error)
2164 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002165 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
Dave Hansen463c3192008-02-15 14:37:57 -08002166 mnt_drop_write(nd.path.mnt);
2167out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002168 dput(dentry);
2169out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002170 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002171 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172out:
Dave Hansen6902d922006-09-30 23:29:01 -07002173 putname(tmp);
2174out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 return error;
2176}
2177
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002178asmlinkage long sys_mkdir(const char __user *pathname, int mode)
2179{
2180 return sys_mkdirat(AT_FDCWD, pathname, mode);
2181}
2182
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183/*
2184 * We try to drop the dentry early: we should have
2185 * a usage count of 2 if we're the only user of this
2186 * dentry, and if that is true (possibly after pruning
2187 * the dcache), then we drop the dentry now.
2188 *
2189 * A low-level filesystem can, if it choses, legally
2190 * do a
2191 *
2192 * if (!d_unhashed(dentry))
2193 * return -EBUSY;
2194 *
2195 * if it cannot handle the case of removing a directory
2196 * that is still in use by something else..
2197 */
2198void dentry_unhash(struct dentry *dentry)
2199{
2200 dget(dentry);
Vasily Averindc168422006-12-06 20:37:07 -08002201 shrink_dcache_parent(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 spin_lock(&dcache_lock);
2203 spin_lock(&dentry->d_lock);
2204 if (atomic_read(&dentry->d_count) == 2)
2205 __d_drop(dentry);
2206 spin_unlock(&dentry->d_lock);
2207 spin_unlock(&dcache_lock);
2208}
2209
2210int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2211{
2212 int error = may_delete(dir, dentry, 1);
2213
2214 if (error)
2215 return error;
2216
2217 if (!dir->i_op || !dir->i_op->rmdir)
2218 return -EPERM;
2219
2220 DQUOT_INIT(dir);
2221
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002222 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 dentry_unhash(dentry);
2224 if (d_mountpoint(dentry))
2225 error = -EBUSY;
2226 else {
2227 error = security_inode_rmdir(dir, dentry);
2228 if (!error) {
2229 error = dir->i_op->rmdir(dir, dentry);
2230 if (!error)
2231 dentry->d_inode->i_flags |= S_DEAD;
2232 }
2233 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002234 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 d_delete(dentry);
2237 }
2238 dput(dentry);
2239
2240 return error;
2241}
2242
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002243static long do_rmdir(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244{
2245 int error = 0;
2246 char * name;
2247 struct dentry *dentry;
2248 struct nameidata nd;
2249
2250 name = getname(pathname);
2251 if(IS_ERR(name))
2252 return PTR_ERR(name);
2253
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002254 error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 if (error)
2256 goto exit;
2257
2258 switch(nd.last_type) {
2259 case LAST_DOTDOT:
2260 error = -ENOTEMPTY;
2261 goto exit1;
2262 case LAST_DOT:
2263 error = -EINVAL;
2264 goto exit1;
2265 case LAST_ROOT:
2266 error = -EBUSY;
2267 goto exit1;
2268 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002269 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002270 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 error = PTR_ERR(dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07002272 if (IS_ERR(dentry))
2273 goto exit2;
Dave Hansen06227532008-02-15 14:37:34 -08002274 error = mnt_want_write(nd.path.mnt);
2275 if (error)
2276 goto exit3;
Jan Blunck4ac91372008-02-14 19:34:32 -08002277 error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
Dave Hansen06227532008-02-15 14:37:34 -08002278 mnt_drop_write(nd.path.mnt);
2279exit3:
Dave Hansen6902d922006-09-30 23:29:01 -07002280 dput(dentry);
2281exit2:
Jan Blunck4ac91372008-02-14 19:34:32 -08002282 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002284 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285exit:
2286 putname(name);
2287 return error;
2288}
2289
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002290asmlinkage long sys_rmdir(const char __user *pathname)
2291{
2292 return do_rmdir(AT_FDCWD, pathname);
2293}
2294
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295int vfs_unlink(struct inode *dir, struct dentry *dentry)
2296{
2297 int error = may_delete(dir, dentry, 0);
2298
2299 if (error)
2300 return error;
2301
2302 if (!dir->i_op || !dir->i_op->unlink)
2303 return -EPERM;
2304
2305 DQUOT_INIT(dir);
2306
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002307 mutex_lock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 if (d_mountpoint(dentry))
2309 error = -EBUSY;
2310 else {
2311 error = security_inode_unlink(dir, dentry);
2312 if (!error)
2313 error = dir->i_op->unlink(dir, dentry);
2314 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002315 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316
2317 /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2318 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
Jan Karaece95912008-02-06 01:37:13 -08002319 fsnotify_link_count(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 d_delete(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 }
Robert Love0eeca282005-07-12 17:06:03 -04002322
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 return error;
2324}
2325
2326/*
2327 * Make sure that the actual truncation of the file will occur outside its
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002328 * directory's i_mutex. Truncate can take a long time if there is a lot of
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 * writeout happening, and we don't want to prevent access to the directory
2330 * while waiting on the I/O.
2331 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002332static long do_unlinkat(int dfd, const char __user *pathname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333{
2334 int error = 0;
2335 char * name;
2336 struct dentry *dentry;
2337 struct nameidata nd;
2338 struct inode *inode = NULL;
2339
2340 name = getname(pathname);
2341 if(IS_ERR(name))
2342 return PTR_ERR(name);
2343
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002344 error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 if (error)
2346 goto exit;
2347 error = -EISDIR;
2348 if (nd.last_type != LAST_NORM)
2349 goto exit1;
Jan Blunck4ac91372008-02-14 19:34:32 -08002350 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
Christoph Hellwig49705b72005-11-08 21:35:06 -08002351 dentry = lookup_hash(&nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 error = PTR_ERR(dentry);
2353 if (!IS_ERR(dentry)) {
2354 /* Why not before? Because we want correct error value */
2355 if (nd.last.name[nd.last.len])
2356 goto slashes;
2357 inode = dentry->d_inode;
2358 if (inode)
2359 atomic_inc(&inode->i_count);
Dave Hansen06227532008-02-15 14:37:34 -08002360 error = mnt_want_write(nd.path.mnt);
2361 if (error)
2362 goto exit2;
Jan Blunck4ac91372008-02-14 19:34:32 -08002363 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
Dave Hansen06227532008-02-15 14:37:34 -08002364 mnt_drop_write(nd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 exit2:
2366 dput(dentry);
2367 }
Jan Blunck4ac91372008-02-14 19:34:32 -08002368 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 if (inode)
2370 iput(inode); /* truncate the inode here */
2371exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002372 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373exit:
2374 putname(name);
2375 return error;
2376
2377slashes:
2378 error = !dentry->d_inode ? -ENOENT :
2379 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2380 goto exit2;
2381}
2382
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002383asmlinkage long sys_unlinkat(int dfd, const char __user *pathname, int flag)
2384{
2385 if ((flag & ~AT_REMOVEDIR) != 0)
2386 return -EINVAL;
2387
2388 if (flag & AT_REMOVEDIR)
2389 return do_rmdir(dfd, pathname);
2390
2391 return do_unlinkat(dfd, pathname);
2392}
2393
2394asmlinkage long sys_unlink(const char __user *pathname)
2395{
2396 return do_unlinkat(AT_FDCWD, pathname);
2397}
2398
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname, int mode)
2400{
2401 int error = may_create(dir, dentry, NULL);
2402
2403 if (error)
2404 return error;
2405
2406 if (!dir->i_op || !dir->i_op->symlink)
2407 return -EPERM;
2408
2409 error = security_inode_symlink(dir, dentry, oldname);
2410 if (error)
2411 return error;
2412
2413 DQUOT_INIT(dir);
2414 error = dir->i_op->symlink(dir, dentry, oldname);
Stephen Smalleya74574a2005-09-09 13:01:44 -07002415 if (!error)
Amy Griffisf38aa942005-11-03 15:57:06 +00002416 fsnotify_create(dir, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 return error;
2418}
2419
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002420asmlinkage long sys_symlinkat(const char __user *oldname,
2421 int newdfd, const char __user *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422{
2423 int error = 0;
2424 char * from;
2425 char * to;
Dave Hansen6902d922006-09-30 23:29:01 -07002426 struct dentry *dentry;
2427 struct nameidata nd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428
2429 from = getname(oldname);
2430 if(IS_ERR(from))
2431 return PTR_ERR(from);
2432 to = getname(newname);
2433 error = PTR_ERR(to);
Dave Hansen6902d922006-09-30 23:29:01 -07002434 if (IS_ERR(to))
2435 goto out_putname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Dave Hansen6902d922006-09-30 23:29:01 -07002437 error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
2438 if (error)
2439 goto out;
2440 dentry = lookup_create(&nd, 0);
2441 error = PTR_ERR(dentry);
2442 if (IS_ERR(dentry))
2443 goto out_unlock;
2444
Dave Hansen75c3f292008-02-15 14:37:45 -08002445 error = mnt_want_write(nd.path.mnt);
2446 if (error)
2447 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002448 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from, S_IALLUGO);
Dave Hansen75c3f292008-02-15 14:37:45 -08002449 mnt_drop_write(nd.path.mnt);
2450out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002451 dput(dentry);
2452out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002453 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Jan Blunck1d957f92008-02-14 19:34:35 -08002454 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455out:
Dave Hansen6902d922006-09-30 23:29:01 -07002456 putname(to);
2457out_putname:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 putname(from);
2459 return error;
2460}
2461
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002462asmlinkage long sys_symlink(const char __user *oldname, const char __user *newname)
2463{
2464 return sys_symlinkat(oldname, AT_FDCWD, newname);
2465}
2466
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2468{
2469 struct inode *inode = old_dentry->d_inode;
2470 int error;
2471
2472 if (!inode)
2473 return -ENOENT;
2474
2475 error = may_create(dir, new_dentry, NULL);
2476 if (error)
2477 return error;
2478
2479 if (dir->i_sb != inode->i_sb)
2480 return -EXDEV;
2481
2482 /*
2483 * A link to an append-only or immutable file cannot be created.
2484 */
2485 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2486 return -EPERM;
2487 if (!dir->i_op || !dir->i_op->link)
2488 return -EPERM;
2489 if (S_ISDIR(old_dentry->d_inode->i_mode))
2490 return -EPERM;
2491
2492 error = security_inode_link(old_dentry, dir, new_dentry);
2493 if (error)
2494 return error;
2495
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002496 mutex_lock(&old_dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 DQUOT_INIT(dir);
2498 error = dir->i_op->link(old_dentry, dir, new_dentry);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002499 mutex_unlock(&old_dentry->d_inode->i_mutex);
Stephen Smalleye31e14e2005-09-09 13:01:45 -07002500 if (!error)
Jan Karaece95912008-02-06 01:37:13 -08002501 fsnotify_link(dir, old_dentry->d_inode, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502 return error;
2503}
2504
2505/*
2506 * Hardlinks are often used in delicate situations. We avoid
2507 * security-related surprises by not following symlinks on the
2508 * newname. --KAB
2509 *
2510 * We don't follow them on the oldname either to be compatible
2511 * with linux 2.0, and to avoid hard-linking to directories
2512 * and other special files. --ADM
2513 */
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002514asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002515 int newdfd, const char __user *newname,
2516 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517{
2518 struct dentry *new_dentry;
2519 struct nameidata nd, old_nd;
2520 int error;
2521 char * to;
2522
Ulrich Drepper45c9b112006-06-25 05:49:11 -07002523 if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002524 return -EINVAL;
2525
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 to = getname(newname);
2527 if (IS_ERR(to))
2528 return PTR_ERR(to);
2529
Ulrich Drepper45c9b112006-06-25 05:49:11 -07002530 error = __user_walk_fd(olddfd, oldname,
2531 flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
2532 &old_nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533 if (error)
2534 goto exit;
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002535 error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 if (error)
2537 goto out;
2538 error = -EXDEV;
Jan Blunck4ac91372008-02-14 19:34:32 -08002539 if (old_nd.path.mnt != nd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 goto out_release;
2541 new_dentry = lookup_create(&nd, 0);
2542 error = PTR_ERR(new_dentry);
Dave Hansen6902d922006-09-30 23:29:01 -07002543 if (IS_ERR(new_dentry))
2544 goto out_unlock;
Dave Hansen75c3f292008-02-15 14:37:45 -08002545 error = mnt_want_write(nd.path.mnt);
2546 if (error)
2547 goto out_dput;
Jan Blunck4ac91372008-02-14 19:34:32 -08002548 error = vfs_link(old_nd.path.dentry, nd.path.dentry->d_inode, new_dentry);
Dave Hansen75c3f292008-02-15 14:37:45 -08002549 mnt_drop_write(nd.path.mnt);
2550out_dput:
Dave Hansen6902d922006-09-30 23:29:01 -07002551 dput(new_dentry);
2552out_unlock:
Jan Blunck4ac91372008-02-14 19:34:32 -08002553 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554out_release:
Jan Blunck1d957f92008-02-14 19:34:35 -08002555 path_put(&nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556out:
Jan Blunck1d957f92008-02-14 19:34:35 -08002557 path_put(&old_nd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558exit:
2559 putname(to);
2560
2561 return error;
2562}
2563
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002564asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
2565{
Ulrich Drepperc04030e2006-02-24 13:04:21 -08002566 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002567}
2568
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569/*
2570 * The worst of all namespace operations - renaming directory. "Perverted"
2571 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2572 * Problems:
2573 * a) we can get into loop creation. Check is done in is_subdir().
2574 * b) race potential - two innocent renames can create a loop together.
2575 * That's where 4.4 screws up. Current fix: serialization on
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002576 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 * story.
2578 * c) we have to lock _three_ objects - parents and victim (if it exists).
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002579 * And that - after we got ->i_mutex on parents (until then we don't know
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 * whether the target exists). Solution: try to be smart with locking
2581 * order for inodes. We rely on the fact that tree topology may change
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002582 * only under ->s_vfs_rename_mutex _and_ that parent of the object we
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 * move will be locked. Thus we can rank directories by the tree
2584 * (ancestors first) and rank all non-directories after them.
2585 * That works since everybody except rename does "lock parent, lookup,
Arjan van de Vena11f3a02006-03-23 03:00:33 -08002586 * lock child" and rename is under ->s_vfs_rename_mutex.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587 * HOWEVER, it relies on the assumption that any object with ->lookup()
2588 * has no more than 1 dentry. If "hybrid" objects will ever appear,
2589 * we'd better make sure that there's no link(2) for them.
2590 * d) some filesystems don't support opened-but-unlinked directories,
2591 * either because of layout or because they are not ready to deal with
2592 * all cases correctly. The latter will be fixed (taking this sort of
2593 * stuff into VFS), but the former is not going away. Solution: the same
2594 * trick as in rmdir().
2595 * e) conversion from fhandle to dentry may come in the wrong moment - when
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002596 * we are removing the target. Solution: we will have to grab ->i_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002598 * ->i_mutex on parents, which works but leads to some truely excessive
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 * locking].
2600 */
Adrian Bunk75c96f82005-05-05 16:16:09 -07002601static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2602 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603{
2604 int error = 0;
2605 struct inode *target;
2606
2607 /*
2608 * If we are going to change the parent - check write permissions,
2609 * we'll need to flip '..'.
2610 */
2611 if (new_dir != old_dir) {
2612 error = permission(old_dentry->d_inode, MAY_WRITE, NULL);
2613 if (error)
2614 return error;
2615 }
2616
2617 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2618 if (error)
2619 return error;
2620
2621 target = new_dentry->d_inode;
2622 if (target) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002623 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 dentry_unhash(new_dentry);
2625 }
2626 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2627 error = -EBUSY;
2628 else
2629 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2630 if (target) {
2631 if (!error)
2632 target->i_flags |= S_DEAD;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002633 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634 if (d_unhashed(new_dentry))
2635 d_rehash(new_dentry);
2636 dput(new_dentry);
2637 }
Stephen Smalleye31e14e2005-09-09 13:01:45 -07002638 if (!error)
Mark Fasheh349457c2006-09-08 14:22:21 -07002639 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2640 d_move(old_dentry,new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 return error;
2642}
2643
Adrian Bunk75c96f82005-05-05 16:16:09 -07002644static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
2645 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646{
2647 struct inode *target;
2648 int error;
2649
2650 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2651 if (error)
2652 return error;
2653
2654 dget(new_dentry);
2655 target = new_dentry->d_inode;
2656 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002657 mutex_lock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2659 error = -EBUSY;
2660 else
2661 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2662 if (!error) {
Mark Fasheh349457c2006-09-08 14:22:21 -07002663 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 d_move(old_dentry, new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 }
2666 if (target)
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002667 mutex_unlock(&target->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 dput(new_dentry);
2669 return error;
2670}
2671
2672int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2673 struct inode *new_dir, struct dentry *new_dentry)
2674{
2675 int error;
2676 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
Robert Love0eeca282005-07-12 17:06:03 -04002677 const char *old_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678
2679 if (old_dentry->d_inode == new_dentry->d_inode)
2680 return 0;
2681
2682 error = may_delete(old_dir, old_dentry, is_dir);
2683 if (error)
2684 return error;
2685
2686 if (!new_dentry->d_inode)
2687 error = may_create(new_dir, new_dentry, NULL);
2688 else
2689 error = may_delete(new_dir, new_dentry, is_dir);
2690 if (error)
2691 return error;
2692
2693 if (!old_dir->i_op || !old_dir->i_op->rename)
2694 return -EPERM;
2695
2696 DQUOT_INIT(old_dir);
2697 DQUOT_INIT(new_dir);
2698
Robert Love0eeca282005-07-12 17:06:03 -04002699 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2700
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 if (is_dir)
2702 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
2703 else
2704 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
2705 if (!error) {
Robert Love0eeca282005-07-12 17:06:03 -04002706 const char *new_name = old_dentry->d_name.name;
John McCutchan89204c42005-08-15 12:13:28 -04002707 fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir,
Al Viro5a190ae2007-06-07 12:19:32 -04002708 new_dentry->d_inode, old_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709 }
Robert Love0eeca282005-07-12 17:06:03 -04002710 fsnotify_oldname_free(old_name);
2711
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 return error;
2713}
2714
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002715static int do_rename(int olddfd, const char *oldname,
2716 int newdfd, const char *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717{
2718 int error = 0;
2719 struct dentry * old_dir, * new_dir;
2720 struct dentry * old_dentry, *new_dentry;
2721 struct dentry * trap;
2722 struct nameidata oldnd, newnd;
2723
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002724 error = do_path_lookup(olddfd, oldname, LOOKUP_PARENT, &oldnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 if (error)
2726 goto exit;
2727
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002728 error = do_path_lookup(newdfd, newname, LOOKUP_PARENT, &newnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 if (error)
2730 goto exit1;
2731
2732 error = -EXDEV;
Jan Blunck4ac91372008-02-14 19:34:32 -08002733 if (oldnd.path.mnt != newnd.path.mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734 goto exit2;
2735
Jan Blunck4ac91372008-02-14 19:34:32 -08002736 old_dir = oldnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 error = -EBUSY;
2738 if (oldnd.last_type != LAST_NORM)
2739 goto exit2;
2740
Jan Blunck4ac91372008-02-14 19:34:32 -08002741 new_dir = newnd.path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 if (newnd.last_type != LAST_NORM)
2743 goto exit2;
2744
2745 trap = lock_rename(new_dir, old_dir);
2746
Christoph Hellwig49705b72005-11-08 21:35:06 -08002747 old_dentry = lookup_hash(&oldnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 error = PTR_ERR(old_dentry);
2749 if (IS_ERR(old_dentry))
2750 goto exit3;
2751 /* source must exist */
2752 error = -ENOENT;
2753 if (!old_dentry->d_inode)
2754 goto exit4;
2755 /* unless the source is a directory trailing slashes give -ENOTDIR */
2756 if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
2757 error = -ENOTDIR;
2758 if (oldnd.last.name[oldnd.last.len])
2759 goto exit4;
2760 if (newnd.last.name[newnd.last.len])
2761 goto exit4;
2762 }
2763 /* source should not be ancestor of target */
2764 error = -EINVAL;
2765 if (old_dentry == trap)
2766 goto exit4;
Christoph Hellwig49705b72005-11-08 21:35:06 -08002767 new_dentry = lookup_hash(&newnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 error = PTR_ERR(new_dentry);
2769 if (IS_ERR(new_dentry))
2770 goto exit4;
2771 /* target should not be an ancestor of source */
2772 error = -ENOTEMPTY;
2773 if (new_dentry == trap)
2774 goto exit5;
2775
Dave Hansen9079b1e2008-02-15 14:37:49 -08002776 error = mnt_want_write(oldnd.path.mnt);
2777 if (error)
2778 goto exit5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 error = vfs_rename(old_dir->d_inode, old_dentry,
2780 new_dir->d_inode, new_dentry);
Dave Hansen9079b1e2008-02-15 14:37:49 -08002781 mnt_drop_write(oldnd.path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782exit5:
2783 dput(new_dentry);
2784exit4:
2785 dput(old_dentry);
2786exit3:
2787 unlock_rename(new_dir, old_dir);
2788exit2:
Jan Blunck1d957f92008-02-14 19:34:35 -08002789 path_put(&newnd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790exit1:
Jan Blunck1d957f92008-02-14 19:34:35 -08002791 path_put(&oldnd.path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792exit:
2793 return error;
2794}
2795
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002796asmlinkage long sys_renameat(int olddfd, const char __user *oldname,
2797 int newdfd, const char __user *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798{
2799 int error;
2800 char * from;
2801 char * to;
2802
2803 from = getname(oldname);
2804 if(IS_ERR(from))
2805 return PTR_ERR(from);
2806 to = getname(newname);
2807 error = PTR_ERR(to);
2808 if (!IS_ERR(to)) {
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002809 error = do_rename(olddfd, from, newdfd, to);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 putname(to);
2811 }
2812 putname(from);
2813 return error;
2814}
2815
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002816asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)
2817{
2818 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
2819}
2820
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
2822{
2823 int len;
2824
2825 len = PTR_ERR(link);
2826 if (IS_ERR(link))
2827 goto out;
2828
2829 len = strlen(link);
2830 if (len > (unsigned) buflen)
2831 len = buflen;
2832 if (copy_to_user(buffer, link, len))
2833 len = -EFAULT;
2834out:
2835 return len;
2836}
2837
2838/*
2839 * A helper for ->readlink(). This should be used *ONLY* for symlinks that
2840 * have ->follow_link() touching nd only in nd_set_link(). Using (or not
2841 * using) it for any given inode is up to filesystem.
2842 */
2843int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2844{
2845 struct nameidata nd;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002846 void *cookie;
2847
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 nd.depth = 0;
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002849 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2850 if (!IS_ERR(cookie)) {
2851 int res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 if (dentry->d_inode->i_op->put_link)
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002853 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
2854 cookie = ERR_PTR(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 }
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002856 return PTR_ERR(cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857}
2858
2859int vfs_follow_link(struct nameidata *nd, const char *link)
2860{
2861 return __vfs_follow_link(nd, link);
2862}
2863
2864/* get the link contents into pagecache */
2865static char *page_getlink(struct dentry * dentry, struct page **ppage)
2866{
2867 struct page * page;
2868 struct address_space *mapping = dentry->d_inode->i_mapping;
Pekka Enberg090d2b12006-06-23 02:05:08 -07002869 page = read_mapping_page(mapping, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 if (IS_ERR(page))
Nick Piggin6fe69002007-05-06 14:49:04 -07002871 return (char*)page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 *ppage = page;
2873 return kmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874}
2875
2876int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2877{
2878 struct page *page = NULL;
2879 char *s = page_getlink(dentry, &page);
2880 int res = vfs_readlink(dentry,buffer,buflen,s);
2881 if (page) {
2882 kunmap(page);
2883 page_cache_release(page);
2884 }
2885 return res;
2886}
2887
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002888void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002890 struct page *page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 nd_set_link(nd, page_getlink(dentry, &page));
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002892 return page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893}
2894
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002895void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896{
Linus Torvaldscc314ee2005-08-19 18:02:56 -07002897 struct page *page = cookie;
2898
2899 if (page) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 kunmap(page);
2901 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 }
2903}
2904
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002905int __page_symlink(struct inode *inode, const char *symname, int len,
2906 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907{
2908 struct address_space *mapping = inode->i_mapping;
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002909 struct page *page;
Nick Pigginafddba42007-10-16 01:25:01 -07002910 void *fsdata;
Dmitriy Monakhovbeb497a2007-02-16 01:27:18 -08002911 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 char *kaddr;
2913
NeilBrown7e53cac2006-03-25 03:07:57 -08002914retry:
Nick Pigginafddba42007-10-16 01:25:01 -07002915 err = pagecache_write_begin(NULL, mapping, 0, len-1,
2916 AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 if (err)
Nick Pigginafddba42007-10-16 01:25:01 -07002918 goto fail;
2919
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 kaddr = kmap_atomic(page, KM_USER0);
2921 memcpy(kaddr, symname, len-1);
2922 kunmap_atomic(kaddr, KM_USER0);
Nick Pigginafddba42007-10-16 01:25:01 -07002923
2924 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
2925 page, fsdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 if (err < 0)
2927 goto fail;
Nick Pigginafddba42007-10-16 01:25:01 -07002928 if (err < len-1)
2929 goto retry;
2930
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931 mark_inode_dirty(inode);
2932 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933fail:
2934 return err;
2935}
2936
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002937int page_symlink(struct inode *inode, const char *symname, int len)
2938{
2939 return __page_symlink(inode, symname, len,
2940 mapping_gfp_mask(inode->i_mapping));
2941}
2942
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002943const struct inode_operations page_symlink_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 .readlink = generic_readlink,
2945 .follow_link = page_follow_link_light,
2946 .put_link = page_put_link,
2947};
2948
2949EXPORT_SYMBOL(__user_walk);
Ulrich Drepper5590ff02006-01-18 17:43:53 -08002950EXPORT_SYMBOL(__user_walk_fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951EXPORT_SYMBOL(follow_down);
2952EXPORT_SYMBOL(follow_up);
2953EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
2954EXPORT_SYMBOL(getname);
2955EXPORT_SYMBOL(lock_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956EXPORT_SYMBOL(lookup_one_len);
2957EXPORT_SYMBOL(page_follow_link_light);
2958EXPORT_SYMBOL(page_put_link);
2959EXPORT_SYMBOL(page_readlink);
Kirill Korotaev0adb25d2006-03-11 03:27:13 -08002960EXPORT_SYMBOL(__page_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961EXPORT_SYMBOL(page_symlink);
2962EXPORT_SYMBOL(page_symlink_inode_operations);
2963EXPORT_SYMBOL(path_lookup);
Josef 'Jeff' Sipek16f18202007-07-19 01:48:18 -07002964EXPORT_SYMBOL(vfs_path_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965EXPORT_SYMBOL(permission);
Christoph Hellwige4543ed2005-11-08 21:35:04 -08002966EXPORT_SYMBOL(vfs_permission);
Christoph Hellwig8c744fb2005-11-08 21:35:04 -08002967EXPORT_SYMBOL(file_permission);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968EXPORT_SYMBOL(unlock_rename);
2969EXPORT_SYMBOL(vfs_create);
2970EXPORT_SYMBOL(vfs_follow_link);
2971EXPORT_SYMBOL(vfs_link);
2972EXPORT_SYMBOL(vfs_mkdir);
2973EXPORT_SYMBOL(vfs_mknod);
2974EXPORT_SYMBOL(generic_permission);
2975EXPORT_SYMBOL(vfs_readlink);
2976EXPORT_SYMBOL(vfs_rename);
2977EXPORT_SYMBOL(vfs_rmdir);
2978EXPORT_SYMBOL(vfs_symlink);
2979EXPORT_SYMBOL(vfs_unlink);
2980EXPORT_SYMBOL(dentry_unhash);
2981EXPORT_SYMBOL(generic_readlink);