4 * Copyright (C) 1991, 1992 Linus Torvalds
8 * Some corrections by tytso.
11 /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
16 #include <linux/proc_fs.h>
17 #include <linux/smp_lock.h>
18 #include <linux/quotaops.h>
20 #include <asm/uaccess.h>
21 #include <asm/unaligned.h>
22 #include <asm/semaphore.h>
24 #include <asm/pgtable.h>
27 * The bitmask for a lookup event:
28 * - follow links at the end
29 * - require a directory
30 * - ending slashes ok even for nonexistent files
31 * - internal "there are more path compnents" flag
33 #define LOOKUP_FOLLOW (1)
34 #define LOOKUP_DIRECTORY (2)
35 #define LOOKUP_SLASHOK (4)
36 #define LOOKUP_CONTINUE (8)
38 #include <asm/namei.h>
40 /* This can be removed after the beta phase. */
41 #define CACHE_SUPERVISE /* debug the correctness of dcache entries */
42 #undef DEBUG /* some other debugging */
45 #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
47 /* [Feb-1997 T. Schoebel-Theuer]
48 * Fundamental changes in the pathname lookup mechanisms (namei)
49 * were necessary because of omirr. The reason is that omirr needs
50 * to know the _real_ pathname, not the user-supplied one, in case
51 * of symlinks (and also when transname replacements occur).
53 * The new code replaces the old recursive symlink resolution with
54 * an iterative one (in case of non-nested symlink chains). It does
55 * this with calls to <fs>_follow_link().
56 * As a side effect, dir_namei(), _namei() and follow_link() are now
57 * replaced with a single function lookup_dentry() that can handle all
58 * the special cases of the former code.
60 * With the new dcache, the pathname is stored at each inode, at least as
61 * long as the refcount of the inode is positive. As a side effect, the
62 * size of the dcache depends on the inode cache and thus is dynamic.
64 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
65 * resolution to correspond with current state of the code.
67 * Note that the symlink resolution is not *completely* iterative.
68 * There is still a significant amount of tail- and mid- recursion in
69 * the algorithm. Also, note that <fs>_readlink() is not used in
70 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
71 * may return different results than <fs>_follow_link(). Many virtual
72 * filesystems (including /proc) exhibit this behavior.
75 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
76 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
77 * and the name already exists in form of a symlink, try to create the new
78 * name indicated by the symlink. The old code always complained that the
79 * name already exists, due to not following the symlink even if its target
80 * is nonexistent. The new semantics affects also mknod() and link() when
81 * the name is a symlink pointing to a non-existant name.
83 * I don't know which semantics is the right one, since I have no access
84 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
85 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
86 * "old" one. Personally, I think the new semantics is much more logical.
87 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
88 * file does succeed in both HP-UX and SunOs, but not in Solaris
89 * and in the old Linux semantics.
92 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
93 * semantics. See the comments in "open_namei" and "do_link" below.
95 * [10-Sep-98 Alan Modra] Another symlink change.
98 /* In order to reduce some races, while at the same time doing additional
99 * checking and hopefully speeding things up, we copy filenames to the
100 * kernel data space before using them..
102 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
104 static inline int do_getname(const char *filename
, char *page
)
107 unsigned long len
= PAGE_SIZE
;
109 if ((unsigned long) filename
>= TASK_SIZE
) {
110 if (!segment_eq(get_fs(), KERNEL_DS
))
112 } else if (TASK_SIZE
- (unsigned long) filename
< PAGE_SIZE
)
113 len
= TASK_SIZE
- (unsigned long) filename
;
115 retval
= strncpy_from_user((char *)page
, filename
, len
);
119 return -ENAMETOOLONG
;
125 char * getname(const char * filename
)
129 result
= ERR_PTR(-ENOMEM
);
132 int retval
= do_getname(filename
, tmp
);
137 result
= ERR_PTR(retval
);
146 * is used to check for read/write/execute permissions on a file.
147 * We use "fsuid" for this, letting us set arbitrary permissions
148 * for filesystem access without changing the "normal" uids which
149 * are used for other things..
151 int permission(struct inode
* inode
,int mask
)
153 int mode
= inode
->i_mode
;
155 if (inode
->i_op
&& inode
->i_op
->permission
)
156 return inode
->i_op
->permission(inode
, mask
);
157 else if ((mask
& S_IWOTH
) && IS_RDONLY(inode
) &&
158 (S_ISREG(mode
) || S_ISDIR(mode
) || S_ISLNK(mode
)))
159 return -EROFS
; /* Nobody gets write access to a read-only fs */
160 else if ((mask
& S_IWOTH
) && IS_IMMUTABLE(inode
))
161 return -EACCES
; /* Nobody gets write access to an immutable file */
162 else if (current
->fsuid
== inode
->i_uid
)
164 else if (in_group_p(inode
->i_gid
))
166 if (((mode
& mask
& S_IRWXO
) == mask
) || capable(CAP_DAC_OVERRIDE
))
168 /* read and search access */
169 if ((mask
== S_IROTH
) ||
170 (S_ISDIR(mode
) && !(mask
& ~(S_IROTH
| S_IXOTH
))))
171 if (capable(CAP_DAC_READ_SEARCH
))
177 * get_write_access() gets write permission for a file.
178 * put_write_access() releases this write permission.
179 * This is used for regular files.
180 * We cannot support write (and maybe mmap read-write shared) accesses and
181 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
182 * can have the following values:
183 * 0: no writers, no VM_DENYWRITE mappings
184 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
185 * > 0: (i_writecount) users are writing to the file.
187 int get_write_access(struct inode
* inode
)
189 if (inode
->i_writecount
< 0)
191 inode
->i_writecount
++;
195 void put_write_access(struct inode
* inode
)
197 inode
->i_writecount
--;
201 * "." and ".." are special - ".." especially so because it has to be able
202 * to know about the current root directory and parent relationships
204 static struct dentry
* reserved_lookup(struct dentry
* parent
, struct qstr
* name
)
206 struct dentry
*result
= NULL
;
207 if (name
->name
[0] == '.') {
212 if (name
->name
[1] != '.')
215 if (parent
!= current
->fs
->root
)
216 parent
= parent
->d_covers
->d_parent
;
226 * Internal lookup() using the new generic dcache.
228 static struct dentry
* cached_lookup(struct dentry
* parent
, struct qstr
* name
)
230 struct dentry
* dentry
= d_lookup(parent
, name
);
232 if (dentry
&& dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
233 if (!dentry
->d_op
->d_revalidate(dentry
) && !d_invalidate(dentry
)) {
242 * This is called when everything else fails, and we actually have
243 * to go to the low-level filesystem to find out what we should do..
245 * We get the directory semaphore, and after getting that we also
246 * make sure that nobody added the entry to the dcache in the meantime..
248 static struct dentry
* real_lookup(struct dentry
* parent
, struct qstr
* name
)
250 struct dentry
* result
;
251 struct inode
*dir
= parent
->d_inode
;
255 * First re-do the cached lookup just in case it was created
256 * while we waited for the directory semaphore..
258 * FIXME! This could use version numbering or similar to
259 * avoid unnecessary cache lookups.
261 result
= cached_lookup(parent
, name
);
263 struct dentry
* dentry
= d_alloc(parent
, name
);
264 result
= ERR_PTR(-ENOMEM
);
266 int error
= dir
->i_op
->lookup(dir
, dentry
);
270 result
= ERR_PTR(error
);
278 static struct dentry
* do_follow_link(struct dentry
*base
, struct dentry
*dentry
, unsigned int follow
)
280 struct inode
* inode
= dentry
->d_inode
;
282 if (inode
&& inode
->i_op
&& inode
->i_op
->follow_link
) {
283 if (current
->link_count
< 5) {
284 struct dentry
* result
;
286 current
->link_count
++;
287 /* This eats the base */
288 result
= inode
->i_op
->follow_link(dentry
, base
, follow
);
289 current
->link_count
--;
294 dentry
= ERR_PTR(-ELOOP
);
300 static inline struct dentry
* follow_mount(struct dentry
* dentry
)
302 struct dentry
* mnt
= dentry
->d_mounts
;
315 * This is the basic name resolution function, turning a pathname
316 * into the final dentry.
318 struct dentry
* lookup_dentry(const char * name
, struct dentry
* base
, unsigned int lookup_flags
)
320 struct dentry
* dentry
;
328 } while (*name
== '/');
329 __prefix_lookup_dentry(name
, lookup_flags
);
330 base
= dget(current
->fs
->root
);
332 base
= dget(current
->fs
->pwd
);
338 inode
= base
->d_inode
;
339 lookup_flags
&= LOOKUP_FOLLOW
| LOOKUP_DIRECTORY
| LOOKUP_SLASHOK
;
341 /* At this point we know we have a real path component. */
349 err
= permission(inode
, MAY_EXEC
);
350 dentry
= ERR_PTR(err
);
355 c
= *(const unsigned char *)name
;
357 hash
= init_name_hash();
360 hash
= partial_name_hash(c
, hash
);
361 c
= *(const unsigned char *)name
;
362 } while (c
&& (c
!= '/'));
363 this.len
= name
- (const char *) this.name
;
364 this.hash
= end_name_hash(hash
);
366 /* remove trailing slashes? */
367 flags
= lookup_flags
;
371 flags
|= LOOKUP_FOLLOW
| LOOKUP_DIRECTORY
;
374 } while (tmp
== '/');
376 flags
|= LOOKUP_CONTINUE
;
380 * See if the low-level filesystem might want
381 * to use its own hash..
383 if (base
->d_op
&& base
->d_op
->d_hash
) {
385 error
= base
->d_op
->d_hash(base
, &this);
387 dentry
= ERR_PTR(error
);
392 /* This does the actual lookups.. */
393 dentry
= reserved_lookup(base
, &this);
395 dentry
= cached_lookup(base
, &this);
397 dentry
= real_lookup(base
, &this);
403 /* Check mountpoints.. */
404 dentry
= follow_mount(dentry
);
406 if (!(flags
& LOOKUP_FOLLOW
))
409 base
= do_follow_link(base
, dentry
, flags
);
413 inode
= base
->d_inode
;
414 if (flags
& LOOKUP_DIRECTORY
) {
417 dentry
= ERR_PTR(-ENOTDIR
);
418 if (!inode
->i_op
|| !inode
->i_op
->lookup
)
420 if (flags
& LOOKUP_CONTINUE
)
426 * The case of a nonexisting file is special.
428 * In the middle of a pathname lookup (ie when
429 * LOOKUP_CONTINUE is set), it's an obvious
430 * error and returns ENOENT.
432 * At the end of a pathname lookup it's legal,
433 * and we return a negative dentry. However, we
434 * get here only if there were trailing slashes,
435 * which is legal only if we know it's supposed
436 * to be a directory (ie "mkdir"). Thus the
437 * LOOKUP_SLASHOK flag.
440 dentry
= ERR_PTR(-ENOENT
);
441 if (flags
& LOOKUP_CONTINUE
)
443 if (flags
& LOOKUP_SLASHOK
)
454 * is used by most simple commands to get the inode of a specified name.
455 * Open, link etc use their own routines, but this is enough for things
458 * namei exists in two versions: namei/lnamei. The only difference is
459 * that namei follows links, while lnamei does not.
461 struct dentry
* __namei(const char *pathname
, unsigned int lookup_flags
)
464 struct dentry
*dentry
;
466 name
= getname(pathname
);
467 dentry
= (struct dentry
*) name
;
469 dentry
= lookup_dentry(name
, NULL
, lookup_flags
);
471 if (!IS_ERR(dentry
)) {
472 if (!dentry
->d_inode
) {
474 dentry
= ERR_PTR(-ENOENT
);
482 * It's inline, so penalty for filesystems that don't use sticky bit is
485 static inline int check_sticky(struct inode
*dir
, struct inode
*inode
)
487 if (!(dir
->i_mode
& S_ISVTX
))
489 if (inode
->i_uid
== current
->fsuid
)
491 if (dir
->i_uid
== current
->fsuid
)
493 return !capable(CAP_FOWNER
);
497 * Check whether we can remove a link victim from directory dir, check
498 * whether the type of victim is right.
499 * 1. We can't do it if dir is read-only (done in permission())
500 * 2. We should have write and exec permissions on dir
501 * 3. We can't remove anything from append-only dir
502 * 4. We can't do anything with immutable dir (done in permission())
503 * 5. If the sticky bit on dir is set we should either
504 * a. be owner of dir, or
505 * b. be owner of victim, or
506 * c. have CAP_FOWNER capability
507 * 6. If the victim is append-only or immutable we can't do antyhing with
508 * links pointing to it.
509 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
510 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
511 * 9. We can't remove a root or mountpoint.
513 static inline int may_delete(struct inode
*dir
,struct dentry
*victim
, int isdir
)
516 if (!victim
->d_inode
|| victim
->d_parent
->d_inode
!= dir
)
518 error
= permission(dir
,MAY_WRITE
| MAY_EXEC
);
523 if (check_sticky(dir
, victim
->d_inode
)||IS_APPEND(victim
->d_inode
)||
524 IS_IMMUTABLE(victim
->d_inode
))
527 if (!S_ISDIR(victim
->d_inode
->i_mode
))
531 if (victim
->d_mounts
!= victim
->d_covers
)
533 } else if (S_ISDIR(victim
->d_inode
->i_mode
))
538 /* Check whether we can create an object with dentry child in directory
540 * 1. We can't do it if child already exists (open has special treatment for
541 * this case, but since we are inlined it's OK)
542 * 2. We can't do it if dir is read-only (done in permission())
543 * 3. We should have write and exec permissions on dir
544 * 4. We can't do it if dir is immutable (done in permission())
546 static inline int may_create(struct inode
*dir
, struct dentry
*child
) {
549 return permission(dir
,MAY_WRITE
| MAY_EXEC
);
552 static inline struct dentry
*get_parent(struct dentry
*dentry
)
554 return dget(dentry
->d_parent
);
557 static inline void unlock_dir(struct dentry
*dir
)
559 up(&dir
->d_inode
->i_sem
);
564 * We need to do a check-parent every time
565 * after we have locked the parent - to verify
566 * that the parent is still our parent and
567 * that we are still hashed onto it..
569 * This is requied in case two processes race
570 * on removing (or moving) the same entry: the
571 * parent lock will serialize them, but the
572 * other process will be too late..
574 #define check_parent(dir, dentry) \
575 ((dir) == (dentry)->d_parent && !list_empty(&dentry->d_hash))
578 * Locking the parent is needed to:
579 * - serialize directory operations
580 * - make sure the parent doesn't change from
581 * under us in the middle of an operation.
583 * NOTE! Right now we'd rather use a "struct inode"
584 * for this, but as I expect things to move toward
585 * using dentries instead for most things it is
586 * probably better to start with the conceptually
587 * better interface of relying on a path of dentries.
589 static inline struct dentry
*lock_parent(struct dentry
*dentry
)
591 struct dentry
*dir
= dget(dentry
->d_parent
);
593 down(&dir
->d_inode
->i_sem
);
598 * Whee.. Deadlock country. Happily there are only two VFS
599 * operations that do this..
601 static inline void double_lock(struct dentry
*d1
, struct dentry
*d2
)
603 struct semaphore
*s1
= &d1
->d_inode
->i_sem
;
604 struct semaphore
*s2
= &d2
->d_inode
->i_sem
;
607 if ((unsigned long) s1
< (unsigned long) s2
) {
608 struct semaphore
*tmp
= s2
;
616 static inline void double_unlock(struct dentry
*d1
, struct dentry
*d2
)
618 struct semaphore
*s1
= &d1
->d_inode
->i_sem
;
619 struct semaphore
*s2
= &d2
->d_inode
->i_sem
;
630 * Special case: O_CREAT|O_EXCL implies O_NOFOLLOW for security
633 * O_DIRECTORY translates into forcing a directory lookup.
635 static inline int lookup_flags(unsigned int f
)
637 unsigned long retval
= LOOKUP_FOLLOW
;
640 retval
&= ~LOOKUP_FOLLOW
;
642 if ((f
& (O_CREAT
|O_EXCL
)) == (O_CREAT
|O_EXCL
))
643 retval
&= ~LOOKUP_FOLLOW
;
646 retval
|= LOOKUP_DIRECTORY
;
654 * namei for open - this is in fact almost the whole open-routine.
656 * Note that the low bits of "flag" aren't the same as in the open
657 * system call - they are 00 - no permissions needed
658 * 01 - read permission needed
659 * 10 - write permission needed
660 * 11 - read/write permissions needed
661 * which is a lot more logical, and also allows the "no perm" needed
662 * for symlinks (where the permissions are checked later).
664 struct dentry
* open_namei(const char * pathname
, int flag
, int mode
)
668 struct dentry
*dentry
;
670 mode
&= S_IALLUGO
& ~current
->fs
->umask
;
673 dentry
= lookup_dentry(pathname
, NULL
, lookup_flags(flag
));
677 acc_mode
= ACC_MODE(flag
);
678 if (flag
& O_CREAT
) {
681 if (dentry
->d_inode
) {
682 if (!(flag
& O_EXCL
))
688 dir
= lock_parent(dentry
);
689 if (!check_parent(dir
, dentry
)) {
691 * Really nasty race happened. What's the
692 * right error code? We had a dentry, but
693 * before we could use it it was removed
694 * by somebody else. We could just re-try
695 * everything, I guess.
697 * ENOENT is definitely wrong.
705 * Somebody might have created the file while we
706 * waited for the directory lock.. So we have to
707 * re-do the existence test.
709 if (dentry
->d_inode
) {
713 } else if ((error
= may_create(dir
->d_inode
, dentry
)) == 0) {
714 if (!dir
->d_inode
->i_op
|| !dir
->d_inode
->i_op
->create
)
717 DQUOT_INIT(dir
->d_inode
);
718 error
= dir
->d_inode
->i_op
->create(dir
->d_inode
, dentry
, mode
);
719 /* Don't check for write permission, don't truncate */
731 inode
= dentry
->d_inode
;
736 if (S_ISLNK(inode
->i_mode
))
740 if (S_ISDIR(inode
->i_mode
) && (flag
& FMODE_WRITE
))
743 error
= permission(inode
,acc_mode
);
748 * FIFO's, sockets and device files are special: they don't
749 * actually live on the filesystem itself, and as such you
750 * can write to them even if the filesystem is read-only.
752 if (S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
754 } else if (S_ISBLK(inode
->i_mode
) || S_ISCHR(inode
->i_mode
)) {
762 if (IS_RDONLY(inode
) && (flag
& 2))
766 * An append-only file must be opened in append mode for writing.
769 if (IS_APPEND(inode
)) {
770 if ((flag
& FMODE_WRITE
) && !(flag
& O_APPEND
))
776 if (flag
& O_TRUNC
) {
777 error
= get_write_access(inode
);
782 * Refuse to truncate files with mandatory locks held on them.
784 error
= locks_verify_locked(inode
);
788 error
= do_truncate(dentry
, 0);
790 put_write_access(inode
);
794 if (flag
& FMODE_WRITE
)
801 return ERR_PTR(error
);
804 struct dentry
* do_mknod(const char * filename
, int mode
, dev_t dev
)
808 struct dentry
*dentry
, *retval
;
810 mode
&= ~current
->fs
->umask
;
811 dentry
= lookup_dentry(filename
, NULL
, LOOKUP_FOLLOW
);
815 dir
= lock_parent(dentry
);
817 if (!check_parent(dir
, dentry
))
820 error
= may_create(dir
->d_inode
, dentry
);
825 if (!dir
->d_inode
->i_op
|| !dir
->d_inode
->i_op
->mknod
)
828 DQUOT_INIT(dir
->d_inode
);
829 error
= dir
->d_inode
->i_op
->mknod(dir
->d_inode
, dentry
, mode
, dev
);
831 retval
= ERR_PTR(error
);
833 retval
= dget(dentry
);
839 asmlinkage
int sys_mknod(const char * filename
, int mode
, dev_t dev
)
846 if (S_ISDIR(mode
) || (!S_ISFIFO(mode
) && !capable(CAP_SYS_ADMIN
)))
849 switch (mode
& S_IFMT
) {
853 case S_IFREG
: case S_IFCHR
: case S_IFBLK
: case S_IFIFO
: case S_IFSOCK
:
858 tmp
= getname(filename
);
859 error
= PTR_ERR(tmp
);
861 struct dentry
* dentry
= do_mknod(tmp
,mode
,dev
);
863 error
= PTR_ERR(dentry
);
864 if (!IS_ERR(dentry
)) {
875 * Look out: this function may change a normal dentry
876 * into a directory dentry (different size)..
878 static inline int do_mkdir(const char * pathname
, int mode
)
882 struct dentry
*dentry
;
884 dentry
= lookup_dentry(pathname
, NULL
, LOOKUP_SLASHOK
);
885 error
= PTR_ERR(dentry
);
890 * EEXIST is kind of a strange error code to
891 * return, but basically if the dentry was moved
892 * or unlinked while we locked the parent, we
893 * do know that it _did_ exist before, and as
894 * such it makes perfect sense.. In contrast,
895 * ENOENT doesn't make sense for mkdir.
897 dir
= lock_parent(dentry
);
899 if (!check_parent(dir
, dentry
))
902 error
= may_create(dir
->d_inode
, dentry
);
907 if (!dir
->d_inode
->i_op
|| !dir
->d_inode
->i_op
->mkdir
)
910 DQUOT_INIT(dir
->d_inode
);
911 mode
&= 0777 & ~current
->fs
->umask
;
912 error
= dir
->d_inode
->i_op
->mkdir(dir
->d_inode
, dentry
, mode
);
921 asmlinkage
int sys_mkdir(const char * pathname
, int mode
)
927 tmp
= getname(pathname
);
928 error
= PTR_ERR(tmp
);
930 error
= do_mkdir(tmp
,mode
);
937 int vfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
941 error
= may_delete(dir
, dentry
, 1);
945 if (!dir
->i_op
|| !dir
->i_op
->rmdir
)
951 * We try to drop the dentry early: we should have
952 * a usage count of 2 if we're the only user of this
953 * dentry, and if that is true (possibly after pruning
954 * the dcache), then we drop the dentry now.
956 * A low-level filesystem can, if it choses, legally
959 * if (!list_empty(&dentry->d_hash))
962 * if it cannot handle the case of removing a directory
963 * that is still in use by something else..
965 switch (dentry
->d_count
) {
967 shrink_dcache_parent(dentry
);
968 if (dentry
->d_count
!= 2)
974 error
= dir
->i_op
->rmdir(dir
, dentry
);
979 static inline int do_rmdir(const char * name
)
983 struct dentry
*dentry
;
985 dentry
= lookup_dentry(name
, NULL
, 0);
986 error
= PTR_ERR(dentry
);
991 if (!dentry
->d_inode
)
994 dir
= dget(dentry
->d_parent
);
997 * The dentry->d_count stuff confuses d_delete() enough to
998 * not kill the inode from under us while it is locked. This
999 * wouldn't be needed, except the dentry semaphore is really
1000 * in the inode, not in the dentry..
1003 double_lock(dir
, dentry
);
1006 if (check_parent(dir
, dentry
))
1007 error
= vfs_rmdir(dir
->d_inode
, dentry
);
1009 double_unlock(dentry
, dir
);
1016 asmlinkage
int sys_rmdir(const char * pathname
)
1022 tmp
= getname(pathname
);
1023 error
= PTR_ERR(tmp
);
1025 error
= do_rmdir(tmp
);
1032 int vfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1036 error
= may_delete(dir
, dentry
, 0);
1040 if (!dir
->i_op
|| !dir
->i_op
->unlink
)
1045 error
= dir
->i_op
->unlink(dir
, dentry
);
1051 static inline int do_unlink(const char * name
)
1055 struct dentry
*dentry
;
1057 dentry
= lookup_dentry(name
, NULL
, 0);
1058 error
= PTR_ERR(dentry
);
1062 dir
= lock_parent(dentry
);
1064 if (check_parent(dir
, dentry
))
1065 error
= vfs_unlink(dir
->d_inode
, dentry
);
1073 asmlinkage
int sys_unlink(const char * pathname
)
1079 tmp
= getname(pathname
);
1080 error
= PTR_ERR(tmp
);
1082 error
= do_unlink(tmp
);
1089 static inline int do_symlink(const char * oldname
, const char * newname
)
1093 struct dentry
*dentry
;
1095 dentry
= lookup_dentry(newname
, NULL
, 0);
1097 error
= PTR_ERR(dentry
);
1101 dir
= lock_parent(dentry
);
1103 if (!check_parent(dir
, dentry
))
1106 error
= may_create(dir
->d_inode
, dentry
);
1111 if (!dir
->d_inode
->i_op
|| !dir
->d_inode
->i_op
->symlink
)
1114 DQUOT_INIT(dir
->d_inode
);
1115 error
= dir
->d_inode
->i_op
->symlink(dir
->d_inode
, dentry
, oldname
);
1124 asmlinkage
int sys_symlink(const char * oldname
, const char * newname
)
1130 from
= getname(oldname
);
1131 error
= PTR_ERR(from
);
1132 if (!IS_ERR(from
)) {
1134 to
= getname(newname
);
1135 error
= PTR_ERR(to
);
1137 error
= do_symlink(from
,to
);
1146 static inline int do_link(const char * oldname
, const char * newname
)
1148 struct dentry
*old_dentry
, *new_dentry
, *dir
;
1149 struct inode
*inode
;
1153 * Hardlinks are often used in delicate situations. We avoid
1154 * security-related surprises by not following symlinks on the
1157 * We don't follow them on the oldname either to be compatible
1158 * with linux 2.0, and to avoid hard-linking to directories
1159 * and other special files. --ADM
1161 old_dentry
= lookup_dentry(oldname
, NULL
, 0);
1162 error
= PTR_ERR(old_dentry
);
1163 if (IS_ERR(old_dentry
))
1166 new_dentry
= lookup_dentry(newname
, NULL
, 0);
1167 error
= PTR_ERR(new_dentry
);
1168 if (IS_ERR(new_dentry
))
1171 dir
= lock_parent(new_dentry
);
1173 if (!check_parent(dir
, new_dentry
))
1177 inode
= old_dentry
->d_inode
;
1181 error
= may_create(dir
->d_inode
, new_dentry
);
1186 if (dir
->d_inode
->i_dev
!= inode
->i_dev
)
1190 * A link to an append-only or immutable file cannot be created.
1193 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1197 if (!dir
->d_inode
->i_op
|| !dir
->d_inode
->i_op
->link
)
1200 DQUOT_INIT(dir
->d_inode
);
1201 error
= dir
->d_inode
->i_op
->link(old_dentry
, dir
->d_inode
, new_dentry
);
1212 asmlinkage
int sys_link(const char * oldname
, const char * newname
)
1218 from
= getname(oldname
);
1219 error
= PTR_ERR(from
);
1220 if (!IS_ERR(from
)) {
1222 to
= getname(newname
);
1223 error
= PTR_ERR(to
);
1225 error
= do_link(from
,to
);
1234 int vfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1235 struct inode
*new_dir
, struct dentry
*new_dentry
)
1240 isdir
= S_ISDIR(old_dentry
->d_inode
->i_mode
);
1242 error
= may_delete(old_dir
, old_dentry
, isdir
); /* XXX */
1246 if (new_dir
->i_dev
!= old_dir
->i_dev
)
1249 if (!new_dentry
->d_inode
)
1250 error
= may_create(new_dir
, new_dentry
);
1252 error
= may_delete(new_dir
, new_dentry
, isdir
);
1256 if (!old_dir
->i_op
|| !old_dir
->i_op
->rename
)
1259 DQUOT_INIT(old_dir
);
1260 DQUOT_INIT(new_dir
);
1261 error
= old_dir
->i_op
->rename(old_dir
, old_dentry
, new_dir
, new_dentry
);
1266 static inline int do_rename(const char * oldname
, const char * newname
)
1269 struct dentry
* old_dir
, * new_dir
;
1270 struct dentry
* old_dentry
, *new_dentry
;
1272 old_dentry
= lookup_dentry(oldname
, NULL
, 0);
1274 error
= PTR_ERR(old_dentry
);
1275 if (IS_ERR(old_dentry
))
1279 if (!old_dentry
->d_inode
)
1283 unsigned int flags
= 0;
1284 if (S_ISDIR(old_dentry
->d_inode
->i_mode
))
1285 flags
= LOOKUP_SLASHOK
;
1286 new_dentry
= lookup_dentry(newname
, NULL
, flags
);
1289 error
= PTR_ERR(new_dentry
);
1290 if (IS_ERR(new_dentry
))
1293 new_dir
= get_parent(new_dentry
);
1294 old_dir
= get_parent(old_dentry
);
1296 double_lock(new_dir
, old_dir
);
1299 if (check_parent(old_dir
, old_dentry
) && check_parent(new_dir
, new_dentry
))
1300 error
= vfs_rename(old_dir
->d_inode
, old_dentry
,
1301 new_dir
->d_inode
, new_dentry
);
1303 double_unlock(new_dir
, old_dir
);
1311 asmlinkage
int sys_rename(const char * oldname
, const char * newname
)
1317 from
= getname(oldname
);
1318 error
= PTR_ERR(from
);
1319 if (!IS_ERR(from
)) {
1321 to
= getname(newname
);
1322 error
= PTR_ERR(to
);
1324 error
= do_rename(from
,to
);