Root/
1 | /* |
2 | * linux/fs/namei.c |
3 | * |
4 | * Copyright (C) 1991, 1992 Linus Torvalds |
5 | */ |
6 | |
7 | /* |
8 | * Some corrections by tytso. |
9 | */ |
10 | |
11 | /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname |
12 | * lookup logic. |
13 | */ |
14 | /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture. |
15 | */ |
16 | |
17 | #include <linux/init.h> |
18 | #include <linux/module.h> |
19 | #include <linux/slab.h> |
20 | #include <linux/fs.h> |
21 | #include <linux/namei.h> |
22 | #include <linux/pagemap.h> |
23 | #include <linux/fsnotify.h> |
24 | #include <linux/personality.h> |
25 | #include <linux/security.h> |
26 | #include <linux/ima.h> |
27 | #include <linux/syscalls.h> |
28 | #include <linux/mount.h> |
29 | #include <linux/audit.h> |
30 | #include <linux/capability.h> |
31 | #include <linux/file.h> |
32 | #include <linux/fcntl.h> |
33 | #include <linux/device_cgroup.h> |
34 | #include <linux/fs_struct.h> |
35 | #include <asm/uaccess.h> |
36 | |
37 | #include "internal.h" |
38 | |
39 | /* [Feb-1997 T. Schoebel-Theuer] |
40 | * Fundamental changes in the pathname lookup mechanisms (namei) |
41 | * were necessary because of omirr. The reason is that omirr needs |
42 | * to know the _real_ pathname, not the user-supplied one, in case |
43 | * of symlinks (and also when transname replacements occur). |
44 | * |
45 | * The new code replaces the old recursive symlink resolution with |
46 | * an iterative one (in case of non-nested symlink chains). It does |
47 | * this with calls to <fs>_follow_link(). |
48 | * As a side effect, dir_namei(), _namei() and follow_link() are now |
49 | * replaced with a single function lookup_dentry() that can handle all |
50 | * the special cases of the former code. |
51 | * |
52 | * With the new dcache, the pathname is stored at each inode, at least as |
53 | * long as the refcount of the inode is positive. As a side effect, the |
54 | * size of the dcache depends on the inode cache and thus is dynamic. |
55 | * |
56 | * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink |
57 | * resolution to correspond with current state of the code. |
58 | * |
59 | * Note that the symlink resolution is not *completely* iterative. |
60 | * There is still a significant amount of tail- and mid- recursion in |
61 | * the algorithm. Also, note that <fs>_readlink() is not used in |
62 | * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink() |
63 | * may return different results than <fs>_follow_link(). Many virtual |
64 | * filesystems (including /proc) exhibit this behavior. |
65 | */ |
66 | |
67 | /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation: |
68 | * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL |
69 | * and the name already exists in form of a symlink, try to create the new |
70 | * name indicated by the symlink. The old code always complained that the |
71 | * name already exists, due to not following the symlink even if its target |
72 | * is nonexistent. The new semantics affects also mknod() and link() when |
73 | * the name is a symlink pointing to a non-existant name. |
74 | * |
75 | * I don't know which semantics is the right one, since I have no access |
76 | * to standards. But I found by trial that HP-UX 9.0 has the full "new" |
77 | * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the |
78 | * "old" one. Personally, I think the new semantics is much more logical. |
79 | * Note that "ln old new" where "new" is a symlink pointing to a non-existing |
80 | * file does succeed in both HP-UX and SunOs, but not in Solaris |
81 | * and in the old Linux semantics. |
82 | */ |
83 | |
84 | /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink |
85 | * semantics. See the comments in "open_namei" and "do_link" below. |
86 | * |
87 | * [10-Sep-98 Alan Modra] Another symlink change. |
88 | */ |
89 | |
90 | /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks: |
91 | * inside the path - always follow. |
92 | * in the last component in creation/removal/renaming - never follow. |
93 | * if LOOKUP_FOLLOW passed - follow. |
94 | * if the pathname has trailing slashes - follow. |
95 | * otherwise - don't follow. |
96 | * (applied in that order). |
97 | * |
98 | * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT |
99 | * restored for 2.4. This is the last surviving part of old 4.2BSD bug. |
100 | * During the 2.4 we need to fix the userland stuff depending on it - |
101 | * hopefully we will be able to get rid of that wart in 2.5. So far only |
102 | * XEmacs seems to be relying on it... |
103 | */ |
104 | /* |
105 | * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland) |
106 | * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives |
107 | * any extra contention... |
108 | */ |
109 | |
110 | /* In order to reduce some races, while at the same time doing additional |
111 | * checking and hopefully speeding things up, we copy filenames to the |
112 | * kernel data space before using them.. |
113 | * |
114 | * POSIX.1 2.4: an empty pathname is invalid (ENOENT). |
115 | * PATH_MAX includes the nul terminator --RR. |
116 | */ |
117 | static int do_getname(const char __user *filename, char *page) |
118 | { |
119 | int retval; |
120 | unsigned long len = PATH_MAX; |
121 | |
122 | if (!segment_eq(get_fs(), KERNEL_DS)) { |
123 | if ((unsigned long) filename >= TASK_SIZE) |
124 | return -EFAULT; |
125 | if (TASK_SIZE - (unsigned long) filename < PATH_MAX) |
126 | len = TASK_SIZE - (unsigned long) filename; |
127 | } |
128 | |
129 | retval = strncpy_from_user(page, filename, len); |
130 | if (retval > 0) { |
131 | if (retval < len) |
132 | return 0; |
133 | return -ENAMETOOLONG; |
134 | } else if (!retval) |
135 | retval = -ENOENT; |
136 | return retval; |
137 | } |
138 | |
139 | char * getname(const char __user * filename) |
140 | { |
141 | char *tmp, *result; |
142 | |
143 | result = ERR_PTR(-ENOMEM); |
144 | tmp = __getname(); |
145 | if (tmp) { |
146 | int retval = do_getname(filename, tmp); |
147 | |
148 | result = tmp; |
149 | if (retval < 0) { |
150 | __putname(tmp); |
151 | result = ERR_PTR(retval); |
152 | } |
153 | } |
154 | audit_getname(result); |
155 | return result; |
156 | } |
157 | |
158 | #ifdef CONFIG_AUDITSYSCALL |
159 | void putname(const char *name) |
160 | { |
161 | if (unlikely(!audit_dummy_context())) |
162 | audit_putname(name); |
163 | else |
164 | __putname(name); |
165 | } |
166 | EXPORT_SYMBOL(putname); |
167 | #endif |
168 | |
169 | /* |
170 | * This does basic POSIX ACL permission checking |
171 | */ |
172 | static int acl_permission_check(struct inode *inode, int mask, |
173 | int (*check_acl)(struct inode *inode, int mask)) |
174 | { |
175 | umode_t mode = inode->i_mode; |
176 | |
177 | mask &= MAY_READ | MAY_WRITE | MAY_EXEC; |
178 | |
179 | if (current_fsuid() == inode->i_uid) |
180 | mode >>= 6; |
181 | else { |
182 | if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) { |
183 | int error = check_acl(inode, mask); |
184 | if (error != -EAGAIN) |
185 | return error; |
186 | } |
187 | |
188 | if (in_group_p(inode->i_gid)) |
189 | mode >>= 3; |
190 | } |
191 | |
192 | /* |
193 | * If the DACs are ok we don't need any capability check. |
194 | */ |
195 | if ((mask & ~mode) == 0) |
196 | return 0; |
197 | return -EACCES; |
198 | } |
199 | |
200 | /** |
201 | * generic_permission - check for access rights on a Posix-like filesystem |
202 | * @inode: inode to check access rights for |
203 | * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) |
204 | * @check_acl: optional callback to check for Posix ACLs |
205 | * |
206 | * Used to check for read/write/execute permissions on a file. |
207 | * We use "fsuid" for this, letting us set arbitrary permissions |
208 | * for filesystem access without changing the "normal" uids which |
209 | * are used for other things.. |
210 | */ |
211 | int generic_permission(struct inode *inode, int mask, |
212 | int (*check_acl)(struct inode *inode, int mask)) |
213 | { |
214 | int ret; |
215 | |
216 | /* |
217 | * Do the basic POSIX ACL permission checks. |
218 | */ |
219 | ret = acl_permission_check(inode, mask, check_acl); |
220 | if (ret != -EACCES) |
221 | return ret; |
222 | |
223 | /* |
224 | * Read/write DACs are always overridable. |
225 | * Executable DACs are overridable if at least one exec bit is set. |
226 | */ |
227 | if (!(mask & MAY_EXEC) || execute_ok(inode)) |
228 | if (capable(CAP_DAC_OVERRIDE)) |
229 | return 0; |
230 | |
231 | /* |
232 | * Searching includes executable on directories, else just read. |
233 | */ |
234 | mask &= MAY_READ | MAY_WRITE | MAY_EXEC; |
235 | if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))) |
236 | if (capable(CAP_DAC_READ_SEARCH)) |
237 | return 0; |
238 | |
239 | return -EACCES; |
240 | } |
241 | |
242 | /** |
243 | * inode_permission - check for access rights to a given inode |
244 | * @inode: inode to check permission on |
245 | * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) |
246 | * |
247 | * Used to check for read/write/execute permissions on an inode. |
248 | * We use "fsuid" for this, letting us set arbitrary permissions |
249 | * for filesystem access without changing the "normal" uids which |
250 | * are used for other things. |
251 | */ |
252 | int inode_permission(struct inode *inode, int mask) |
253 | { |
254 | int retval; |
255 | |
256 | if (mask & MAY_WRITE) { |
257 | umode_t mode = inode->i_mode; |
258 | |
259 | /* |
260 | * Nobody gets write access to a read-only fs. |
261 | */ |
262 | if (IS_RDONLY(inode) && |
263 | (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) |
264 | return -EROFS; |
265 | |
266 | /* |
267 | * Nobody gets write access to an immutable file. |
268 | */ |
269 | if (IS_IMMUTABLE(inode)) |
270 | return -EACCES; |
271 | } |
272 | |
273 | if (inode->i_op->permission) |
274 | retval = inode->i_op->permission(inode, mask); |
275 | else |
276 | retval = generic_permission(inode, mask, inode->i_op->check_acl); |
277 | |
278 | if (retval) |
279 | return retval; |
280 | |
281 | retval = devcgroup_inode_permission(inode, mask); |
282 | if (retval) |
283 | return retval; |
284 | |
285 | return security_inode_permission(inode, |
286 | mask & (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND)); |
287 | } |
288 | |
289 | /** |
290 | * file_permission - check for additional access rights to a given file |
291 | * @file: file to check access rights for |
292 | * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) |
293 | * |
294 | * Used to check for read/write/execute permissions on an already opened |
295 | * file. |
296 | * |
297 | * Note: |
298 | * Do not use this function in new code. All access checks should |
299 | * be done using inode_permission(). |
300 | */ |
301 | int file_permission(struct file *file, int mask) |
302 | { |
303 | return inode_permission(file->f_path.dentry->d_inode, mask); |
304 | } |
305 | |
306 | /* |
307 | * get_write_access() gets write permission for a file. |
308 | * put_write_access() releases this write permission. |
309 | * This is used for regular files. |
310 | * We cannot support write (and maybe mmap read-write shared) accesses and |
311 | * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode |
312 | * can have the following values: |
313 | * 0: no writers, no VM_DENYWRITE mappings |
314 | * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist |
315 | * > 0: (i_writecount) users are writing to the file. |
316 | * |
317 | * Normally we operate on that counter with atomic_{inc,dec} and it's safe |
318 | * except for the cases where we don't hold i_writecount yet. Then we need to |
319 | * use {get,deny}_write_access() - these functions check the sign and refuse |
320 | * to do the change if sign is wrong. Exclusion between them is provided by |
321 | * the inode->i_lock spinlock. |
322 | */ |
323 | |
324 | int get_write_access(struct inode * inode) |
325 | { |
326 | spin_lock(&inode->i_lock); |
327 | if (atomic_read(&inode->i_writecount) < 0) { |
328 | spin_unlock(&inode->i_lock); |
329 | return -ETXTBSY; |
330 | } |
331 | atomic_inc(&inode->i_writecount); |
332 | spin_unlock(&inode->i_lock); |
333 | |
334 | return 0; |
335 | } |
336 | |
337 | int deny_write_access(struct file * file) |
338 | { |
339 | struct inode *inode = file->f_path.dentry->d_inode; |
340 | |
341 | spin_lock(&inode->i_lock); |
342 | if (atomic_read(&inode->i_writecount) > 0) { |
343 | spin_unlock(&inode->i_lock); |
344 | return -ETXTBSY; |
345 | } |
346 | atomic_dec(&inode->i_writecount); |
347 | spin_unlock(&inode->i_lock); |
348 | |
349 | return 0; |
350 | } |
351 | |
352 | /** |
353 | * path_get - get a reference to a path |
354 | * @path: path to get the reference to |
355 | * |
356 | * Given a path increment the reference count to the dentry and the vfsmount. |
357 | */ |
358 | void path_get(struct path *path) |
359 | { |
360 | mntget(path->mnt); |
361 | dget(path->dentry); |
362 | } |
363 | EXPORT_SYMBOL(path_get); |
364 | |
365 | /** |
366 | * path_put - put a reference to a path |
367 | * @path: path to put the reference to |
368 | * |
369 | * Given a path decrement the reference count to the dentry and the vfsmount. |
370 | */ |
371 | void path_put(struct path *path) |
372 | { |
373 | dput(path->dentry); |
374 | mntput(path->mnt); |
375 | } |
376 | EXPORT_SYMBOL(path_put); |
377 | |
378 | /** |
379 | * release_open_intent - free up open intent resources |
380 | * @nd: pointer to nameidata |
381 | */ |
382 | void release_open_intent(struct nameidata *nd) |
383 | { |
384 | if (nd->intent.open.file->f_path.dentry == NULL) |
385 | put_filp(nd->intent.open.file); |
386 | else |
387 | fput(nd->intent.open.file); |
388 | } |
389 | |
390 | static inline struct dentry * |
391 | do_revalidate(struct dentry *dentry, struct nameidata *nd) |
392 | { |
393 | int status = dentry->d_op->d_revalidate(dentry, nd); |
394 | if (unlikely(status <= 0)) { |
395 | /* |
396 | * The dentry failed validation. |
397 | * If d_revalidate returned 0 attempt to invalidate |
398 | * the dentry otherwise d_revalidate is asking us |
399 | * to return a fail status. |
400 | */ |
401 | if (!status) { |
402 | if (!d_invalidate(dentry)) { |
403 | dput(dentry); |
404 | dentry = NULL; |
405 | } |
406 | } else { |
407 | dput(dentry); |
408 | dentry = ERR_PTR(status); |
409 | } |
410 | } |
411 | return dentry; |
412 | } |
413 | |
414 | /* |
415 | * force_reval_path - force revalidation of a dentry |
416 | * |
417 | * In some situations the path walking code will trust dentries without |
418 | * revalidating them. This causes problems for filesystems that depend on |
419 | * d_revalidate to handle file opens (e.g. NFSv4). When FS_REVAL_DOT is set |
420 | * (which indicates that it's possible for the dentry to go stale), force |
421 | * a d_revalidate call before proceeding. |
422 | * |
423 | * Returns 0 if the revalidation was successful. If the revalidation fails, |
424 | * either return the error returned by d_revalidate or -ESTALE if the |
425 | * revalidation it just returned 0. If d_revalidate returns 0, we attempt to |
426 | * invalidate the dentry. It's up to the caller to handle putting references |
427 | * to the path if necessary. |
428 | */ |
429 | static int |
430 | force_reval_path(struct path *path, struct nameidata *nd) |
431 | { |
432 | int status; |
433 | struct dentry *dentry = path->dentry; |
434 | |
435 | /* |
436 | * only check on filesystems where it's possible for the dentry to |
437 | * become stale. It's assumed that if this flag is set then the |
438 | * d_revalidate op will also be defined. |
439 | */ |
440 | if (!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) |
441 | return 0; |
442 | |
443 | status = dentry->d_op->d_revalidate(dentry, nd); |
444 | if (status > 0) |
445 | return 0; |
446 | |
447 | if (!status) { |
448 | d_invalidate(dentry); |
449 | status = -ESTALE; |
450 | } |
451 | return status; |
452 | } |
453 | |
454 | /* |
455 | * Short-cut version of permission(), for calling on directories |
456 | * during pathname resolution. Combines parts of permission() |
457 | * and generic_permission(), and tests ONLY for MAY_EXEC permission. |
458 | * |
459 | * If appropriate, check DAC only. If not appropriate, or |
460 | * short-cut DAC fails, then call ->permission() to do more |
461 | * complete permission check. |
462 | */ |
463 | static int exec_permission(struct inode *inode) |
464 | { |
465 | int ret; |
466 | |
467 | if (inode->i_op->permission) { |
468 | ret = inode->i_op->permission(inode, MAY_EXEC); |
469 | if (!ret) |
470 | goto ok; |
471 | return ret; |
472 | } |
473 | ret = acl_permission_check(inode, MAY_EXEC, inode->i_op->check_acl); |
474 | if (!ret) |
475 | goto ok; |
476 | |
477 | if (capable(CAP_DAC_OVERRIDE) || capable(CAP_DAC_READ_SEARCH)) |
478 | goto ok; |
479 | |
480 | return ret; |
481 | ok: |
482 | return security_inode_permission(inode, MAY_EXEC); |
483 | } |
484 | |
485 | static __always_inline void set_root(struct nameidata *nd) |
486 | { |
487 | if (!nd->root.mnt) { |
488 | struct fs_struct *fs = current->fs; |
489 | read_lock(&fs->lock); |
490 | nd->root = fs->root; |
491 | path_get(&nd->root); |
492 | read_unlock(&fs->lock); |
493 | } |
494 | } |
495 | |
496 | static int link_path_walk(const char *, struct nameidata *); |
497 | |
498 | static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link) |
499 | { |
500 | if (IS_ERR(link)) |
501 | goto fail; |
502 | |
503 | if (*link == '/') { |
504 | set_root(nd); |
505 | path_put(&nd->path); |
506 | nd->path = nd->root; |
507 | path_get(&nd->root); |
508 | } |
509 | |
510 | return link_path_walk(link, nd); |
511 | fail: |
512 | path_put(&nd->path); |
513 | return PTR_ERR(link); |
514 | } |
515 | |
516 | static void path_put_conditional(struct path *path, struct nameidata *nd) |
517 | { |
518 | dput(path->dentry); |
519 | if (path->mnt != nd->path.mnt) |
520 | mntput(path->mnt); |
521 | } |
522 | |
523 | static inline void path_to_nameidata(struct path *path, struct nameidata *nd) |
524 | { |
525 | dput(nd->path.dentry); |
526 | if (nd->path.mnt != path->mnt) { |
527 | mntput(nd->path.mnt); |
528 | nd->path.mnt = path->mnt; |
529 | } |
530 | nd->path.dentry = path->dentry; |
531 | } |
532 | |
533 | static __always_inline int |
534 | __do_follow_link(struct path *path, struct nameidata *nd, void **p) |
535 | { |
536 | int error; |
537 | struct dentry *dentry = path->dentry; |
538 | |
539 | touch_atime(path->mnt, dentry); |
540 | nd_set_link(nd, NULL); |
541 | |
542 | if (path->mnt != nd->path.mnt) { |
543 | path_to_nameidata(path, nd); |
544 | dget(dentry); |
545 | } |
546 | mntget(path->mnt); |
547 | nd->last_type = LAST_BIND; |
548 | *p = dentry->d_inode->i_op->follow_link(dentry, nd); |
549 | error = PTR_ERR(*p); |
550 | if (!IS_ERR(*p)) { |
551 | char *s = nd_get_link(nd); |
552 | error = 0; |
553 | if (s) |
554 | error = __vfs_follow_link(nd, s); |
555 | else if (nd->last_type == LAST_BIND) { |
556 | error = force_reval_path(&nd->path, nd); |
557 | if (error) |
558 | path_put(&nd->path); |
559 | } |
560 | } |
561 | return error; |
562 | } |
563 | |
564 | /* |
565 | * This limits recursive symlink follows to 8, while |
566 | * limiting consecutive symlinks to 40. |
567 | * |
568 | * Without that kind of total limit, nasty chains of consecutive |
569 | * symlinks can cause almost arbitrarily long lookups. |
570 | */ |
571 | static inline int do_follow_link(struct path *path, struct nameidata *nd) |
572 | { |
573 | void *cookie; |
574 | int err = -ELOOP; |
575 | if (current->link_count >= MAX_NESTED_LINKS) |
576 | goto loop; |
577 | if (current->total_link_count >= 40) |
578 | goto loop; |
579 | BUG_ON(nd->depth >= MAX_NESTED_LINKS); |
580 | cond_resched(); |
581 | err = security_inode_follow_link(path->dentry, nd); |
582 | if (err) |
583 | goto loop; |
584 | current->link_count++; |
585 | current->total_link_count++; |
586 | nd->depth++; |
587 | err = __do_follow_link(path, nd, &cookie); |
588 | if (!IS_ERR(cookie) && path->dentry->d_inode->i_op->put_link) |
589 | path->dentry->d_inode->i_op->put_link(path->dentry, nd, cookie); |
590 | path_put(path); |
591 | current->link_count--; |
592 | nd->depth--; |
593 | return err; |
594 | loop: |
595 | path_put_conditional(path, nd); |
596 | path_put(&nd->path); |
597 | return err; |
598 | } |
599 | |
600 | int follow_up(struct path *path) |
601 | { |
602 | struct vfsmount *parent; |
603 | struct dentry *mountpoint; |
604 | spin_lock(&vfsmount_lock); |
605 | parent = path->mnt->mnt_parent; |
606 | if (parent == path->mnt) { |
607 | spin_unlock(&vfsmount_lock); |
608 | return 0; |
609 | } |
610 | mntget(parent); |
611 | mountpoint = dget(path->mnt->mnt_mountpoint); |
612 | spin_unlock(&vfsmount_lock); |
613 | dput(path->dentry); |
614 | path->dentry = mountpoint; |
615 | mntput(path->mnt); |
616 | path->mnt = parent; |
617 | return 1; |
618 | } |
619 | |
620 | /* no need for dcache_lock, as serialization is taken care in |
621 | * namespace.c |
622 | */ |
623 | static int __follow_mount(struct path *path) |
624 | { |
625 | int res = 0; |
626 | while (d_mountpoint(path->dentry)) { |
627 | struct vfsmount *mounted = lookup_mnt(path); |
628 | if (!mounted) |
629 | break; |
630 | dput(path->dentry); |
631 | if (res) |
632 | mntput(path->mnt); |
633 | path->mnt = mounted; |
634 | path->dentry = dget(mounted->mnt_root); |
635 | res = 1; |
636 | } |
637 | return res; |
638 | } |
639 | |
640 | static void follow_mount(struct path *path) |
641 | { |
642 | while (d_mountpoint(path->dentry)) { |
643 | struct vfsmount *mounted = lookup_mnt(path); |
644 | if (!mounted) |
645 | break; |
646 | dput(path->dentry); |
647 | mntput(path->mnt); |
648 | path->mnt = mounted; |
649 | path->dentry = dget(mounted->mnt_root); |
650 | } |
651 | } |
652 | |
653 | /* no need for dcache_lock, as serialization is taken care in |
654 | * namespace.c |
655 | */ |
656 | int follow_down(struct path *path) |
657 | { |
658 | struct vfsmount *mounted; |
659 | |
660 | mounted = lookup_mnt(path); |
661 | if (mounted) { |
662 | dput(path->dentry); |
663 | mntput(path->mnt); |
664 | path->mnt = mounted; |
665 | path->dentry = dget(mounted->mnt_root); |
666 | return 1; |
667 | } |
668 | return 0; |
669 | } |
670 | |
671 | static __always_inline void follow_dotdot(struct nameidata *nd) |
672 | { |
673 | set_root(nd); |
674 | |
675 | while(1) { |
676 | struct dentry *old = nd->path.dentry; |
677 | |
678 | if (nd->path.dentry == nd->root.dentry && |
679 | nd->path.mnt == nd->root.mnt) { |
680 | break; |
681 | } |
682 | if (nd->path.dentry != nd->path.mnt->mnt_root) { |
683 | /* rare case of legitimate dget_parent()... */ |
684 | nd->path.dentry = dget_parent(nd->path.dentry); |
685 | dput(old); |
686 | break; |
687 | } |
688 | if (!follow_up(&nd->path)) |
689 | break; |
690 | } |
691 | follow_mount(&nd->path); |
692 | } |
693 | |
694 | /* |
695 | * It's more convoluted than I'd like it to be, but... it's still fairly |
696 | * small and for now I'd prefer to have fast path as straight as possible. |
697 | * It _is_ time-critical. |
698 | */ |
699 | static int do_lookup(struct nameidata *nd, struct qstr *name, |
700 | struct path *path) |
701 | { |
702 | struct vfsmount *mnt = nd->path.mnt; |
703 | struct dentry *dentry, *parent; |
704 | struct inode *dir; |
705 | /* |
706 | * See if the low-level filesystem might want |
707 | * to use its own hash.. |
708 | */ |
709 | if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) { |
710 | int err = nd->path.dentry->d_op->d_hash(nd->path.dentry, name); |
711 | if (err < 0) |
712 | return err; |
713 | } |
714 | |
715 | dentry = __d_lookup(nd->path.dentry, name); |
716 | if (!dentry) |
717 | goto need_lookup; |
718 | if (dentry->d_op && dentry->d_op->d_revalidate) |
719 | goto need_revalidate; |
720 | done: |
721 | path->mnt = mnt; |
722 | path->dentry = dentry; |
723 | __follow_mount(path); |
724 | return 0; |
725 | |
726 | need_lookup: |
727 | parent = nd->path.dentry; |
728 | dir = parent->d_inode; |
729 | |
730 | mutex_lock(&dir->i_mutex); |
731 | /* |
732 | * First re-do the cached lookup just in case it was created |
733 | * while we waited for the directory semaphore.. |
734 | * |
735 | * FIXME! This could use version numbering or similar to |
736 | * avoid unnecessary cache lookups. |
737 | * |
738 | * The "dcache_lock" is purely to protect the RCU list walker |
739 | * from concurrent renames at this point (we mustn't get false |
740 | * negatives from the RCU list walk here, unlike the optimistic |
741 | * fast walk). |
742 | * |
743 | * so doing d_lookup() (with seqlock), instead of lockfree __d_lookup |
744 | */ |
745 | dentry = d_lookup(parent, name); |
746 | if (!dentry) { |
747 | struct dentry *new; |
748 | |
749 | /* Don't create child dentry for a dead directory. */ |
750 | dentry = ERR_PTR(-ENOENT); |
751 | if (IS_DEADDIR(dir)) |
752 | goto out_unlock; |
753 | |
754 | new = d_alloc(parent, name); |
755 | dentry = ERR_PTR(-ENOMEM); |
756 | if (new) { |
757 | dentry = dir->i_op->lookup(dir, new, nd); |
758 | if (dentry) |
759 | dput(new); |
760 | else |
761 | dentry = new; |
762 | } |
763 | out_unlock: |
764 | mutex_unlock(&dir->i_mutex); |
765 | if (IS_ERR(dentry)) |
766 | goto fail; |
767 | goto done; |
768 | } |
769 | |
770 | /* |
771 | * Uhhuh! Nasty case: the cache was re-populated while |
772 | * we waited on the semaphore. Need to revalidate. |
773 | */ |
774 | mutex_unlock(&dir->i_mutex); |
775 | if (dentry->d_op && dentry->d_op->d_revalidate) { |
776 | dentry = do_revalidate(dentry, nd); |
777 | if (!dentry) |
778 | dentry = ERR_PTR(-ENOENT); |
779 | } |
780 | if (IS_ERR(dentry)) |
781 | goto fail; |
782 | goto done; |
783 | |
784 | need_revalidate: |
785 | dentry = do_revalidate(dentry, nd); |
786 | if (!dentry) |
787 | goto need_lookup; |
788 | if (IS_ERR(dentry)) |
789 | goto fail; |
790 | goto done; |
791 | |
792 | fail: |
793 | return PTR_ERR(dentry); |
794 | } |
795 | |
796 | /* |
797 | * This is a temporary kludge to deal with "automount" symlinks; proper |
798 | * solution is to trigger them on follow_mount(), so that do_lookup() |
799 | * would DTRT. To be killed before 2.6.34-final. |
800 | */ |
801 | static inline int follow_on_final(struct inode *inode, unsigned lookup_flags) |
802 | { |
803 | return inode && unlikely(inode->i_op->follow_link) && |
804 | ((lookup_flags & LOOKUP_FOLLOW) || S_ISDIR(inode->i_mode)); |
805 | } |
806 | |
807 | /* |
808 | * Name resolution. |
809 | * This is the basic name resolution function, turning a pathname into |
810 | * the final dentry. We expect 'base' to be positive and a directory. |
811 | * |
812 | * Returns 0 and nd will have valid dentry and mnt on success. |
813 | * Returns error and drops reference to input namei data on failure. |
814 | */ |
815 | static int link_path_walk(const char *name, struct nameidata *nd) |
816 | { |
817 | struct path next; |
818 | struct inode *inode; |
819 | int err; |
820 | unsigned int lookup_flags = nd->flags; |
821 | |
822 | while (*name=='/') |
823 | name++; |
824 | if (!*name) |
825 | goto return_reval; |
826 | |
827 | inode = nd->path.dentry->d_inode; |
828 | if (nd->depth) |
829 | lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE); |
830 | |
831 | /* At this point we know we have a real path component. */ |
832 | for(;;) { |
833 | unsigned long hash; |
834 | struct qstr this; |
835 | unsigned int c; |
836 | |
837 | nd->flags |= LOOKUP_CONTINUE; |
838 | err = exec_permission(inode); |
839 | if (err) |
840 | break; |
841 | |
842 | this.name = name; |
843 | c = *(const unsigned char *)name; |
844 | |
845 | hash = init_name_hash(); |
846 | do { |
847 | name++; |
848 | hash = partial_name_hash(c, hash); |
849 | c = *(const unsigned char *)name; |
850 | } while (c && (c != '/')); |
851 | this.len = name - (const char *) this.name; |
852 | this.hash = end_name_hash(hash); |
853 | |
854 | /* remove trailing slashes? */ |
855 | if (!c) |
856 | goto last_component; |
857 | while (*++name == '/'); |
858 | if (!*name) |
859 | goto last_with_slashes; |
860 | |
861 | /* |
862 | * "." and ".." are special - ".." especially so because it has |
863 | * to be able to know about the current root directory and |
864 | * parent relationships. |
865 | */ |
866 | if (this.name[0] == '.') switch (this.len) { |
867 | default: |
868 | break; |
869 | case 2: |
870 | if (this.name[1] != '.') |
871 | break; |
872 | follow_dotdot(nd); |
873 | inode = nd->path.dentry->d_inode; |
874 | /* fallthrough */ |
875 | case 1: |
876 | continue; |
877 | } |
878 | /* This does the actual lookups.. */ |
879 | err = do_lookup(nd, &this, &next); |
880 | if (err) |
881 | break; |
882 | |
883 | err = -ENOENT; |
884 | inode = next.dentry->d_inode; |
885 | if (!inode) |
886 | goto out_dput; |
887 | |
888 | if (inode->i_op->follow_link) { |
889 | err = do_follow_link(&next, nd); |
890 | if (err) |
891 | goto return_err; |
892 | err = -ENOENT; |
893 | inode = nd->path.dentry->d_inode; |
894 | if (!inode) |
895 | break; |
896 | } else |
897 | path_to_nameidata(&next, nd); |
898 | err = -ENOTDIR; |
899 | if (!inode->i_op->lookup) |
900 | break; |
901 | continue; |
902 | /* here ends the main loop */ |
903 | |
904 | last_with_slashes: |
905 | lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY; |
906 | last_component: |
907 | /* Clear LOOKUP_CONTINUE iff it was previously unset */ |
908 | nd->flags &= lookup_flags | ~LOOKUP_CONTINUE; |
909 | if (lookup_flags & LOOKUP_PARENT) |
910 | goto lookup_parent; |
911 | if (this.name[0] == '.') switch (this.len) { |
912 | default: |
913 | break; |
914 | case 2: |
915 | if (this.name[1] != '.') |
916 | break; |
917 | follow_dotdot(nd); |
918 | inode = nd->path.dentry->d_inode; |
919 | /* fallthrough */ |
920 | case 1: |
921 | goto return_reval; |
922 | } |
923 | err = do_lookup(nd, &this, &next); |
924 | if (err) |
925 | break; |
926 | inode = next.dentry->d_inode; |
927 | if (follow_on_final(inode, lookup_flags)) { |
928 | err = do_follow_link(&next, nd); |
929 | if (err) |
930 | goto return_err; |
931 | inode = nd->path.dentry->d_inode; |
932 | } else |
933 | path_to_nameidata(&next, nd); |
934 | err = -ENOENT; |
935 | if (!inode) |
936 | break; |
937 | if (lookup_flags & LOOKUP_DIRECTORY) { |
938 | err = -ENOTDIR; |
939 | if (!inode->i_op->lookup) |
940 | break; |
941 | } |
942 | goto return_base; |
943 | lookup_parent: |
944 | nd->last = this; |
945 | nd->last_type = LAST_NORM; |
946 | if (this.name[0] != '.') |
947 | goto return_base; |
948 | if (this.len == 1) |
949 | nd->last_type = LAST_DOT; |
950 | else if (this.len == 2 && this.name[1] == '.') |
951 | nd->last_type = LAST_DOTDOT; |
952 | else |
953 | goto return_base; |
954 | return_reval: |
955 | /* |
956 | * We bypassed the ordinary revalidation routines. |
957 | * We may need to check the cached dentry for staleness. |
958 | */ |
959 | if (nd->path.dentry && nd->path.dentry->d_sb && |
960 | (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) { |
961 | err = -ESTALE; |
962 | /* Note: we do not d_invalidate() */ |
963 | if (!nd->path.dentry->d_op->d_revalidate( |
964 | nd->path.dentry, nd)) |
965 | break; |
966 | } |
967 | return_base: |
968 | return 0; |
969 | out_dput: |
970 | path_put_conditional(&next, nd); |
971 | break; |
972 | } |
973 | path_put(&nd->path); |
974 | return_err: |
975 | return err; |
976 | } |
977 | |
978 | static int path_walk(const char *name, struct nameidata *nd) |
979 | { |
980 | struct path save = nd->path; |
981 | int result; |
982 | |
983 | current->total_link_count = 0; |
984 | |
985 | /* make sure the stuff we saved doesn't go away */ |
986 | path_get(&save); |
987 | |
988 | result = link_path_walk(name, nd); |
989 | if (result == -ESTALE) { |
990 | /* nd->path had been dropped */ |
991 | current->total_link_count = 0; |
992 | nd->path = save; |
993 | path_get(&nd->path); |
994 | nd->flags |= LOOKUP_REVAL; |
995 | result = link_path_walk(name, nd); |
996 | } |
997 | |
998 | path_put(&save); |
999 | |
1000 | return result; |
1001 | } |
1002 | |
1003 | static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd) |
1004 | { |
1005 | int retval = 0; |
1006 | int fput_needed; |
1007 | struct file *file; |
1008 | |
1009 | nd->last_type = LAST_ROOT; /* if there are only slashes... */ |
1010 | nd->flags = flags; |
1011 | nd->depth = 0; |
1012 | nd->root.mnt = NULL; |
1013 | |
1014 | if (*name=='/') { |
1015 | set_root(nd); |
1016 | nd->path = nd->root; |
1017 | path_get(&nd->root); |
1018 | } else if (dfd == AT_FDCWD) { |
1019 | struct fs_struct *fs = current->fs; |
1020 | read_lock(&fs->lock); |
1021 | nd->path = fs->pwd; |
1022 | path_get(&fs->pwd); |
1023 | read_unlock(&fs->lock); |
1024 | } else { |
1025 | struct dentry *dentry; |
1026 | |
1027 | file = fget_light(dfd, &fput_needed); |
1028 | retval = -EBADF; |
1029 | if (!file) |
1030 | goto out_fail; |
1031 | |
1032 | dentry = file->f_path.dentry; |
1033 | |
1034 | retval = -ENOTDIR; |
1035 | if (!S_ISDIR(dentry->d_inode->i_mode)) |
1036 | goto fput_fail; |
1037 | |
1038 | retval = file_permission(file, MAY_EXEC); |
1039 | if (retval) |
1040 | goto fput_fail; |
1041 | |
1042 | nd->path = file->f_path; |
1043 | path_get(&file->f_path); |
1044 | |
1045 | fput_light(file, fput_needed); |
1046 | } |
1047 | return 0; |
1048 | |
1049 | fput_fail: |
1050 | fput_light(file, fput_needed); |
1051 | out_fail: |
1052 | return retval; |
1053 | } |
1054 | |
1055 | /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */ |
1056 | static int do_path_lookup(int dfd, const char *name, |
1057 | unsigned int flags, struct nameidata *nd) |
1058 | { |
1059 | int retval = path_init(dfd, name, flags, nd); |
1060 | if (!retval) |
1061 | retval = path_walk(name, nd); |
1062 | if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry && |
1063 | nd->path.dentry->d_inode)) |
1064 | audit_inode(name, nd->path.dentry); |
1065 | if (nd->root.mnt) { |
1066 | path_put(&nd->root); |
1067 | nd->root.mnt = NULL; |
1068 | } |
1069 | return retval; |
1070 | } |
1071 | |
1072 | int path_lookup(const char *name, unsigned int flags, |
1073 | struct nameidata *nd) |
1074 | { |
1075 | return do_path_lookup(AT_FDCWD, name, flags, nd); |
1076 | } |
1077 | |
1078 | int kern_path(const char *name, unsigned int flags, struct path *path) |
1079 | { |
1080 | struct nameidata nd; |
1081 | int res = do_path_lookup(AT_FDCWD, name, flags, &nd); |
1082 | if (!res) |
1083 | *path = nd.path; |
1084 | return res; |
1085 | } |
1086 | |
1087 | /** |
1088 | * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair |
1089 | * @dentry: pointer to dentry of the base directory |
1090 | * @mnt: pointer to vfs mount of the base directory |
1091 | * @name: pointer to file name |
1092 | * @flags: lookup flags |
1093 | * @nd: pointer to nameidata |
1094 | */ |
1095 | int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, |
1096 | const char *name, unsigned int flags, |
1097 | struct nameidata *nd) |
1098 | { |
1099 | int retval; |
1100 | |
1101 | /* same as do_path_lookup */ |
1102 | nd->last_type = LAST_ROOT; |
1103 | nd->flags = flags; |
1104 | nd->depth = 0; |
1105 | |
1106 | nd->path.dentry = dentry; |
1107 | nd->path.mnt = mnt; |
1108 | path_get(&nd->path); |
1109 | nd->root = nd->path; |
1110 | path_get(&nd->root); |
1111 | |
1112 | retval = path_walk(name, nd); |
1113 | if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry && |
1114 | nd->path.dentry->d_inode)) |
1115 | audit_inode(name, nd->path.dentry); |
1116 | |
1117 | path_put(&nd->root); |
1118 | nd->root.mnt = NULL; |
1119 | |
1120 | return retval; |
1121 | } |
1122 | |
1123 | static struct dentry *__lookup_hash(struct qstr *name, |
1124 | struct dentry *base, struct nameidata *nd) |
1125 | { |
1126 | struct dentry *dentry; |
1127 | struct inode *inode; |
1128 | int err; |
1129 | |
1130 | inode = base->d_inode; |
1131 | |
1132 | /* |
1133 | * See if the low-level filesystem might want |
1134 | * to use its own hash.. |
1135 | */ |
1136 | if (base->d_op && base->d_op->d_hash) { |
1137 | err = base->d_op->d_hash(base, name); |
1138 | dentry = ERR_PTR(err); |
1139 | if (err < 0) |
1140 | goto out; |
1141 | } |
1142 | |
1143 | dentry = __d_lookup(base, name); |
1144 | |
1145 | /* lockess __d_lookup may fail due to concurrent d_move() |
1146 | * in some unrelated directory, so try with d_lookup |
1147 | */ |
1148 | if (!dentry) |
1149 | dentry = d_lookup(base, name); |
1150 | |
1151 | if (dentry && dentry->d_op && dentry->d_op->d_revalidate) |
1152 | dentry = do_revalidate(dentry, nd); |
1153 | |
1154 | if (!dentry) { |
1155 | struct dentry *new; |
1156 | |
1157 | /* Don't create child dentry for a dead directory. */ |
1158 | dentry = ERR_PTR(-ENOENT); |
1159 | if (IS_DEADDIR(inode)) |
1160 | goto out; |
1161 | |
1162 | new = d_alloc(base, name); |
1163 | dentry = ERR_PTR(-ENOMEM); |
1164 | if (!new) |
1165 | goto out; |
1166 | dentry = inode->i_op->lookup(inode, new, nd); |
1167 | if (!dentry) |
1168 | dentry = new; |
1169 | else |
1170 | dput(new); |
1171 | } |
1172 | out: |
1173 | return dentry; |
1174 | } |
1175 | |
1176 | /* |
1177 | * Restricted form of lookup. Doesn't follow links, single-component only, |
1178 | * needs parent already locked. Doesn't follow mounts. |
1179 | * SMP-safe. |
1180 | */ |
1181 | static struct dentry *lookup_hash(struct nameidata *nd) |
1182 | { |
1183 | int err; |
1184 | |
1185 | err = exec_permission(nd->path.dentry->d_inode); |
1186 | if (err) |
1187 | return ERR_PTR(err); |
1188 | return __lookup_hash(&nd->last, nd->path.dentry, nd); |
1189 | } |
1190 | |
1191 | static int __lookup_one_len(const char *name, struct qstr *this, |
1192 | struct dentry *base, int len) |
1193 | { |
1194 | unsigned long hash; |
1195 | unsigned int c; |
1196 | |
1197 | this->name = name; |
1198 | this->len = len; |
1199 | if (!len) |
1200 | return -EACCES; |
1201 | |
1202 | hash = init_name_hash(); |
1203 | while (len--) { |
1204 | c = *(const unsigned char *)name++; |
1205 | if (c == '/' || c == '\0') |
1206 | return -EACCES; |
1207 | hash = partial_name_hash(c, hash); |
1208 | } |
1209 | this->hash = end_name_hash(hash); |
1210 | return 0; |
1211 | } |
1212 | |
1213 | /** |
1214 | * lookup_one_len - filesystem helper to lookup single pathname component |
1215 | * @name: pathname component to lookup |
1216 | * @base: base directory to lookup from |
1217 | * @len: maximum length @len should be interpreted to |
1218 | * |
1219 | * Note that this routine is purely a helper for filesystem usage and should |
1220 | * not be called by generic code. Also note that by using this function the |
1221 | * nameidata argument is passed to the filesystem methods and a filesystem |
1222 | * using this helper needs to be prepared for that. |
1223 | */ |
1224 | struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) |
1225 | { |
1226 | int err; |
1227 | struct qstr this; |
1228 | |
1229 | WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex)); |
1230 | |
1231 | err = __lookup_one_len(name, &this, base, len); |
1232 | if (err) |
1233 | return ERR_PTR(err); |
1234 | |
1235 | err = exec_permission(base->d_inode); |
1236 | if (err) |
1237 | return ERR_PTR(err); |
1238 | return __lookup_hash(&this, base, NULL); |
1239 | } |
1240 | |
1241 | int user_path_at(int dfd, const char __user *name, unsigned flags, |
1242 | struct path *path) |
1243 | { |
1244 | struct nameidata nd; |
1245 | char *tmp = getname(name); |
1246 | int err = PTR_ERR(tmp); |
1247 | if (!IS_ERR(tmp)) { |
1248 | |
1249 | BUG_ON(flags & LOOKUP_PARENT); |
1250 | |
1251 | err = do_path_lookup(dfd, tmp, flags, &nd); |
1252 | putname(tmp); |
1253 | if (!err) |
1254 | *path = nd.path; |
1255 | } |
1256 | return err; |
1257 | } |
1258 | |
1259 | static int user_path_parent(int dfd, const char __user *path, |
1260 | struct nameidata *nd, char **name) |
1261 | { |
1262 | char *s = getname(path); |
1263 | int error; |
1264 | |
1265 | if (IS_ERR(s)) |
1266 | return PTR_ERR(s); |
1267 | |
1268 | error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd); |
1269 | if (error) |
1270 | putname(s); |
1271 | else |
1272 | *name = s; |
1273 | |
1274 | return error; |
1275 | } |
1276 | |
1277 | /* |
1278 | * It's inline, so penalty for filesystems that don't use sticky bit is |
1279 | * minimal. |
1280 | */ |
1281 | static inline int check_sticky(struct inode *dir, struct inode *inode) |
1282 | { |
1283 | uid_t fsuid = current_fsuid(); |
1284 | |
1285 | if (!(dir->i_mode & S_ISVTX)) |
1286 | return 0; |
1287 | if (inode->i_uid == fsuid) |
1288 | return 0; |
1289 | if (dir->i_uid == fsuid) |
1290 | return 0; |
1291 | return !capable(CAP_FOWNER); |
1292 | } |
1293 | |
1294 | /* |
1295 | * Check whether we can remove a link victim from directory dir, check |
1296 | * whether the type of victim is right. |
1297 | * 1. We can't do it if dir is read-only (done in permission()) |
1298 | * 2. We should have write and exec permissions on dir |
1299 | * 3. We can't remove anything from append-only dir |
1300 | * 4. We can't do anything with immutable dir (done in permission()) |
1301 | * 5. If the sticky bit on dir is set we should either |
1302 | * a. be owner of dir, or |
1303 | * b. be owner of victim, or |
1304 | * c. have CAP_FOWNER capability |
1305 | * 6. If the victim is append-only or immutable we can't do antyhing with |
1306 | * links pointing to it. |
1307 | * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. |
1308 | * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. |
1309 | * 9. We can't remove a root or mountpoint. |
1310 | * 10. We don't allow removal of NFS sillyrenamed files; it's handled by |
1311 | * nfs_async_unlink(). |
1312 | */ |
1313 | static int may_delete(struct inode *dir,struct dentry *victim,int isdir) |
1314 | { |
1315 | int error; |
1316 | |
1317 | if (!victim->d_inode) |
1318 | return -ENOENT; |
1319 | |
1320 | BUG_ON(victim->d_parent->d_inode != dir); |
1321 | audit_inode_child(victim, dir); |
1322 | |
1323 | error = inode_permission(dir, MAY_WRITE | MAY_EXEC); |
1324 | if (error) |
1325 | return error; |
1326 | if (IS_APPEND(dir)) |
1327 | return -EPERM; |
1328 | if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)|| |
1329 | IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) |
1330 | return -EPERM; |
1331 | if (isdir) { |
1332 | if (!S_ISDIR(victim->d_inode->i_mode)) |
1333 | return -ENOTDIR; |
1334 | if (IS_ROOT(victim)) |
1335 | return -EBUSY; |
1336 | } else if (S_ISDIR(victim->d_inode->i_mode)) |
1337 | return -EISDIR; |
1338 | if (IS_DEADDIR(dir)) |
1339 | return -ENOENT; |
1340 | if (victim->d_flags & DCACHE_NFSFS_RENAMED) |
1341 | return -EBUSY; |
1342 | return 0; |
1343 | } |
1344 | |
1345 | /* Check whether we can create an object with dentry child in directory |
1346 | * dir. |
1347 | * 1. We can't do it if child already exists (open has special treatment for |
1348 | * this case, but since we are inlined it's OK) |
1349 | * 2. We can't do it if dir is read-only (done in permission()) |
1350 | * 3. We should have write and exec permissions on dir |
1351 | * 4. We can't do it if dir is immutable (done in permission()) |
1352 | */ |
1353 | static inline int may_create(struct inode *dir, struct dentry *child) |
1354 | { |
1355 | if (child->d_inode) |
1356 | return -EEXIST; |
1357 | if (IS_DEADDIR(dir)) |
1358 | return -ENOENT; |
1359 | return inode_permission(dir, MAY_WRITE | MAY_EXEC); |
1360 | } |
1361 | |
1362 | /* |
1363 | * p1 and p2 should be directories on the same fs. |
1364 | */ |
1365 | struct dentry *lock_rename(struct dentry *p1, struct dentry *p2) |
1366 | { |
1367 | struct dentry *p; |
1368 | |
1369 | if (p1 == p2) { |
1370 | mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); |
1371 | return NULL; |
1372 | } |
1373 | |
1374 | mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex); |
1375 | |
1376 | p = d_ancestor(p2, p1); |
1377 | if (p) { |
1378 | mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT); |
1379 | mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD); |
1380 | return p; |
1381 | } |
1382 | |
1383 | p = d_ancestor(p1, p2); |
1384 | if (p) { |
1385 | mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); |
1386 | mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); |
1387 | return p; |
1388 | } |
1389 | |
1390 | mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); |
1391 | mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); |
1392 | return NULL; |
1393 | } |
1394 | |
1395 | void unlock_rename(struct dentry *p1, struct dentry *p2) |
1396 | { |
1397 | mutex_unlock(&p1->d_inode->i_mutex); |
1398 | if (p1 != p2) { |
1399 | mutex_unlock(&p2->d_inode->i_mutex); |
1400 | mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex); |
1401 | } |
1402 | } |
1403 | |
1404 | int vfs_create(struct inode *dir, struct dentry *dentry, int mode, |
1405 | struct nameidata *nd) |
1406 | { |
1407 | int error = may_create(dir, dentry); |
1408 | |
1409 | if (error) |
1410 | return error; |
1411 | |
1412 | if (!dir->i_op->create) |
1413 | return -EACCES; /* shouldn't it be ENOSYS? */ |
1414 | mode &= S_IALLUGO; |
1415 | mode |= S_IFREG; |
1416 | error = security_inode_create(dir, dentry, mode); |
1417 | if (error) |
1418 | return error; |
1419 | error = dir->i_op->create(dir, dentry, mode, nd); |
1420 | if (!error) |
1421 | fsnotify_create(dir, dentry); |
1422 | return error; |
1423 | } |
1424 | |
1425 | int may_open(struct path *path, int acc_mode, int flag) |
1426 | { |
1427 | struct dentry *dentry = path->dentry; |
1428 | struct inode *inode = dentry->d_inode; |
1429 | int error; |
1430 | |
1431 | if (!inode) |
1432 | return -ENOENT; |
1433 | |
1434 | switch (inode->i_mode & S_IFMT) { |
1435 | case S_IFLNK: |
1436 | return -ELOOP; |
1437 | case S_IFDIR: |
1438 | if (acc_mode & MAY_WRITE) |
1439 | return -EISDIR; |
1440 | break; |
1441 | case S_IFBLK: |
1442 | case S_IFCHR: |
1443 | if (path->mnt->mnt_flags & MNT_NODEV) |
1444 | return -EACCES; |
1445 | /*FALLTHRU*/ |
1446 | case S_IFIFO: |
1447 | case S_IFSOCK: |
1448 | flag &= ~O_TRUNC; |
1449 | break; |
1450 | } |
1451 | |
1452 | error = inode_permission(inode, acc_mode); |
1453 | if (error) |
1454 | return error; |
1455 | |
1456 | /* |
1457 | * An append-only file must be opened in append mode for writing. |
1458 | */ |
1459 | if (IS_APPEND(inode)) { |
1460 | if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) |
1461 | return -EPERM; |
1462 | if (flag & O_TRUNC) |
1463 | return -EPERM; |
1464 | } |
1465 | |
1466 | /* O_NOATIME can only be set by the owner or superuser */ |
1467 | if (flag & O_NOATIME && !is_owner_or_cap(inode)) |
1468 | return -EPERM; |
1469 | |
1470 | /* |
1471 | * Ensure there are no outstanding leases on the file. |
1472 | */ |
1473 | return break_lease(inode, flag); |
1474 | } |
1475 | |
1476 | static int handle_truncate(struct path *path) |
1477 | { |
1478 | struct inode *inode = path->dentry->d_inode; |
1479 | int error = get_write_access(inode); |
1480 | if (error) |
1481 | return error; |
1482 | /* |
1483 | * Refuse to truncate files with mandatory locks held on them. |
1484 | */ |
1485 | error = locks_verify_locked(inode); |
1486 | if (!error) |
1487 | error = security_path_truncate(path, 0, |
1488 | ATTR_MTIME|ATTR_CTIME|ATTR_OPEN); |
1489 | if (!error) { |
1490 | error = do_truncate(path->dentry, 0, |
1491 | ATTR_MTIME|ATTR_CTIME|ATTR_OPEN, |
1492 | NULL); |
1493 | } |
1494 | put_write_access(inode); |
1495 | return error; |
1496 | } |
1497 | |
1498 | /* |
1499 | * Be careful about ever adding any more callers of this |
1500 | * function. Its flags must be in the namei format, not |
1501 | * what get passed to sys_open(). |
1502 | */ |
1503 | static int __open_namei_create(struct nameidata *nd, struct path *path, |
1504 | int open_flag, int mode) |
1505 | { |
1506 | int error; |
1507 | struct dentry *dir = nd->path.dentry; |
1508 | |
1509 | if (!IS_POSIXACL(dir->d_inode)) |
1510 | mode &= ~current_umask(); |
1511 | error = security_path_mknod(&nd->path, path->dentry, mode, 0); |
1512 | if (error) |
1513 | goto out_unlock; |
1514 | error = vfs_create(dir->d_inode, path->dentry, mode, nd); |
1515 | out_unlock: |
1516 | mutex_unlock(&dir->d_inode->i_mutex); |
1517 | dput(nd->path.dentry); |
1518 | nd->path.dentry = path->dentry; |
1519 | if (error) |
1520 | return error; |
1521 | /* Don't check for write permission, don't truncate */ |
1522 | return may_open(&nd->path, 0, open_flag & ~O_TRUNC); |
1523 | } |
1524 | |
1525 | /* |
1526 | * Note that while the flag value (low two bits) for sys_open means: |
1527 | * 00 - read-only |
1528 | * 01 - write-only |
1529 | * 10 - read-write |
1530 | * 11 - special |
1531 | * it is changed into |
1532 | * 00 - no permissions needed |
1533 | * 01 - read-permission |
1534 | * 10 - write-permission |
1535 | * 11 - read-write |
1536 | * for the internal routines (ie open_namei()/follow_link() etc) |
1537 | * This is more logical, and also allows the 00 "no perm needed" |
1538 | * to be used for symlinks (where the permissions are checked |
1539 | * later). |
1540 | * |
1541 | */ |
1542 | static inline int open_to_namei_flags(int flag) |
1543 | { |
1544 | if ((flag+1) & O_ACCMODE) |
1545 | flag++; |
1546 | return flag; |
1547 | } |
1548 | |
1549 | static int open_will_truncate(int flag, struct inode *inode) |
1550 | { |
1551 | /* |
1552 | * We'll never write to the fs underlying |
1553 | * a device file. |
1554 | */ |
1555 | if (special_file(inode->i_mode)) |
1556 | return 0; |
1557 | return (flag & O_TRUNC); |
1558 | } |
1559 | |
1560 | static struct file *finish_open(struct nameidata *nd, |
1561 | int open_flag, int acc_mode) |
1562 | { |
1563 | struct file *filp; |
1564 | int will_truncate; |
1565 | int error; |
1566 | |
1567 | will_truncate = open_will_truncate(open_flag, nd->path.dentry->d_inode); |
1568 | if (will_truncate) { |
1569 | error = mnt_want_write(nd->path.mnt); |
1570 | if (error) |
1571 | goto exit; |
1572 | } |
1573 | error = may_open(&nd->path, acc_mode, open_flag); |
1574 | if (error) { |
1575 | if (will_truncate) |
1576 | mnt_drop_write(nd->path.mnt); |
1577 | goto exit; |
1578 | } |
1579 | filp = nameidata_to_filp(nd); |
1580 | if (!IS_ERR(filp)) { |
1581 | error = ima_file_check(filp, acc_mode); |
1582 | if (error) { |
1583 | fput(filp); |
1584 | filp = ERR_PTR(error); |
1585 | } |
1586 | } |
1587 | if (!IS_ERR(filp)) { |
1588 | if (will_truncate) { |
1589 | error = handle_truncate(&nd->path); |
1590 | if (error) { |
1591 | fput(filp); |
1592 | filp = ERR_PTR(error); |
1593 | } |
1594 | } |
1595 | } |
1596 | /* |
1597 | * It is now safe to drop the mnt write |
1598 | * because the filp has had a write taken |
1599 | * on its behalf. |
1600 | */ |
1601 | if (will_truncate) |
1602 | mnt_drop_write(nd->path.mnt); |
1603 | return filp; |
1604 | |
1605 | exit: |
1606 | if (!IS_ERR(nd->intent.open.file)) |
1607 | release_open_intent(nd); |
1608 | path_put(&nd->path); |
1609 | return ERR_PTR(error); |
1610 | } |
1611 | |
1612 | static struct file *do_last(struct nameidata *nd, struct path *path, |
1613 | int open_flag, int acc_mode, |
1614 | int mode, const char *pathname) |
1615 | { |
1616 | struct dentry *dir = nd->path.dentry; |
1617 | struct file *filp; |
1618 | int error = -EISDIR; |
1619 | |
1620 | switch (nd->last_type) { |
1621 | case LAST_DOTDOT: |
1622 | follow_dotdot(nd); |
1623 | dir = nd->path.dentry; |
1624 | case LAST_DOT: |
1625 | if (nd->path.mnt->mnt_sb->s_type->fs_flags & FS_REVAL_DOT) { |
1626 | if (!dir->d_op->d_revalidate(dir, nd)) { |
1627 | error = -ESTALE; |
1628 | goto exit; |
1629 | } |
1630 | } |
1631 | /* fallthrough */ |
1632 | case LAST_ROOT: |
1633 | if (open_flag & O_CREAT) |
1634 | goto exit; |
1635 | /* fallthrough */ |
1636 | case LAST_BIND: |
1637 | audit_inode(pathname, dir); |
1638 | goto ok; |
1639 | } |
1640 | |
1641 | /* trailing slashes? */ |
1642 | if (nd->last.name[nd->last.len]) { |
1643 | if (open_flag & O_CREAT) |
1644 | goto exit; |
1645 | nd->flags |= LOOKUP_DIRECTORY | LOOKUP_FOLLOW; |
1646 | } |
1647 | |
1648 | /* just plain open? */ |
1649 | if (!(open_flag & O_CREAT)) { |
1650 | error = do_lookup(nd, &nd->last, path); |
1651 | if (error) |
1652 | goto exit; |
1653 | error = -ENOENT; |
1654 | if (!path->dentry->d_inode) |
1655 | goto exit_dput; |
1656 | if (path->dentry->d_inode->i_op->follow_link) |
1657 | return NULL; |
1658 | error = -ENOTDIR; |
1659 | if (nd->flags & LOOKUP_DIRECTORY) { |
1660 | if (!path->dentry->d_inode->i_op->lookup) |
1661 | goto exit_dput; |
1662 | } |
1663 | path_to_nameidata(path, nd); |
1664 | audit_inode(pathname, nd->path.dentry); |
1665 | goto ok; |
1666 | } |
1667 | |
1668 | /* OK, it's O_CREAT */ |
1669 | mutex_lock(&dir->d_inode->i_mutex); |
1670 | |
1671 | path->dentry = lookup_hash(nd); |
1672 | path->mnt = nd->path.mnt; |
1673 | |
1674 | error = PTR_ERR(path->dentry); |
1675 | if (IS_ERR(path->dentry)) { |
1676 | mutex_unlock(&dir->d_inode->i_mutex); |
1677 | goto exit; |
1678 | } |
1679 | |
1680 | if (IS_ERR(nd->intent.open.file)) { |
1681 | error = PTR_ERR(nd->intent.open.file); |
1682 | goto exit_mutex_unlock; |
1683 | } |
1684 | |
1685 | /* Negative dentry, just create the file */ |
1686 | if (!path->dentry->d_inode) { |
1687 | /* |
1688 | * This write is needed to ensure that a |
1689 | * ro->rw transition does not occur between |
1690 | * the time when the file is created and when |
1691 | * a permanent write count is taken through |
1692 | * the 'struct file' in nameidata_to_filp(). |
1693 | */ |
1694 | error = mnt_want_write(nd->path.mnt); |
1695 | if (error) |
1696 | goto exit_mutex_unlock; |
1697 | error = __open_namei_create(nd, path, open_flag, mode); |
1698 | if (error) { |
1699 | mnt_drop_write(nd->path.mnt); |
1700 | goto exit; |
1701 | } |
1702 | filp = nameidata_to_filp(nd); |
1703 | mnt_drop_write(nd->path.mnt); |
1704 | if (!IS_ERR(filp)) { |
1705 | error = ima_file_check(filp, acc_mode); |
1706 | if (error) { |
1707 | fput(filp); |
1708 | filp = ERR_PTR(error); |
1709 | } |
1710 | } |
1711 | return filp; |
1712 | } |
1713 | |
1714 | /* |
1715 | * It already exists. |
1716 | */ |
1717 | mutex_unlock(&dir->d_inode->i_mutex); |
1718 | audit_inode(pathname, path->dentry); |
1719 | |
1720 | error = -EEXIST; |
1721 | if (open_flag & O_EXCL) |
1722 | goto exit_dput; |
1723 | |
1724 | if (__follow_mount(path)) { |
1725 | error = -ELOOP; |
1726 | if (open_flag & O_NOFOLLOW) |
1727 | goto exit_dput; |
1728 | } |
1729 | |
1730 | error = -ENOENT; |
1731 | if (!path->dentry->d_inode) |
1732 | goto exit_dput; |
1733 | |
1734 | if (path->dentry->d_inode->i_op->follow_link) |
1735 | return NULL; |
1736 | |
1737 | path_to_nameidata(path, nd); |
1738 | error = -EISDIR; |
1739 | if (S_ISDIR(path->dentry->d_inode->i_mode)) |
1740 | goto exit; |
1741 | ok: |
1742 | filp = finish_open(nd, open_flag, acc_mode); |
1743 | return filp; |
1744 | |
1745 | exit_mutex_unlock: |
1746 | mutex_unlock(&dir->d_inode->i_mutex); |
1747 | exit_dput: |
1748 | path_put_conditional(path, nd); |
1749 | exit: |
1750 | if (!IS_ERR(nd->intent.open.file)) |
1751 | release_open_intent(nd); |
1752 | path_put(&nd->path); |
1753 | return ERR_PTR(error); |
1754 | } |
1755 | |
1756 | /* |
1757 | * Note that the low bits of the passed in "open_flag" |
1758 | * are not the same as in the local variable "flag". See |
1759 | * open_to_namei_flags() for more details. |
1760 | */ |
1761 | struct file *do_filp_open(int dfd, const char *pathname, |
1762 | int open_flag, int mode, int acc_mode) |
1763 | { |
1764 | struct file *filp; |
1765 | struct nameidata nd; |
1766 | int error; |
1767 | struct path path; |
1768 | int count = 0; |
1769 | int flag = open_to_namei_flags(open_flag); |
1770 | int force_reval = 0; |
1771 | |
1772 | if (!(open_flag & O_CREAT)) |
1773 | mode = 0; |
1774 | |
1775 | /* |
1776 | * O_SYNC is implemented as __O_SYNC|O_DSYNC. As many places only |
1777 | * check for O_DSYNC if the need any syncing at all we enforce it's |
1778 | * always set instead of having to deal with possibly weird behaviour |
1779 | * for malicious applications setting only __O_SYNC. |
1780 | */ |
1781 | if (open_flag & __O_SYNC) |
1782 | open_flag |= O_DSYNC; |
1783 | |
1784 | if (!acc_mode) |
1785 | acc_mode = MAY_OPEN | ACC_MODE(open_flag); |
1786 | |
1787 | /* O_TRUNC implies we need access checks for write permissions */ |
1788 | if (open_flag & O_TRUNC) |
1789 | acc_mode |= MAY_WRITE; |
1790 | |
1791 | /* Allow the LSM permission hook to distinguish append |
1792 | access from general write access. */ |
1793 | if (open_flag & O_APPEND) |
1794 | acc_mode |= MAY_APPEND; |
1795 | |
1796 | /* find the parent */ |
1797 | reval: |
1798 | error = path_init(dfd, pathname, LOOKUP_PARENT, &nd); |
1799 | if (error) |
1800 | return ERR_PTR(error); |
1801 | if (force_reval) |
1802 | nd.flags |= LOOKUP_REVAL; |
1803 | |
1804 | current->total_link_count = 0; |
1805 | error = link_path_walk(pathname, &nd); |
1806 | if (error) { |
1807 | filp = ERR_PTR(error); |
1808 | goto out; |
1809 | } |
1810 | if (unlikely(!audit_dummy_context()) && (open_flag & O_CREAT)) |
1811 | audit_inode(pathname, nd.path.dentry); |
1812 | |
1813 | /* |
1814 | * We have the parent and last component. |
1815 | */ |
1816 | |
1817 | error = -ENFILE; |
1818 | filp = get_empty_filp(); |
1819 | if (filp == NULL) |
1820 | goto exit_parent; |
1821 | nd.intent.open.file = filp; |
1822 | filp->f_flags = open_flag; |
1823 | nd.intent.open.flags = flag; |
1824 | nd.intent.open.create_mode = mode; |
1825 | nd.flags &= ~LOOKUP_PARENT; |
1826 | nd.flags |= LOOKUP_OPEN; |
1827 | if (open_flag & O_CREAT) { |
1828 | nd.flags |= LOOKUP_CREATE; |
1829 | if (open_flag & O_EXCL) |
1830 | nd.flags |= LOOKUP_EXCL; |
1831 | } |
1832 | if (open_flag & O_DIRECTORY) |
1833 | nd.flags |= LOOKUP_DIRECTORY; |
1834 | if (!(open_flag & O_NOFOLLOW)) |
1835 | nd.flags |= LOOKUP_FOLLOW; |
1836 | filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname); |
1837 | while (unlikely(!filp)) { /* trailing symlink */ |
1838 | struct path holder; |
1839 | struct inode *inode = path.dentry->d_inode; |
1840 | void *cookie; |
1841 | error = -ELOOP; |
1842 | /* S_ISDIR part is a temporary automount kludge */ |
1843 | if (!(nd.flags & LOOKUP_FOLLOW) && !S_ISDIR(inode->i_mode)) |
1844 | goto exit_dput; |
1845 | if (count++ == 32) |
1846 | goto exit_dput; |
1847 | /* |
1848 | * This is subtle. Instead of calling do_follow_link() we do |
1849 | * the thing by hands. The reason is that this way we have zero |
1850 | * link_count and path_walk() (called from ->follow_link) |
1851 | * honoring LOOKUP_PARENT. After that we have the parent and |
1852 | * last component, i.e. we are in the same situation as after |
1853 | * the first path_walk(). Well, almost - if the last component |
1854 | * is normal we get its copy stored in nd->last.name and we will |
1855 | * have to putname() it when we are done. Procfs-like symlinks |
1856 | * just set LAST_BIND. |
1857 | */ |
1858 | nd.flags |= LOOKUP_PARENT; |
1859 | error = security_inode_follow_link(path.dentry, &nd); |
1860 | if (error) |
1861 | goto exit_dput; |
1862 | error = __do_follow_link(&path, &nd, &cookie); |
1863 | if (unlikely(error)) { |
1864 | /* nd.path had been dropped */ |
1865 | if (!IS_ERR(cookie) && inode->i_op->put_link) |
1866 | inode->i_op->put_link(path.dentry, &nd, cookie); |
1867 | path_put(&path); |
1868 | release_open_intent(&nd); |
1869 | filp = ERR_PTR(error); |
1870 | goto out; |
1871 | } |
1872 | holder = path; |
1873 | nd.flags &= ~LOOKUP_PARENT; |
1874 | filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname); |
1875 | if (inode->i_op->put_link) |
1876 | inode->i_op->put_link(holder.dentry, &nd, cookie); |
1877 | path_put(&holder); |
1878 | } |
1879 | out: |
1880 | if (nd.root.mnt) |
1881 | path_put(&nd.root); |
1882 | if (filp == ERR_PTR(-ESTALE) && !force_reval) { |
1883 | force_reval = 1; |
1884 | goto reval; |
1885 | } |
1886 | return filp; |
1887 | |
1888 | exit_dput: |
1889 | path_put_conditional(&path, &nd); |
1890 | if (!IS_ERR(nd.intent.open.file)) |
1891 | release_open_intent(&nd); |
1892 | exit_parent: |
1893 | path_put(&nd.path); |
1894 | filp = ERR_PTR(error); |
1895 | goto out; |
1896 | } |
1897 | |
1898 | /** |
1899 | * filp_open - open file and return file pointer |
1900 | * |
1901 | * @filename: path to open |
1902 | * @flags: open flags as per the open(2) second argument |
1903 | * @mode: mode for the new file if O_CREAT is set, else ignored |
1904 | * |
1905 | * This is the helper to open a file from kernelspace if you really |
1906 | * have to. But in generally you should not do this, so please move |
1907 | * along, nothing to see here.. |
1908 | */ |
1909 | struct file *filp_open(const char *filename, int flags, int mode) |
1910 | { |
1911 | return do_filp_open(AT_FDCWD, filename, flags, mode, 0); |
1912 | } |
1913 | EXPORT_SYMBOL(filp_open); |
1914 | |
1915 | /** |
1916 | * lookup_create - lookup a dentry, creating it if it doesn't exist |
1917 | * @nd: nameidata info |
1918 | * @is_dir: directory flag |
1919 | * |
1920 | * Simple function to lookup and return a dentry and create it |
1921 | * if it doesn't exist. Is SMP-safe. |
1922 | * |
1923 | * Returns with nd->path.dentry->d_inode->i_mutex locked. |
1924 | */ |
1925 | struct dentry *lookup_create(struct nameidata *nd, int is_dir) |
1926 | { |
1927 | struct dentry *dentry = ERR_PTR(-EEXIST); |
1928 | |
1929 | mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); |
1930 | /* |
1931 | * Yucky last component or no last component at all? |
1932 | * (foo/., foo/.., /////) |
1933 | */ |
1934 | if (nd->last_type != LAST_NORM) |
1935 | goto fail; |
1936 | nd->flags &= ~LOOKUP_PARENT; |
1937 | nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL; |
1938 | nd->intent.open.flags = O_EXCL; |
1939 | |
1940 | /* |
1941 | * Do the final lookup. |
1942 | */ |
1943 | dentry = lookup_hash(nd); |
1944 | if (IS_ERR(dentry)) |
1945 | goto fail; |
1946 | |
1947 | if (dentry->d_inode) |
1948 | goto eexist; |
1949 | /* |
1950 | * Special case - lookup gave negative, but... we had foo/bar/ |
1951 | * From the vfs_mknod() POV we just have a negative dentry - |
1952 | * all is fine. Let's be bastards - you had / on the end, you've |
1953 | * been asking for (non-existent) directory. -ENOENT for you. |
1954 | */ |
1955 | if (unlikely(!is_dir && nd->last.name[nd->last.len])) { |
1956 | dput(dentry); |
1957 | dentry = ERR_PTR(-ENOENT); |
1958 | } |
1959 | return dentry; |
1960 | eexist: |
1961 | dput(dentry); |
1962 | dentry = ERR_PTR(-EEXIST); |
1963 | fail: |
1964 | return dentry; |
1965 | } |
1966 | EXPORT_SYMBOL_GPL(lookup_create); |
1967 | |
1968 | int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) |
1969 | { |
1970 | int error = may_create(dir, dentry); |
1971 | |
1972 | if (error) |
1973 | return error; |
1974 | |
1975 | if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD)) |
1976 | return -EPERM; |
1977 | |
1978 | if (!dir->i_op->mknod) |
1979 | return -EPERM; |
1980 | |
1981 | error = devcgroup_inode_mknod(mode, dev); |
1982 | if (error) |
1983 | return error; |
1984 | |
1985 | error = security_inode_mknod(dir, dentry, mode, dev); |
1986 | if (error) |
1987 | return error; |
1988 | |
1989 | error = dir->i_op->mknod(dir, dentry, mode, dev); |
1990 | if (!error) |
1991 | fsnotify_create(dir, dentry); |
1992 | return error; |
1993 | } |
1994 | |
1995 | static int may_mknod(mode_t mode) |
1996 | { |
1997 | switch (mode & S_IFMT) { |
1998 | case S_IFREG: |
1999 | case S_IFCHR: |
2000 | case S_IFBLK: |
2001 | case S_IFIFO: |
2002 | case S_IFSOCK: |
2003 | case 0: /* zero mode translates to S_IFREG */ |
2004 | return 0; |
2005 | case S_IFDIR: |
2006 | return -EPERM; |
2007 | default: |
2008 | return -EINVAL; |
2009 | } |
2010 | } |
2011 | |
2012 | SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode, |
2013 | unsigned, dev) |
2014 | { |
2015 | int error; |
2016 | char *tmp; |
2017 | struct dentry *dentry; |
2018 | struct nameidata nd; |
2019 | |
2020 | if (S_ISDIR(mode)) |
2021 | return -EPERM; |
2022 | |
2023 | error = user_path_parent(dfd, filename, &nd, &tmp); |
2024 | if (error) |
2025 | return error; |
2026 | |
2027 | dentry = lookup_create(&nd, 0); |
2028 | if (IS_ERR(dentry)) { |
2029 | error = PTR_ERR(dentry); |
2030 | goto out_unlock; |
2031 | } |
2032 | if (!IS_POSIXACL(nd.path.dentry->d_inode)) |
2033 | mode &= ~current_umask(); |
2034 | error = may_mknod(mode); |
2035 | if (error) |
2036 | goto out_dput; |
2037 | error = mnt_want_write(nd.path.mnt); |
2038 | if (error) |
2039 | goto out_dput; |
2040 | error = security_path_mknod(&nd.path, dentry, mode, dev); |
2041 | if (error) |
2042 | goto out_drop_write; |
2043 | switch (mode & S_IFMT) { |
2044 | case 0: case S_IFREG: |
2045 | error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd); |
2046 | break; |
2047 | case S_IFCHR: case S_IFBLK: |
2048 | error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode, |
2049 | new_decode_dev(dev)); |
2050 | break; |
2051 | case S_IFIFO: case S_IFSOCK: |
2052 | error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0); |
2053 | break; |
2054 | } |
2055 | out_drop_write: |
2056 | mnt_drop_write(nd.path.mnt); |
2057 | out_dput: |
2058 | dput(dentry); |
2059 | out_unlock: |
2060 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2061 | path_put(&nd.path); |
2062 | putname(tmp); |
2063 | |
2064 | return error; |
2065 | } |
2066 | |
2067 | SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev) |
2068 | { |
2069 | return sys_mknodat(AT_FDCWD, filename, mode, dev); |
2070 | } |
2071 | |
2072 | int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) |
2073 | { |
2074 | int error = may_create(dir, dentry); |
2075 | |
2076 | if (error) |
2077 | return error; |
2078 | |
2079 | if (!dir->i_op->mkdir) |
2080 | return -EPERM; |
2081 | |
2082 | mode &= (S_IRWXUGO|S_ISVTX); |
2083 | error = security_inode_mkdir(dir, dentry, mode); |
2084 | if (error) |
2085 | return error; |
2086 | |
2087 | error = dir->i_op->mkdir(dir, dentry, mode); |
2088 | if (!error) |
2089 | fsnotify_mkdir(dir, dentry); |
2090 | return error; |
2091 | } |
2092 | |
2093 | SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode) |
2094 | { |
2095 | int error = 0; |
2096 | char * tmp; |
2097 | struct dentry *dentry; |
2098 | struct nameidata nd; |
2099 | |
2100 | error = user_path_parent(dfd, pathname, &nd, &tmp); |
2101 | if (error) |
2102 | goto out_err; |
2103 | |
2104 | dentry = lookup_create(&nd, 1); |
2105 | error = PTR_ERR(dentry); |
2106 | if (IS_ERR(dentry)) |
2107 | goto out_unlock; |
2108 | |
2109 | if (!IS_POSIXACL(nd.path.dentry->d_inode)) |
2110 | mode &= ~current_umask(); |
2111 | error = mnt_want_write(nd.path.mnt); |
2112 | if (error) |
2113 | goto out_dput; |
2114 | error = security_path_mkdir(&nd.path, dentry, mode); |
2115 | if (error) |
2116 | goto out_drop_write; |
2117 | error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode); |
2118 | out_drop_write: |
2119 | mnt_drop_write(nd.path.mnt); |
2120 | out_dput: |
2121 | dput(dentry); |
2122 | out_unlock: |
2123 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2124 | path_put(&nd.path); |
2125 | putname(tmp); |
2126 | out_err: |
2127 | return error; |
2128 | } |
2129 | |
2130 | SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode) |
2131 | { |
2132 | return sys_mkdirat(AT_FDCWD, pathname, mode); |
2133 | } |
2134 | |
2135 | /* |
2136 | * We try to drop the dentry early: we should have |
2137 | * a usage count of 2 if we're the only user of this |
2138 | * dentry, and if that is true (possibly after pruning |
2139 | * the dcache), then we drop the dentry now. |
2140 | * |
2141 | * A low-level filesystem can, if it choses, legally |
2142 | * do a |
2143 | * |
2144 | * if (!d_unhashed(dentry)) |
2145 | * return -EBUSY; |
2146 | * |
2147 | * if it cannot handle the case of removing a directory |
2148 | * that is still in use by something else.. |
2149 | */ |
2150 | void dentry_unhash(struct dentry *dentry) |
2151 | { |
2152 | dget(dentry); |
2153 | shrink_dcache_parent(dentry); |
2154 | spin_lock(&dcache_lock); |
2155 | spin_lock(&dentry->d_lock); |
2156 | if (atomic_read(&dentry->d_count) == 2) |
2157 | __d_drop(dentry); |
2158 | spin_unlock(&dentry->d_lock); |
2159 | spin_unlock(&dcache_lock); |
2160 | } |
2161 | |
2162 | int vfs_rmdir(struct inode *dir, struct dentry *dentry) |
2163 | { |
2164 | int error = may_delete(dir, dentry, 1); |
2165 | |
2166 | if (error) |
2167 | return error; |
2168 | |
2169 | if (!dir->i_op->rmdir) |
2170 | return -EPERM; |
2171 | |
2172 | mutex_lock(&dentry->d_inode->i_mutex); |
2173 | dentry_unhash(dentry); |
2174 | if (d_mountpoint(dentry)) |
2175 | error = -EBUSY; |
2176 | else { |
2177 | error = security_inode_rmdir(dir, dentry); |
2178 | if (!error) { |
2179 | error = dir->i_op->rmdir(dir, dentry); |
2180 | if (!error) { |
2181 | dentry->d_inode->i_flags |= S_DEAD; |
2182 | dont_mount(dentry); |
2183 | } |
2184 | } |
2185 | } |
2186 | mutex_unlock(&dentry->d_inode->i_mutex); |
2187 | if (!error) { |
2188 | d_delete(dentry); |
2189 | } |
2190 | dput(dentry); |
2191 | |
2192 | return error; |
2193 | } |
2194 | |
2195 | static long do_rmdir(int dfd, const char __user *pathname) |
2196 | { |
2197 | int error = 0; |
2198 | char * name; |
2199 | struct dentry *dentry; |
2200 | struct nameidata nd; |
2201 | |
2202 | error = user_path_parent(dfd, pathname, &nd, &name); |
2203 | if (error) |
2204 | return error; |
2205 | |
2206 | switch(nd.last_type) { |
2207 | case LAST_DOTDOT: |
2208 | error = -ENOTEMPTY; |
2209 | goto exit1; |
2210 | case LAST_DOT: |
2211 | error = -EINVAL; |
2212 | goto exit1; |
2213 | case LAST_ROOT: |
2214 | error = -EBUSY; |
2215 | goto exit1; |
2216 | } |
2217 | |
2218 | nd.flags &= ~LOOKUP_PARENT; |
2219 | |
2220 | mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); |
2221 | dentry = lookup_hash(&nd); |
2222 | error = PTR_ERR(dentry); |
2223 | if (IS_ERR(dentry)) |
2224 | goto exit2; |
2225 | error = mnt_want_write(nd.path.mnt); |
2226 | if (error) |
2227 | goto exit3; |
2228 | error = security_path_rmdir(&nd.path, dentry); |
2229 | if (error) |
2230 | goto exit4; |
2231 | error = vfs_rmdir(nd.path.dentry->d_inode, dentry); |
2232 | exit4: |
2233 | mnt_drop_write(nd.path.mnt); |
2234 | exit3: |
2235 | dput(dentry); |
2236 | exit2: |
2237 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2238 | exit1: |
2239 | path_put(&nd.path); |
2240 | putname(name); |
2241 | return error; |
2242 | } |
2243 | |
2244 | SYSCALL_DEFINE1(rmdir, const char __user *, pathname) |
2245 | { |
2246 | return do_rmdir(AT_FDCWD, pathname); |
2247 | } |
2248 | |
2249 | int vfs_unlink(struct inode *dir, struct dentry *dentry) |
2250 | { |
2251 | int error = may_delete(dir, dentry, 0); |
2252 | |
2253 | if (error) |
2254 | return error; |
2255 | |
2256 | if (!dir->i_op->unlink) |
2257 | return -EPERM; |
2258 | |
2259 | mutex_lock(&dentry->d_inode->i_mutex); |
2260 | if (d_mountpoint(dentry)) |
2261 | error = -EBUSY; |
2262 | else { |
2263 | error = security_inode_unlink(dir, dentry); |
2264 | if (!error) { |
2265 | error = dir->i_op->unlink(dir, dentry); |
2266 | if (!error) |
2267 | dont_mount(dentry); |
2268 | } |
2269 | } |
2270 | mutex_unlock(&dentry->d_inode->i_mutex); |
2271 | |
2272 | /* We don't d_delete() NFS sillyrenamed files--they still exist. */ |
2273 | if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) { |
2274 | fsnotify_link_count(dentry->d_inode); |
2275 | d_delete(dentry); |
2276 | } |
2277 | |
2278 | return error; |
2279 | } |
2280 | |
2281 | /* |
2282 | * Make sure that the actual truncation of the file will occur outside its |
2283 | * directory's i_mutex. Truncate can take a long time if there is a lot of |
2284 | * writeout happening, and we don't want to prevent access to the directory |
2285 | * while waiting on the I/O. |
2286 | */ |
2287 | static long do_unlinkat(int dfd, const char __user *pathname) |
2288 | { |
2289 | int error; |
2290 | char *name; |
2291 | struct dentry *dentry; |
2292 | struct nameidata nd; |
2293 | struct inode *inode = NULL; |
2294 | |
2295 | error = user_path_parent(dfd, pathname, &nd, &name); |
2296 | if (error) |
2297 | return error; |
2298 | |
2299 | error = -EISDIR; |
2300 | if (nd.last_type != LAST_NORM) |
2301 | goto exit1; |
2302 | |
2303 | nd.flags &= ~LOOKUP_PARENT; |
2304 | |
2305 | mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); |
2306 | dentry = lookup_hash(&nd); |
2307 | error = PTR_ERR(dentry); |
2308 | if (!IS_ERR(dentry)) { |
2309 | /* Why not before? Because we want correct error value */ |
2310 | if (nd.last.name[nd.last.len]) |
2311 | goto slashes; |
2312 | inode = dentry->d_inode; |
2313 | if (inode) |
2314 | atomic_inc(&inode->i_count); |
2315 | error = mnt_want_write(nd.path.mnt); |
2316 | if (error) |
2317 | goto exit2; |
2318 | error = security_path_unlink(&nd.path, dentry); |
2319 | if (error) |
2320 | goto exit3; |
2321 | error = vfs_unlink(nd.path.dentry->d_inode, dentry); |
2322 | exit3: |
2323 | mnt_drop_write(nd.path.mnt); |
2324 | exit2: |
2325 | dput(dentry); |
2326 | } |
2327 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2328 | if (inode) |
2329 | iput(inode); /* truncate the inode here */ |
2330 | exit1: |
2331 | path_put(&nd.path); |
2332 | putname(name); |
2333 | return error; |
2334 | |
2335 | slashes: |
2336 | error = !dentry->d_inode ? -ENOENT : |
2337 | S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR; |
2338 | goto exit2; |
2339 | } |
2340 | |
2341 | SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag) |
2342 | { |
2343 | if ((flag & ~AT_REMOVEDIR) != 0) |
2344 | return -EINVAL; |
2345 | |
2346 | if (flag & AT_REMOVEDIR) |
2347 | return do_rmdir(dfd, pathname); |
2348 | |
2349 | return do_unlinkat(dfd, pathname); |
2350 | } |
2351 | |
2352 | SYSCALL_DEFINE1(unlink, const char __user *, pathname) |
2353 | { |
2354 | return do_unlinkat(AT_FDCWD, pathname); |
2355 | } |
2356 | |
2357 | int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) |
2358 | { |
2359 | int error = may_create(dir, dentry); |
2360 | |
2361 | if (error) |
2362 | return error; |
2363 | |
2364 | if (!dir->i_op->symlink) |
2365 | return -EPERM; |
2366 | |
2367 | error = security_inode_symlink(dir, dentry, oldname); |
2368 | if (error) |
2369 | return error; |
2370 | |
2371 | error = dir->i_op->symlink(dir, dentry, oldname); |
2372 | if (!error) |
2373 | fsnotify_create(dir, dentry); |
2374 | return error; |
2375 | } |
2376 | |
2377 | SYSCALL_DEFINE3(symlinkat, const char __user *, oldname, |
2378 | int, newdfd, const char __user *, newname) |
2379 | { |
2380 | int error; |
2381 | char *from; |
2382 | char *to; |
2383 | struct dentry *dentry; |
2384 | struct nameidata nd; |
2385 | |
2386 | from = getname(oldname); |
2387 | if (IS_ERR(from)) |
2388 | return PTR_ERR(from); |
2389 | |
2390 | error = user_path_parent(newdfd, newname, &nd, &to); |
2391 | if (error) |
2392 | goto out_putname; |
2393 | |
2394 | dentry = lookup_create(&nd, 0); |
2395 | error = PTR_ERR(dentry); |
2396 | if (IS_ERR(dentry)) |
2397 | goto out_unlock; |
2398 | |
2399 | error = mnt_want_write(nd.path.mnt); |
2400 | if (error) |
2401 | goto out_dput; |
2402 | error = security_path_symlink(&nd.path, dentry, from); |
2403 | if (error) |
2404 | goto out_drop_write; |
2405 | error = vfs_symlink(nd.path.dentry->d_inode, dentry, from); |
2406 | out_drop_write: |
2407 | mnt_drop_write(nd.path.mnt); |
2408 | out_dput: |
2409 | dput(dentry); |
2410 | out_unlock: |
2411 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2412 | path_put(&nd.path); |
2413 | putname(to); |
2414 | out_putname: |
2415 | putname(from); |
2416 | return error; |
2417 | } |
2418 | |
2419 | SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname) |
2420 | { |
2421 | return sys_symlinkat(oldname, AT_FDCWD, newname); |
2422 | } |
2423 | |
2424 | int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) |
2425 | { |
2426 | struct inode *inode = old_dentry->d_inode; |
2427 | int error; |
2428 | |
2429 | if (!inode) |
2430 | return -ENOENT; |
2431 | |
2432 | error = may_create(dir, new_dentry); |
2433 | if (error) |
2434 | return error; |
2435 | |
2436 | if (dir->i_sb != inode->i_sb) |
2437 | return -EXDEV; |
2438 | |
2439 | /* |
2440 | * A link to an append-only or immutable file cannot be created. |
2441 | */ |
2442 | if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) |
2443 | return -EPERM; |
2444 | if (!dir->i_op->link) |
2445 | return -EPERM; |
2446 | if (S_ISDIR(inode->i_mode)) |
2447 | return -EPERM; |
2448 | |
2449 | error = security_inode_link(old_dentry, dir, new_dentry); |
2450 | if (error) |
2451 | return error; |
2452 | |
2453 | mutex_lock(&inode->i_mutex); |
2454 | error = dir->i_op->link(old_dentry, dir, new_dentry); |
2455 | mutex_unlock(&inode->i_mutex); |
2456 | if (!error) |
2457 | fsnotify_link(dir, inode, new_dentry); |
2458 | return error; |
2459 | } |
2460 | |
2461 | /* |
2462 | * Hardlinks are often used in delicate situations. We avoid |
2463 | * security-related surprises by not following symlinks on the |
2464 | * newname. --KAB |
2465 | * |
2466 | * We don't follow them on the oldname either to be compatible |
2467 | * with linux 2.0, and to avoid hard-linking to directories |
2468 | * and other special files. --ADM |
2469 | */ |
2470 | SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname, |
2471 | int, newdfd, const char __user *, newname, int, flags) |
2472 | { |
2473 | struct dentry *new_dentry; |
2474 | struct nameidata nd; |
2475 | struct path old_path; |
2476 | int error; |
2477 | char *to; |
2478 | |
2479 | if ((flags & ~AT_SYMLINK_FOLLOW) != 0) |
2480 | return -EINVAL; |
2481 | |
2482 | error = user_path_at(olddfd, oldname, |
2483 | flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0, |
2484 | &old_path); |
2485 | if (error) |
2486 | return error; |
2487 | |
2488 | error = user_path_parent(newdfd, newname, &nd, &to); |
2489 | if (error) |
2490 | goto out; |
2491 | error = -EXDEV; |
2492 | if (old_path.mnt != nd.path.mnt) |
2493 | goto out_release; |
2494 | new_dentry = lookup_create(&nd, 0); |
2495 | error = PTR_ERR(new_dentry); |
2496 | if (IS_ERR(new_dentry)) |
2497 | goto out_unlock; |
2498 | error = mnt_want_write(nd.path.mnt); |
2499 | if (error) |
2500 | goto out_dput; |
2501 | error = security_path_link(old_path.dentry, &nd.path, new_dentry); |
2502 | if (error) |
2503 | goto out_drop_write; |
2504 | error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry); |
2505 | out_drop_write: |
2506 | mnt_drop_write(nd.path.mnt); |
2507 | out_dput: |
2508 | dput(new_dentry); |
2509 | out_unlock: |
2510 | mutex_unlock(&nd.path.dentry->d_inode->i_mutex); |
2511 | out_release: |
2512 | path_put(&nd.path); |
2513 | putname(to); |
2514 | out: |
2515 | path_put(&old_path); |
2516 | |
2517 | return error; |
2518 | } |
2519 | |
2520 | SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname) |
2521 | { |
2522 | return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0); |
2523 | } |
2524 | |
2525 | /* |
2526 | * The worst of all namespace operations - renaming directory. "Perverted" |
2527 | * doesn't even start to describe it. Somebody in UCB had a heck of a trip... |
2528 | * Problems: |
2529 | * a) we can get into loop creation. Check is done in is_subdir(). |
2530 | * b) race potential - two innocent renames can create a loop together. |
2531 | * That's where 4.4 screws up. Current fix: serialization on |
2532 | * sb->s_vfs_rename_mutex. We might be more accurate, but that's another |
2533 | * story. |
2534 | * c) we have to lock _three_ objects - parents and victim (if it exists). |
2535 | * And that - after we got ->i_mutex on parents (until then we don't know |
2536 | * whether the target exists). Solution: try to be smart with locking |
2537 | * order for inodes. We rely on the fact that tree topology may change |
2538 | * only under ->s_vfs_rename_mutex _and_ that parent of the object we |
2539 | * move will be locked. Thus we can rank directories by the tree |
2540 | * (ancestors first) and rank all non-directories after them. |
2541 | * That works since everybody except rename does "lock parent, lookup, |
2542 | * lock child" and rename is under ->s_vfs_rename_mutex. |
2543 | * HOWEVER, it relies on the assumption that any object with ->lookup() |
2544 | * has no more than 1 dentry. If "hybrid" objects will ever appear, |
2545 | * we'd better make sure that there's no link(2) for them. |
2546 | * d) some filesystems don't support opened-but-unlinked directories, |
2547 | * either because of layout or because they are not ready to deal with |
2548 | * all cases correctly. The latter will be fixed (taking this sort of |
2549 | * stuff into VFS), but the former is not going away. Solution: the same |
2550 | * trick as in rmdir(). |
2551 | * e) conversion from fhandle to dentry may come in the wrong moment - when |
2552 | * we are removing the target. Solution: we will have to grab ->i_mutex |
2553 | * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on |
2554 | * ->i_mutex on parents, which works but leads to some truly excessive |
2555 | * locking]. |
2556 | */ |
2557 | static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry, |
2558 | struct inode *new_dir, struct dentry *new_dentry) |
2559 | { |
2560 | int error = 0; |
2561 | struct inode *target; |
2562 | |
2563 | /* |
2564 | * If we are going to change the parent - check write permissions, |
2565 | * we'll need to flip '..'. |
2566 | */ |
2567 | if (new_dir != old_dir) { |
2568 | error = inode_permission(old_dentry->d_inode, MAY_WRITE); |
2569 | if (error) |
2570 | return error; |
2571 | } |
2572 | |
2573 | error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); |
2574 | if (error) |
2575 | return error; |
2576 | |
2577 | target = new_dentry->d_inode; |
2578 | if (target) |
2579 | mutex_lock(&target->i_mutex); |
2580 | if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) |
2581 | error = -EBUSY; |
2582 | else { |
2583 | if (target) |
2584 | dentry_unhash(new_dentry); |
2585 | error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); |
2586 | } |
2587 | if (target) { |
2588 | if (!error) { |
2589 | target->i_flags |= S_DEAD; |
2590 | dont_mount(new_dentry); |
2591 | } |
2592 | mutex_unlock(&target->i_mutex); |
2593 | if (d_unhashed(new_dentry)) |
2594 | d_rehash(new_dentry); |
2595 | dput(new_dentry); |
2596 | } |
2597 | if (!error) |
2598 | if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) |
2599 | d_move(old_dentry,new_dentry); |
2600 | return error; |
2601 | } |
2602 | |
2603 | static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry, |
2604 | struct inode *new_dir, struct dentry *new_dentry) |
2605 | { |
2606 | struct inode *target; |
2607 | int error; |
2608 | |
2609 | error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); |
2610 | if (error) |
2611 | return error; |
2612 | |
2613 | dget(new_dentry); |
2614 | target = new_dentry->d_inode; |
2615 | if (target) |
2616 | mutex_lock(&target->i_mutex); |
2617 | if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) |
2618 | error = -EBUSY; |
2619 | else |
2620 | error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); |
2621 | if (!error) { |
2622 | if (target) |
2623 | dont_mount(new_dentry); |
2624 | if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) |
2625 | d_move(old_dentry, new_dentry); |
2626 | } |
2627 | if (target) |
2628 | mutex_unlock(&target->i_mutex); |
2629 | dput(new_dentry); |
2630 | return error; |
2631 | } |
2632 | |
2633 | int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, |
2634 | struct inode *new_dir, struct dentry *new_dentry) |
2635 | { |
2636 | int error; |
2637 | int is_dir = S_ISDIR(old_dentry->d_inode->i_mode); |
2638 | const char *old_name; |
2639 | |
2640 | if (old_dentry->d_inode == new_dentry->d_inode) |
2641 | return 0; |
2642 | |
2643 | error = may_delete(old_dir, old_dentry, is_dir); |
2644 | if (error) |
2645 | return error; |
2646 | |
2647 | if (!new_dentry->d_inode) |
2648 | error = may_create(new_dir, new_dentry); |
2649 | else |
2650 | error = may_delete(new_dir, new_dentry, is_dir); |
2651 | if (error) |
2652 | return error; |
2653 | |
2654 | if (!old_dir->i_op->rename) |
2655 | return -EPERM; |
2656 | |
2657 | old_name = fsnotify_oldname_init(old_dentry->d_name.name); |
2658 | |
2659 | if (is_dir) |
2660 | error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry); |
2661 | else |
2662 | error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry); |
2663 | if (!error) |
2664 | fsnotify_move(old_dir, new_dir, old_name, is_dir, |
2665 | new_dentry->d_inode, old_dentry); |
2666 | fsnotify_oldname_free(old_name); |
2667 | |
2668 | return error; |
2669 | } |
2670 | |
2671 | SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname, |
2672 | int, newdfd, const char __user *, newname) |
2673 | { |
2674 | struct dentry *old_dir, *new_dir; |
2675 | struct dentry *old_dentry, *new_dentry; |
2676 | struct dentry *trap; |
2677 | struct nameidata oldnd, newnd; |
2678 | char *from; |
2679 | char *to; |
2680 | int error; |
2681 | |
2682 | error = user_path_parent(olddfd, oldname, &oldnd, &from); |
2683 | if (error) |
2684 | goto exit; |
2685 | |
2686 | error = user_path_parent(newdfd, newname, &newnd, &to); |
2687 | if (error) |
2688 | goto exit1; |
2689 | |
2690 | error = -EXDEV; |
2691 | if (oldnd.path.mnt != newnd.path.mnt) |
2692 | goto exit2; |
2693 | |
2694 | old_dir = oldnd.path.dentry; |
2695 | error = -EBUSY; |
2696 | if (oldnd.last_type != LAST_NORM) |
2697 | goto exit2; |
2698 | |
2699 | new_dir = newnd.path.dentry; |
2700 | if (newnd.last_type != LAST_NORM) |
2701 | goto exit2; |
2702 | |
2703 | oldnd.flags &= ~LOOKUP_PARENT; |
2704 | newnd.flags &= ~LOOKUP_PARENT; |
2705 | newnd.flags |= LOOKUP_RENAME_TARGET; |
2706 | |
2707 | trap = lock_rename(new_dir, old_dir); |
2708 | |
2709 | old_dentry = lookup_hash(&oldnd); |
2710 | error = PTR_ERR(old_dentry); |
2711 | if (IS_ERR(old_dentry)) |
2712 | goto exit3; |
2713 | /* source must exist */ |
2714 | error = -ENOENT; |
2715 | if (!old_dentry->d_inode) |
2716 | goto exit4; |
2717 | /* unless the source is a directory trailing slashes give -ENOTDIR */ |
2718 | if (!S_ISDIR(old_dentry->d_inode->i_mode)) { |
2719 | error = -ENOTDIR; |
2720 | if (oldnd.last.name[oldnd.last.len]) |
2721 | goto exit4; |
2722 | if (newnd.last.name[newnd.last.len]) |
2723 | goto exit4; |
2724 | } |
2725 | /* source should not be ancestor of target */ |
2726 | error = -EINVAL; |
2727 | if (old_dentry == trap) |
2728 | goto exit4; |
2729 | new_dentry = lookup_hash(&newnd); |
2730 | error = PTR_ERR(new_dentry); |
2731 | if (IS_ERR(new_dentry)) |
2732 | goto exit4; |
2733 | /* target should not be an ancestor of source */ |
2734 | error = -ENOTEMPTY; |
2735 | if (new_dentry == trap) |
2736 | goto exit5; |
2737 | |
2738 | error = mnt_want_write(oldnd.path.mnt); |
2739 | if (error) |
2740 | goto exit5; |
2741 | error = security_path_rename(&oldnd.path, old_dentry, |
2742 | &newnd.path, new_dentry); |
2743 | if (error) |
2744 | goto exit6; |
2745 | error = vfs_rename(old_dir->d_inode, old_dentry, |
2746 | new_dir->d_inode, new_dentry); |
2747 | exit6: |
2748 | mnt_drop_write(oldnd.path.mnt); |
2749 | exit5: |
2750 | dput(new_dentry); |
2751 | exit4: |
2752 | dput(old_dentry); |
2753 | exit3: |
2754 | unlock_rename(new_dir, old_dir); |
2755 | exit2: |
2756 | path_put(&newnd.path); |
2757 | putname(to); |
2758 | exit1: |
2759 | path_put(&oldnd.path); |
2760 | putname(from); |
2761 | exit: |
2762 | return error; |
2763 | } |
2764 | |
2765 | SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname) |
2766 | { |
2767 | return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname); |
2768 | } |
2769 | |
2770 | int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link) |
2771 | { |
2772 | int len; |
2773 | |
2774 | len = PTR_ERR(link); |
2775 | if (IS_ERR(link)) |
2776 | goto out; |
2777 | |
2778 | len = strlen(link); |
2779 | if (len > (unsigned) buflen) |
2780 | len = buflen; |
2781 | if (copy_to_user(buffer, link, len)) |
2782 | len = -EFAULT; |
2783 | out: |
2784 | return len; |
2785 | } |
2786 | |
2787 | /* |
2788 | * A helper for ->readlink(). This should be used *ONLY* for symlinks that |
2789 | * have ->follow_link() touching nd only in nd_set_link(). Using (or not |
2790 | * using) it for any given inode is up to filesystem. |
2791 | */ |
2792 | int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen) |
2793 | { |
2794 | struct nameidata nd; |
2795 | void *cookie; |
2796 | int res; |
2797 | |
2798 | nd.depth = 0; |
2799 | cookie = dentry->d_inode->i_op->follow_link(dentry, &nd); |
2800 | if (IS_ERR(cookie)) |
2801 | return PTR_ERR(cookie); |
2802 | |
2803 | res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd)); |
2804 | if (dentry->d_inode->i_op->put_link) |
2805 | dentry->d_inode->i_op->put_link(dentry, &nd, cookie); |
2806 | return res; |
2807 | } |
2808 | |
2809 | int vfs_follow_link(struct nameidata *nd, const char *link) |
2810 | { |
2811 | return __vfs_follow_link(nd, link); |
2812 | } |
2813 | |
2814 | /* get the link contents into pagecache */ |
2815 | static char *page_getlink(struct dentry * dentry, struct page **ppage) |
2816 | { |
2817 | char *kaddr; |
2818 | struct page *page; |
2819 | struct address_space *mapping = dentry->d_inode->i_mapping; |
2820 | page = read_mapping_page(mapping, 0, NULL); |
2821 | if (IS_ERR(page)) |
2822 | return (char*)page; |
2823 | *ppage = page; |
2824 | kaddr = kmap(page); |
2825 | nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1); |
2826 | return kaddr; |
2827 | } |
2828 | |
2829 | int page_readlink(struct dentry *dentry, char __user *buffer, int buflen) |
2830 | { |
2831 | struct page *page = NULL; |
2832 | char *s = page_getlink(dentry, &page); |
2833 | int res = vfs_readlink(dentry,buffer,buflen,s); |
2834 | if (page) { |
2835 | kunmap(page); |
2836 | page_cache_release(page); |
2837 | } |
2838 | return res; |
2839 | } |
2840 | |
2841 | void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd) |
2842 | { |
2843 | struct page *page = NULL; |
2844 | nd_set_link(nd, page_getlink(dentry, &page)); |
2845 | return page; |
2846 | } |
2847 | |
2848 | void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) |
2849 | { |
2850 | struct page *page = cookie; |
2851 | |
2852 | if (page) { |
2853 | kunmap(page); |
2854 | page_cache_release(page); |
2855 | } |
2856 | } |
2857 | |
2858 | /* |
2859 | * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS |
2860 | */ |
2861 | int __page_symlink(struct inode *inode, const char *symname, int len, int nofs) |
2862 | { |
2863 | struct address_space *mapping = inode->i_mapping; |
2864 | struct page *page; |
2865 | void *fsdata; |
2866 | int err; |
2867 | char *kaddr; |
2868 | unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE; |
2869 | if (nofs) |
2870 | flags |= AOP_FLAG_NOFS; |
2871 | |
2872 | retry: |
2873 | err = pagecache_write_begin(NULL, mapping, 0, len-1, |
2874 | flags, &page, &fsdata); |
2875 | if (err) |
2876 | goto fail; |
2877 | |
2878 | kaddr = kmap_atomic(page, KM_USER0); |
2879 | memcpy(kaddr, symname, len-1); |
2880 | kunmap_atomic(kaddr, KM_USER0); |
2881 | |
2882 | err = pagecache_write_end(NULL, mapping, 0, len-1, len-1, |
2883 | page, fsdata); |
2884 | if (err < 0) |
2885 | goto fail; |
2886 | if (err < len-1) |
2887 | goto retry; |
2888 | |
2889 | mark_inode_dirty(inode); |
2890 | return 0; |
2891 | fail: |
2892 | return err; |
2893 | } |
2894 | |
2895 | int page_symlink(struct inode *inode, const char *symname, int len) |
2896 | { |
2897 | return __page_symlink(inode, symname, len, |
2898 | !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS)); |
2899 | } |
2900 | |
2901 | const struct inode_operations page_symlink_inode_operations = { |
2902 | .readlink = generic_readlink, |
2903 | .follow_link = page_follow_link_light, |
2904 | .put_link = page_put_link, |
2905 | }; |
2906 | |
2907 | EXPORT_SYMBOL(user_path_at); |
2908 | EXPORT_SYMBOL(follow_down); |
2909 | EXPORT_SYMBOL(follow_up); |
2910 | EXPORT_SYMBOL(get_write_access); /* binfmt_aout */ |
2911 | EXPORT_SYMBOL(getname); |
2912 | EXPORT_SYMBOL(lock_rename); |
2913 | EXPORT_SYMBOL(lookup_one_len); |
2914 | EXPORT_SYMBOL(page_follow_link_light); |
2915 | EXPORT_SYMBOL(page_put_link); |
2916 | EXPORT_SYMBOL(page_readlink); |
2917 | EXPORT_SYMBOL(__page_symlink); |
2918 | EXPORT_SYMBOL(page_symlink); |
2919 | EXPORT_SYMBOL(page_symlink_inode_operations); |
2920 | EXPORT_SYMBOL(path_lookup); |
2921 | EXPORT_SYMBOL(kern_path); |
2922 | EXPORT_SYMBOL(vfs_path_lookup); |
2923 | EXPORT_SYMBOL(inode_permission); |
2924 | EXPORT_SYMBOL(file_permission); |
2925 | EXPORT_SYMBOL(unlock_rename); |
2926 | EXPORT_SYMBOL(vfs_create); |
2927 | EXPORT_SYMBOL(vfs_follow_link); |
2928 | EXPORT_SYMBOL(vfs_link); |
2929 | EXPORT_SYMBOL(vfs_mkdir); |
2930 | EXPORT_SYMBOL(vfs_mknod); |
2931 | EXPORT_SYMBOL(generic_permission); |
2932 | EXPORT_SYMBOL(vfs_readlink); |
2933 | EXPORT_SYMBOL(vfs_rename); |
2934 | EXPORT_SYMBOL(vfs_rmdir); |
2935 | EXPORT_SYMBOL(vfs_symlink); |
2936 | EXPORT_SYMBOL(vfs_unlink); |
2937 | EXPORT_SYMBOL(dentry_unhash); |
2938 | EXPORT_SYMBOL(generic_readlink); |
2939 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9