2 * linux/fs/umsdos/namei.c
4 * Written 1993 by Jacques Gelinas
5 * Inspired from linux/fs/msdos/... by Werner Almesberger
7 * Maintain and access the --linux alternate directory file.
10 * You are in the maze of twisted functions - half of them shouldn't
14 #include <linux/errno.h>
15 #include <linux/kernel.h>
16 #include <linux/time.h>
17 #include <linux/types.h>
18 #include <linux/fcntl.h>
19 #include <linux/stat.h>
20 #include <linux/string.h>
21 #include <linux/msdos_fs.h>
22 #include <linux/umsdos_fs.h>
23 #include <linux/slab.h>
25 #define UMSDOS_DIR_LOCK
27 #ifdef UMSDOS_DIR_LOCK
29 static inline void u_sleep_on (struct inode *dir)
31 sleep_on (&UMSDOS_I(dir)->dir_info.p);
34 static inline void u_wake_up (struct inode *dir)
36 wake_up (&UMSDOS_I(dir)->dir_info.p);
40 * Wait for creation exclusivity.
41 * Return 0 if the dir was already available.
42 * Return 1 if a wait was necessary.
43 * When 1 is return, it means a wait was done. It does not
44 * mean the directory is available.
46 static int umsdos_waitcreate (struct inode *dir)
50 if (UMSDOS_I(dir)->dir_info.creating
51 && UMSDOS_I(dir)->dir_info.pid != current->pid) {
52 PRINTK (("creating && dir_info.pid=%lu, current->pid=%u\n", UMSDOS_I(dir)->dir_info.pid, current->pid));
60 * Wait for any lookup process to finish
62 static void umsdos_waitlookup (struct inode *dir)
64 while (UMSDOS_I(dir)->dir_info.looking) {
70 * Lock all other process out of this directory.
72 /* #Specification: file creation / not atomic
73 * File creation is a two step process. First we create (allocate)
74 * an entry in the EMD file and then (using the entry offset) we
75 * build a unique name for MSDOS. We create this name in the msdos
78 * We have to use semaphore (sleep_on/wake_up) to prevent lookup
79 * into a directory when we create a file or directory and to
80 * prevent creation while a lookup is going on. Since many lookup
81 * may happen at the same time, the semaphore is a counter.
83 * Only one creation is allowed at the same time. This protection
84 * may not be necessary. The problem arise mainly when a lookup
85 * or a readdir is done while a file is partially created. The
86 * lookup process see that as a "normal" problem and silently
87 * erase the file from the EMD file. Normal because a file
88 * may be erased during a MSDOS session, but not removed from
91 * The locking is done on a directory per directory basis. Each
92 * directory inode has its wait_queue.
94 * For some operation like hard link, things even get worse. Many
95 * creation must occur at once (atomic). To simplify the design
96 * a process is allowed to recursively lock the directory for
97 * creation. The pid of the locking process is kept along with
98 * a counter so a second level of locking is granted or not.
100 void umsdos_lockcreate (struct inode *dir)
103 * Wait for any creation process to finish except
104 * if we (the process) own the lock
106 while (umsdos_waitcreate (dir) != 0);
107 UMSDOS_I(dir)->dir_info.creating++;
108 UMSDOS_I(dir)->dir_info.pid = current->pid;
109 umsdos_waitlookup (dir);
113 * Lock all other process out of those two directories.
115 static void umsdos_lockcreate2 (struct inode *dir1, struct inode *dir2)
118 * We must check that both directory are available before
119 * locking anyone of them. This is to avoid some deadlock.
120 * Thanks to dglaude@is1.vub.ac.be (GLAUDE DAVID) for pointing
124 if (umsdos_waitcreate (dir1) == 0
125 && umsdos_waitcreate (dir2) == 0) {
126 /* We own both now */
127 UMSDOS_I(dir1)->dir_info.creating++;
128 UMSDOS_I(dir1)->dir_info.pid = current->pid;
129 UMSDOS_I(dir2)->dir_info.creating++;
130 UMSDOS_I(dir2)->dir_info.pid = current->pid;
134 umsdos_waitlookup (dir1);
135 umsdos_waitlookup (dir2);
139 * Wait until creation is finish in this directory.
141 void umsdos_startlookup (struct inode *dir)
143 while (umsdos_waitcreate (dir) != 0);
144 UMSDOS_I(dir)->dir_info.looking++;
148 * Unlock the directory.
150 void umsdos_unlockcreate (struct inode *dir)
152 UMSDOS_I(dir)->dir_info.creating--;
153 if (UMSDOS_I(dir)->dir_info.creating < 0) {
154 printk ("UMSDOS: UMSDOS_I(dir)->dir_info.creating < 0: %d"
155 ,UMSDOS_I(dir)->dir_info.creating);
161 * Tell directory lookup is over.
163 void umsdos_endlookup (struct inode *dir)
165 UMSDOS_I(dir)->dir_info.looking--;
166 if (UMSDOS_I(dir)->dir_info.looking < 0) {
167 printk ("UMSDOS: UMSDOS_I(dir)->dir_info.looking < 0: %d"
168 ,UMSDOS_I(dir)->dir_info.looking);
174 static void umsdos_lockcreate (struct inode *dir)
177 static void umsdos_lockcreate2 (struct inode *dir1, struct inode *dir2)
180 void umsdos_startlookup (struct inode *dir)
183 static void umsdos_unlockcreate (struct inode *dir)
186 void umsdos_endlookup (struct inode *dir)
192 static int umsdos_nevercreat (struct inode *dir, struct dentry *dentry,
197 if (umsdos_is_pseudodos (dir, dentry)) {
198 /* #Specification: pseudo root / any file creation /DOS
199 * The pseudo sub-directory /DOS can't be created!
200 * EEXIST is returned.
202 * The pseudo sub-directory /DOS can't be removed!
211 * Add a new file (ordinary or special) into the alternate directory.
212 * The file is added to the real MSDOS directory. If successful, it
213 * is then added to the EMD file.
215 * Return the status of the operation. 0 mean success.
217 * #Specification: create / file exists in DOS
218 * Here is a situation: we are trying to create a file with
219 * UMSDOS. The file is unknown to UMSDOS but already
220 * exists in the DOS directory.
222 * Here is what we are NOT doing:
224 * We could silently assume that everything is fine
225 * and allows the creation to succeed.
227 * It is possible not all files in the partition
228 * are meant to be visible from linux. By trying to create
229 * those file in some directory, one user may get access
230 * to those file without proper permissions. Looks like
231 * a security hole to me. Off course sharing a file system
232 * with DOS is some kind of security hole :-)
236 * We return EEXIST in this case.
237 * The same is true for directory creation.
239 static int umsdos_create_any (struct inode *dir, struct dentry *dentry,
240 int mode, dev_t rdev, char flags)
245 struct umsdos_info info;
247 ret = umsdos_nevercreat (dir, dentry, -EEXIST);
251 ret = umsdos_parse (dentry->d_name.name, dentry->d_name.len, &info);
255 info.entry.mode = mode;
256 info.entry.rdev = rdev;
257 info.entry.flags = flags;
258 info.entry.uid = current->fsuid;
259 info.entry.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
260 info.entry.ctime = info.entry.atime = info.entry.mtime = get_seconds();
261 info.entry.nlink = 1;
262 ret = umsdos_newentry (dentry->d_parent, &info);
266 /* do a real lookup to get the short name dentry */
267 fake = umsdos_covered(dentry->d_parent, info.fake.fname, info.fake.len);
272 /* should not exist yet ... */
275 goto out_remove_dput;
277 ret = msdos_create (dir, fake, S_IFREG | 0777, NULL);
279 goto out_remove_dput;
281 inode = fake->d_inode;
282 atomic_inc(&inode->i_count);
283 d_instantiate (dentry, inode);
285 if (atomic_read(&inode->i_count) > 1) {
287 "umsdos_create_any: %s/%s, ino=%ld, icount=%d??\n",
288 dentry->d_parent->d_name.name, dentry->d_name.name,
289 inode->i_ino, atomic_read(&inode->i_count));
291 umsdos_lookup_patch_new(dentry, &info);
296 /* Creation failed ... remove the EMD entry */
301 printk(KERN_WARNING "UMSDOS: out of sync, deleting %s/%s\n",
302 dentry->d_parent->d_name.name, info.fake.fname);
303 umsdos_delentry (dentry->d_parent, &info, S_ISDIR (info.entry.mode));
308 * Add a new file into the alternate directory.
309 * The file is added to the real MSDOS directory. If successful, it
310 * is then added to the EMD file.
312 * Return the status of the operation. 0 mean success.
314 int UMSDOS_create (struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
316 return umsdos_create_any (dir, dentry, mode, 0, 0);
321 * Initialise the new_entry from the old for a rename operation.
322 * (Only useful for umsdos_rename_f() below).
324 static void umsdos_ren_init (struct umsdos_info *new_info,
325 struct umsdos_info *old_info)
327 new_info->entry.mode = old_info->entry.mode;
328 new_info->entry.rdev = old_info->entry.rdev;
329 new_info->entry.uid = old_info->entry.uid;
330 new_info->entry.gid = old_info->entry.gid;
331 new_info->entry.ctime = old_info->entry.ctime;
332 new_info->entry.atime = old_info->entry.atime;
333 new_info->entry.mtime = old_info->entry.mtime;
334 new_info->entry.flags = old_info->entry.flags;
335 new_info->entry.nlink = old_info->entry.nlink;
339 * Rename a file (move) in the file system.
342 static int umsdos_rename_f (struct inode *old_dir, struct dentry *old_dentry,
343 struct inode *new_dir, struct dentry *new_dentry,
346 struct inode *old_inode = old_dentry->d_inode;
347 struct dentry *old, *new, *old_emd;
349 struct umsdos_info old_info;
350 struct umsdos_info new_info;
353 err = umsdos_parse (old_dentry->d_name.name,
354 old_dentry->d_name.len, &old_info);
357 err = umsdos_parse (new_dentry->d_name.name,
358 new_dentry->d_name.len, &new_info);
362 /* Get the EMD dentry for the old parent */
363 old_emd = umsdos_get_emd_dentry(old_dentry->d_parent);
364 ret = PTR_ERR(old_emd);
368 umsdos_lockcreate2 (old_dir, new_dir);
370 ret = umsdos_findentry(old_emd->d_parent, &old_info, 0);
374 err = umsdos_findentry(new_dentry->d_parent, &new_info, 0);
376 /* check whether it _really_ exists ... */
378 if (new_dentry->d_inode)
381 /* bogus lookup? complain and fix up the EMD ... */
383 "umsdos_rename_f: entry %s/%s exists, inode NULL??\n",
384 new_dentry->d_parent->d_name.name, new_info.entry.name);
385 err = umsdos_delentry(new_dentry->d_parent, &new_info,
386 S_ISDIR(new_info.entry.mode));
389 umsdos_ren_init (&new_info, &old_info);
391 new_info.entry.flags = flags;
392 ret = umsdos_newentry (new_dentry->d_parent, &new_info);
396 /* If we're moving a hardlink, drop it first */
397 if (old_info.entry.flags & UMSDOS_HLINK) {
401 old = umsdos_covered(old_dentry->d_parent, old_info.fake.fname,
406 /* make sure it's the same inode! */
409 * note: for hardlinks they will be different!
410 * old_inode will contain inode of .LINKxxx file containing data, and
411 * old->d_inode will contain inode of file containing path to .LINKxxx file
413 if (!(old_info.entry.flags & UMSDOS_HLINK)) {
414 if (old->d_inode != old_inode)
418 new = umsdos_covered(new_dentry->d_parent, new_info.fake.fname,
424 /* Do the msdos-level rename */
425 ret = msdos_rename (old_dir, old, new_dir, new);
429 /* If the rename failed, remove the new EMD entry */
431 umsdos_delentry (new_dentry->d_parent, &new_info,
432 S_ISDIR (new_info.entry.mode));
437 * Rename successful ... remove the old name from the EMD.
438 * Note that we use the EMD parent here, as the old dentry
439 * may have moved to a new parent ...
441 err = umsdos_delentry (old_emd->d_parent, &old_info,
442 S_ISDIR (old_info.entry.mode));
444 /* Failed? Complain a bit, but don't fail the operation */
446 "umsdos_rename_f: delentry %s/%s failed, error=%d\n",
447 old_emd->d_parent->d_name.name, old_info.entry.name,
452 * Update f_pos so notify_change will succeed
453 * if the file was already in use.
455 umsdos_set_dirinfo_new(old_dentry, new_info.f_pos);
457 /* dput() the dentry if we haven't already */
463 umsdos_unlockcreate (old_dir);
464 umsdos_unlockcreate (new_dir);
467 Printk ((" _ret=%d\n", ret));
472 * Setup a Symbolic link or a (pseudo) hard link
473 * Return a negative error code or 0 if OK.
475 /* #Specification: symbolic links / strategy
476 * A symbolic link is simply a file which holds a path. It is
477 * implemented as a normal MSDOS file (not very space efficient :-()
479 * I see two different ways to do this: One is to place the link data
480 * in unused entries of the EMD file; the other is to have a separate
481 * file dedicated to hold all symbolic links data.
483 * Let's go for simplicity...
487 * AV. Should be called with dir->i_sem down.
489 static int umsdos_symlink_x (struct inode *dir, struct dentry *dentry,
490 const char *symname, int mode, char flags)
494 ret = umsdos_create_any (dir, dentry, mode, 0, flags);
497 "umsdos_symlink: create failed, ret=%d\n", ret);
501 len = strlen (symname) + 1;
502 ret = page_symlink(dentry->d_inode, symname, len);
509 printk(KERN_WARNING "umsdos_symlink: write failed, unlinking\n");
510 UMSDOS_unlink (dir, dentry);
516 * Setup a Symbolic link.
517 * Return a negative error code or 0 if OK.
519 int UMSDOS_symlink ( struct inode *dir, struct dentry *dentry,
522 return umsdos_symlink_x (dir, dentry, symname, S_IFLNK | 0777, 0);
526 * Add a link to an inode in a directory
528 int UMSDOS_link (struct dentry *olddentry, struct inode *dir,
529 struct dentry *dentry)
531 struct inode *oldinode = olddentry->d_inode;
532 struct inode *olddir = olddentry->d_parent->d_inode;
535 unsigned long buffer;
537 struct umsdos_info old_info;
538 struct umsdos_info hid_info;
540 #ifdef UMSDOS_DEBUG_VERBOSE
541 printk("umsdos_link: new %s/%s -> %s/%s\n",
542 dentry->d_parent->d_name.name, dentry->d_name.name,
543 olddentry->d_parent->d_name.name, olddentry->d_name.name);
547 if (S_ISDIR (oldinode->i_mode))
550 ret = umsdos_nevercreat (dir, dentry, -EPERM);
555 buffer = get_zeroed_page(GFP_KERNEL);
560 * Lock the link parent if it's not the same directory.
564 if (atomic_read(&olddir->i_sem.count) < 1)
566 down(&olddir->i_sem);
570 * Parse the name and get the visible directory entry.
572 ret = umsdos_parse (olddentry->d_name.name, olddentry->d_name.len,
576 ret = umsdos_findentry (olddentry->d_parent, &old_info, 1);
578 printk("UMSDOS_link: %s/%s not in EMD, ret=%d\n",
579 olddentry->d_parent->d_name.name, olddentry->d_name.name, ret);
584 * If the visible dentry is a pseudo-hardlink, the original
585 * file must be already hidden.
587 if (!(old_info.entry.flags & UMSDOS_HLINK)) {
590 /* create a hidden link name */
591 ret = umsdos_newhidden (olddentry->d_parent, &hid_info);
593 printk("umsdos_link: can't make hidden %s/%s, ret=%d\n",
594 olddentry->d_parent->d_name.name, hid_info.entry.name, ret);
599 * Make a dentry and rename the original file ...
601 temp = umsdos_lookup_dentry(olddentry->d_parent,
603 hid_info.entry.name_len, 0);
606 printk("umsdos_link: lookup %s/%s failed, ret=%d\n",
607 dentry->d_parent->d_name.name, hid_info.entry.name, ret);
610 /* rename the link to the hidden location ... */
611 ret = umsdos_rename_f(olddir, olddentry, olddir, temp,
613 d_move(olddentry, temp);
616 printk("umsdos_link: rename to %s/%s failed, ret=%d\n",
617 temp->d_parent->d_name.name, temp->d_name.name, ret);
620 /* mark the inode as a hardlink */
621 UMSDOS_I(oldinode)->i_is_hlink = 1;
624 * Capture the path to the hidden link.
626 path = umsdos_d_path(olddentry, (char *) buffer, PAGE_SIZE);
627 Printk(("umsdos_link: hidden link path=%s\n", path));
630 * Recreate a dentry for the original name and symlink it,
631 * then symlink the new dentry. Don't give up if one fails,
632 * or we'll lose the file completely!
634 * Note: this counts as the "original" reference, so we
635 * don't increment i_nlink for this one.
637 temp = umsdos_lookup_dentry(olddentry->d_parent,
639 old_info.entry.name_len, 0);
642 ret = umsdos_symlink_x (olddir, temp, path,
643 S_IFREG | 0777, UMSDOS_HLINK);
647 /* This symlink increments i_nlink (see below.) */
648 err = umsdos_symlink_x (dir, dentry, path,
649 S_IFREG | 0777, UMSDOS_HLINK);
650 /* fold the two errors */
655 /* creation failed ... remove the link entry */
657 printk("umsdos_link: link failed, ret=%d, removing %s/%s\n",
658 ret, olddentry->d_parent->d_name.name, hid_info.entry.name);
659 err = umsdos_delentry(olddentry->d_parent, &hid_info, 0);
663 Printk(("UMSDOS_link: %s/%s already hidden\n",
664 olddentry->d_parent->d_name.name, olddentry->d_name.name));
666 * The original file is already hidden, and we need to get
667 * the dentry for its real name, not the visible name.
668 * N.B. make sure it's the hidden inode ...
670 if (!UMSDOS_I(oldinode)->i_is_hlink)
671 printk("UMSDOS_link: %s/%s hidden, ino=%ld not hlink??\n",
672 olddentry->d_parent->d_name.name,
673 olddentry->d_name.name, oldinode->i_ino);
676 * In order to get the correct (real) inode, we just drop
677 * the original dentry.
680 Printk(("UMSDOS_link: hard link %s/%s, fake=%s\n",
681 olddentry->d_parent->d_name.name, olddentry->d_name.name, old_info.fake.fname));
683 /* Do a real lookup to get the short name dentry */
684 temp = umsdos_covered(olddentry->d_parent, old_info.fake.fname,
690 /* now resolve the link ... */
691 temp = umsdos_solve_hlink(temp);
695 path = umsdos_d_path(temp, (char *) buffer, PAGE_SIZE);
697 Printk(("umsdos_link: %s/%s already hidden, path=%s\n",
698 olddentry->d_parent->d_name.name, olddentry->d_name.name, path));
700 /* finally we can symlink it ... */
701 ret = umsdos_symlink_x (dir, dentry, path, S_IFREG | 0777,UMSDOS_HLINK);
704 /* remain locked for the call to notify_change ... */
706 struct iattr newattrs;
708 /* Do a real lookup to get the short name dentry */
709 temp = umsdos_covered(olddentry->d_parent,
716 /* now resolve the link ... */
717 temp = umsdos_solve_hlink(temp);
723 #ifdef UMSDOS_PARANOIA
724 if (!UMSDOS_I(oldinode)->i_is_hlink)
725 printk("UMSDOS_link: %s/%s, ino=%ld, not marked as hlink!\n",
726 olddentry->d_parent->d_name.name, olddentry->d_name.name, oldinode->i_ino);
728 temp->d_inode->i_nlink++;
729 Printk(("UMSDOS_link: linked %s/%s, ino=%ld, nlink=%d\n",
730 olddentry->d_parent->d_name.name, olddentry->d_name.name,
731 oldinode->i_ino, oldinode->i_nlink));
732 newattrs.ia_valid = 0;
733 ret = umsdos_notify_change_locked(temp, &newattrs);
735 mark_inode_dirty(temp->d_inode);
739 mark_inode_dirty(olddentry->d_inode);
747 Printk (("umsdos_link %d\n", ret));
753 * Add a sub-directory in a directory
755 /* #Specification: mkdir / Directory already exist in DOS
756 * We do the same thing as for file creation.
757 * For all user it is an error.
759 /* #Specification: mkdir / umsdos directory / create EMD
760 * When we created a new sub-directory in a UMSDOS
761 * directory (one with full UMSDOS semantics), we
762 * create immediately an EMD file in the new
763 * sub-directory so it inherits UMSDOS semantics.
765 int UMSDOS_mkdir (struct inode *dir, struct dentry *dentry, int mode)
770 struct umsdos_info info;
772 ret = umsdos_nevercreat (dir, dentry, -EEXIST);
776 ret = umsdos_parse (dentry->d_name.name, dentry->d_name.len, &info);
780 info.entry.mode = mode | S_IFDIR;
782 info.entry.uid = current->fsuid;
783 info.entry.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
784 info.entry.ctime = info.entry.atime = info.entry.mtime = get_seconds();
785 info.entry.flags = 0;
786 info.entry.nlink = 1;
787 ret = umsdos_newentry (dentry->d_parent, &info);
791 /* lookup the short name dentry */
792 temp = umsdos_covered(dentry->d_parent, info.fake.fname, info.fake.len);
797 /* Make sure the short name doesn't exist */
800 printk("umsdos_mkdir: short name %s/%s exists\n",
801 dentry->d_parent->d_name.name, info.fake.fname);
802 goto out_remove_dput;
805 ret = msdos_mkdir (dir, temp, mode);
807 goto out_remove_dput;
810 * Lock the inode to protect the EMD creation ...
812 inode = temp->d_inode;
815 atomic_inc(&inode->i_count);
816 d_instantiate(dentry, inode);
818 /* N.B. this should have an option to create the EMD ... */
819 umsdos_lookup_patch_new(dentry, &info);
822 * Create the EMD file, and set up the dir so it is
823 * promoted to EMD with the EMD file invisible.
825 * N.B. error return if EMD fails?
827 err = umsdos_make_emd(dentry);
828 umsdos_setup_dir(dentry);
834 Printk(("umsdos_mkdir: %s/%s, ret=%d\n",
835 dentry->d_parent->d_name.name, dentry->d_name.name, ret));
838 /* an error occurred ... remove EMD entry. */
842 umsdos_delentry (dentry->d_parent, &info, 1);
847 * Add a new device special file into a directory.
849 * #Specification: Special files / strategy
850 * Device special file, pipes, etc ... are created like normal
851 * file in the msdos file system. Of course they remain empty.
853 * One strategy was to create those files only in the EMD file
854 * since they were not important for MSDOS. The problem with
855 * that, is that there were not getting inode number allocated.
856 * The MSDOS filesystems is playing a nice game to fake inode
857 * number, so why not use it.
859 * The absence of inode number compatible with those allocated
860 * for ordinary files was causing major trouble with hard link
861 * in particular and other parts of the kernel I guess.
863 int UMSDOS_mknod (struct inode *dir, struct dentry *dentry,
864 int mode, dev_t rdev)
866 return umsdos_create_any (dir, dentry, mode, rdev, 0);
870 * Remove a sub-directory.
872 int UMSDOS_rmdir (struct inode *dir, struct dentry *dentry)
876 struct umsdos_info info;
878 ret = umsdos_nevercreat (dir, dentry, -EPERM);
883 if (!d_unhashed(dentry))
886 /* check whether the EMD is empty */
888 empty = umsdos_isempty (dentry);
890 /* Have to remove the EMD file? */
894 demd = umsdos_get_emd_dentry(dentry);
898 err = msdos_unlink (dentry->d_inode, demd);
899 Printk (("UMSDOS_rmdir: unlinking empty EMD err=%d", err));
900 #ifdef UMSDOS_PARANOIA
902 printk("umsdos_rmdir: EMD %s/%s unlink failed, err=%d\n",
903 demd->d_parent->d_name.name, demd->d_name.name, err);
911 } else if (empty == 2)
916 umsdos_parse (dentry->d_name.name, dentry->d_name.len, &info);
917 /* Call findentry to complete the mangling */
918 umsdos_findentry (dentry->d_parent, &info, 2);
919 temp = umsdos_covered(dentry->d_parent, info.fake.fname, info.fake.len);
924 * Attempt to remove the msdos name.
926 ret = msdos_rmdir (dir, temp);
927 if (ret && ret != -ENOENT)
931 /* OK so far ... remove the name from the EMD */
932 ret = umsdos_delentry (dentry->d_parent, &info, 1);
933 #ifdef UMSDOS_PARANOIA
935 printk("umsdos_rmdir: delentry %s failed, ret=%d\n", info.entry.name, ret);
938 /* dput() temp if we didn't do it above */
943 Printk (("umsdos_rmdir %d\n", ret));
949 * Remove a file from the directory.
951 * #Specification: hard link / deleting a link
952 * When we delete a file and this file is a link,
953 * we must subtract 1 from the nlink field of the
956 * If the count goes to 0, we delete this hidden
959 int UMSDOS_unlink (struct inode *dir, struct dentry *dentry)
961 struct dentry *temp, *link = NULL;
964 struct umsdos_info info;
966 Printk(("UMSDOS_unlink: entering %s/%s\n",
967 dentry->d_parent->d_name.name, dentry->d_name.name));
969 ret = umsdos_nevercreat (dir, dentry, -EPERM);
973 ret = umsdos_parse (dentry->d_name.name, dentry->d_name.len, &info);
977 umsdos_lockcreate (dir);
978 ret = umsdos_findentry (dentry->d_parent, &info, 1);
980 printk("UMSDOS_unlink: %s/%s not in EMD, ret=%d\n",
981 dentry->d_parent->d_name.name, dentry->d_name.name, ret);
985 Printk (("UMSDOS_unlink %.*s ", info.fake.len, info.fake.fname));
988 * Note! If this is a hardlink and the names are aliased,
989 * the short-name lookup will return the hardlink dentry.
990 * In order to get the correct (real) inode, we just drop
991 * the original dentry.
993 if (info.entry.flags & UMSDOS_HLINK) {
997 /* Do a real lookup to get the short name dentry */
998 temp = umsdos_covered(dentry->d_parent, info.fake.fname, info.fake.len);
1004 * Resolve hardlinks now, but defer processing until later.
1006 if (info.entry.flags & UMSDOS_HLINK) {
1007 link = umsdos_solve_hlink(dget(temp));
1010 /* Delete the EMD entry */
1011 ret = umsdos_delentry (dentry->d_parent, &info, 0);
1012 if (ret && ret != -ENOENT) {
1013 printk(KERN_WARNING "UMSDOS_unlink: delentry %s, error=%d\n",
1014 info.entry.name, ret);
1018 ret = msdos_unlink(dir, temp);
1021 #ifdef UMSDOS_PARANOIA
1023 printk("umsdos_unlink: %s/%s unlink failed, ret=%d\n",
1024 temp->d_parent->d_name.name, temp->d_name.name, ret);
1027 /* dput() temp if we didn't do it above */
1032 umsdos_unlockcreate (dir);
1035 * Now check for deferred handling of a hardlink.
1041 printk("umsdos_unlink: failed to resolve %s/%s\n",
1042 dentry->d_parent->d_name.name, dentry->d_name.name);
1044 ret = PTR_ERR(link);
1048 Printk(("umsdos_unlink: link %s/%s deferred, pending ret=%d\n",
1049 link->d_parent->d_name.name, link->d_name.name, ret));
1051 /* already have an error? */
1055 /* make sure the link exists ... */
1056 inode = link->d_inode;
1058 printk(KERN_WARNING "umsdos_unlink: hard link not found\n");
1063 * If this was the last linked reference, delete it now.
1065 * N.B. Deadlock problem? We should be holding the lock
1066 * for the hardlink's parent, but another process might
1067 * be holding that lock waiting for us to finish ...
1069 if (inode->i_nlink <= 1) {
1070 ret = UMSDOS_unlink (link->d_parent->d_inode, link);
1073 "umsdos_unlink: link removal failed, ret=%d\n",
1078 struct iattr newattrs;
1080 newattrs.ia_valid = 0;
1081 ret = umsdos_notify_change_locked(link, &newattrs);
1083 mark_inode_dirty(link->d_inode);
1091 Printk (("umsdos_unlink %d\n", ret));
1096 * Rename (move) a file.
1098 int UMSDOS_rename (struct inode *old_dir, struct dentry *old_dentry,
1099 struct inode *new_dir, struct dentry *new_dentry)
1103 ret = umsdos_nevercreat (new_dir, new_dentry, -EEXIST);
1108 * If the target already exists, delete it first.
1110 if (new_dentry->d_inode) {
1112 if (S_ISDIR(old_dentry->d_inode->i_mode))
1113 ret = UMSDOS_rmdir (new_dir, new_dentry);
1115 ret = UMSDOS_unlink (new_dir, new_dentry);
1122 ret = umsdos_rename_f(old_dir, old_dentry, new_dir, new_dentry, 0);