vfs: push dentry_unhash on rename_dir into file systems
[linux-3.10.git] / fs / hpfs / namei.c
1 /*
2  *  linux/fs/hpfs/namei.c
3  *
4  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5  *
6  *  adding & removing files & directories
7  */
8 #include <linux/sched.h>
9 #include "hpfs_fn.h"
10
11 static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
12 {
13         const unsigned char *name = dentry->d_name.name;
14         unsigned len = dentry->d_name.len;
15         struct quad_buffer_head qbh0;
16         struct buffer_head *bh;
17         struct hpfs_dirent *de;
18         struct fnode *fnode;
19         struct dnode *dnode;
20         struct inode *result;
21         fnode_secno fno;
22         dnode_secno dno;
23         int r;
24         struct hpfs_dirent dee;
25         int err;
26         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
27         hpfs_lock(dir->i_sb);
28         err = -ENOSPC;
29         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
30         if (!fnode)
31                 goto bail;
32         dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
33         if (!dnode)
34                 goto bail1;
35         memset(&dee, 0, sizeof dee);
36         dee.directory = 1;
37         if (!(mode & 0222)) dee.read_only = 1;
38         /*dee.archive = 0;*/
39         dee.hidden = name[0] == '.';
40         dee.fnode = fno;
41         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
42         result = new_inode(dir->i_sb);
43         if (!result)
44                 goto bail2;
45         hpfs_init_inode(result);
46         result->i_ino = fno;
47         hpfs_i(result)->i_parent_dir = dir->i_ino;
48         hpfs_i(result)->i_dno = dno;
49         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
50         result->i_ctime.tv_nsec = 0; 
51         result->i_mtime.tv_nsec = 0; 
52         result->i_atime.tv_nsec = 0; 
53         hpfs_i(result)->i_ea_size = 0;
54         result->i_mode |= S_IFDIR;
55         result->i_op = &hpfs_dir_iops;
56         result->i_fop = &hpfs_dir_ops;
57         result->i_blocks = 4;
58         result->i_size = 2048;
59         result->i_nlink = 2;
60         if (dee.read_only)
61                 result->i_mode &= ~0222;
62
63         mutex_lock(&hpfs_i(dir)->i_mutex);
64         r = hpfs_add_dirent(dir, name, len, &dee, 0);
65         if (r == 1)
66                 goto bail3;
67         if (r == -1) {
68                 err = -EEXIST;
69                 goto bail3;
70         }
71         fnode->len = len;
72         memcpy(fnode->name, name, len > 15 ? 15 : len);
73         fnode->up = dir->i_ino;
74         fnode->dirflag = 1;
75         fnode->btree.n_free_nodes = 7;
76         fnode->btree.n_used_nodes = 1;
77         fnode->btree.first_free = 0x14;
78         fnode->u.external[0].disk_secno = dno;
79         fnode->u.external[0].file_secno = -1;
80         dnode->root_dnode = 1;
81         dnode->up = fno;
82         de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
83         de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
84         if (!(mode & 0222)) de->read_only = 1;
85         de->first = de->directory = 1;
86         /*de->hidden = de->system = 0;*/
87         de->fnode = fno;
88         mark_buffer_dirty(bh);
89         brelse(bh);
90         hpfs_mark_4buffers_dirty(&qbh0);
91         hpfs_brelse4(&qbh0);
92         inc_nlink(dir);
93         insert_inode_hash(result);
94
95         if (result->i_uid != current_fsuid() ||
96             result->i_gid != current_fsgid() ||
97             result->i_mode != (mode | S_IFDIR)) {
98                 result->i_uid = current_fsuid();
99                 result->i_gid = current_fsgid();
100                 result->i_mode = mode | S_IFDIR;
101                 hpfs_write_inode_nolock(result);
102         }
103         d_instantiate(dentry, result);
104         mutex_unlock(&hpfs_i(dir)->i_mutex);
105         hpfs_unlock(dir->i_sb);
106         return 0;
107 bail3:
108         mutex_unlock(&hpfs_i(dir)->i_mutex);
109         iput(result);
110 bail2:
111         hpfs_brelse4(&qbh0);
112         hpfs_free_dnode(dir->i_sb, dno);
113 bail1:
114         brelse(bh);
115         hpfs_free_sectors(dir->i_sb, fno, 1);
116 bail:
117         hpfs_unlock(dir->i_sb);
118         return err;
119 }
120
121 static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
122 {
123         const unsigned char *name = dentry->d_name.name;
124         unsigned len = dentry->d_name.len;
125         struct inode *result = NULL;
126         struct buffer_head *bh;
127         struct fnode *fnode;
128         fnode_secno fno;
129         int r;
130         struct hpfs_dirent dee;
131         int err;
132         if ((err = hpfs_chk_name(name, &len)))
133                 return err==-ENOENT ? -EINVAL : err;
134         hpfs_lock(dir->i_sb);
135         err = -ENOSPC;
136         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
137         if (!fnode)
138                 goto bail;
139         memset(&dee, 0, sizeof dee);
140         if (!(mode & 0222)) dee.read_only = 1;
141         dee.archive = 1;
142         dee.hidden = name[0] == '.';
143         dee.fnode = fno;
144         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
145
146         result = new_inode(dir->i_sb);
147         if (!result)
148                 goto bail1;
149         
150         hpfs_init_inode(result);
151         result->i_ino = fno;
152         result->i_mode |= S_IFREG;
153         result->i_mode &= ~0111;
154         result->i_op = &hpfs_file_iops;
155         result->i_fop = &hpfs_file_ops;
156         result->i_nlink = 1;
157         hpfs_decide_conv(result, name, len);
158         hpfs_i(result)->i_parent_dir = dir->i_ino;
159         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
160         result->i_ctime.tv_nsec = 0;
161         result->i_mtime.tv_nsec = 0;
162         result->i_atime.tv_nsec = 0;
163         hpfs_i(result)->i_ea_size = 0;
164         if (dee.read_only)
165                 result->i_mode &= ~0222;
166         result->i_blocks = 1;
167         result->i_size = 0;
168         result->i_data.a_ops = &hpfs_aops;
169         hpfs_i(result)->mmu_private = 0;
170
171         mutex_lock(&hpfs_i(dir)->i_mutex);
172         r = hpfs_add_dirent(dir, name, len, &dee, 0);
173         if (r == 1)
174                 goto bail2;
175         if (r == -1) {
176                 err = -EEXIST;
177                 goto bail2;
178         }
179         fnode->len = len;
180         memcpy(fnode->name, name, len > 15 ? 15 : len);
181         fnode->up = dir->i_ino;
182         mark_buffer_dirty(bh);
183         brelse(bh);
184
185         insert_inode_hash(result);
186
187         if (result->i_uid != current_fsuid() ||
188             result->i_gid != current_fsgid() ||
189             result->i_mode != (mode | S_IFREG)) {
190                 result->i_uid = current_fsuid();
191                 result->i_gid = current_fsgid();
192                 result->i_mode = mode | S_IFREG;
193                 hpfs_write_inode_nolock(result);
194         }
195         d_instantiate(dentry, result);
196         mutex_unlock(&hpfs_i(dir)->i_mutex);
197         hpfs_unlock(dir->i_sb);
198         return 0;
199
200 bail2:
201         mutex_unlock(&hpfs_i(dir)->i_mutex);
202         iput(result);
203 bail1:
204         brelse(bh);
205         hpfs_free_sectors(dir->i_sb, fno, 1);
206 bail:
207         hpfs_unlock(dir->i_sb);
208         return err;
209 }
210
211 static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
212 {
213         const unsigned char *name = dentry->d_name.name;
214         unsigned len = dentry->d_name.len;
215         struct buffer_head *bh;
216         struct fnode *fnode;
217         fnode_secno fno;
218         int r;
219         struct hpfs_dirent dee;
220         struct inode *result = NULL;
221         int err;
222         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
223         if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
224         if (!new_valid_dev(rdev))
225                 return -EINVAL;
226         hpfs_lock(dir->i_sb);
227         err = -ENOSPC;
228         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
229         if (!fnode)
230                 goto bail;
231         memset(&dee, 0, sizeof dee);
232         if (!(mode & 0222)) dee.read_only = 1;
233         dee.archive = 1;
234         dee.hidden = name[0] == '.';
235         dee.fnode = fno;
236         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
237
238         result = new_inode(dir->i_sb);
239         if (!result)
240                 goto bail1;
241
242         hpfs_init_inode(result);
243         result->i_ino = fno;
244         hpfs_i(result)->i_parent_dir = dir->i_ino;
245         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
246         result->i_ctime.tv_nsec = 0;
247         result->i_mtime.tv_nsec = 0;
248         result->i_atime.tv_nsec = 0;
249         hpfs_i(result)->i_ea_size = 0;
250         result->i_uid = current_fsuid();
251         result->i_gid = current_fsgid();
252         result->i_nlink = 1;
253         result->i_size = 0;
254         result->i_blocks = 1;
255         init_special_inode(result, mode, rdev);
256
257         mutex_lock(&hpfs_i(dir)->i_mutex);
258         r = hpfs_add_dirent(dir, name, len, &dee, 0);
259         if (r == 1)
260                 goto bail2;
261         if (r == -1) {
262                 err = -EEXIST;
263                 goto bail2;
264         }
265         fnode->len = len;
266         memcpy(fnode->name, name, len > 15 ? 15 : len);
267         fnode->up = dir->i_ino;
268         mark_buffer_dirty(bh);
269
270         insert_inode_hash(result);
271
272         hpfs_write_inode_nolock(result);
273         d_instantiate(dentry, result);
274         mutex_unlock(&hpfs_i(dir)->i_mutex);
275         brelse(bh);
276         hpfs_unlock(dir->i_sb);
277         return 0;
278 bail2:
279         mutex_unlock(&hpfs_i(dir)->i_mutex);
280         iput(result);
281 bail1:
282         brelse(bh);
283         hpfs_free_sectors(dir->i_sb, fno, 1);
284 bail:
285         hpfs_unlock(dir->i_sb);
286         return err;
287 }
288
289 static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
290 {
291         const unsigned char *name = dentry->d_name.name;
292         unsigned len = dentry->d_name.len;
293         struct buffer_head *bh;
294         struct fnode *fnode;
295         fnode_secno fno;
296         int r;
297         struct hpfs_dirent dee;
298         struct inode *result;
299         int err;
300         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
301         hpfs_lock(dir->i_sb);
302         if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
303                 hpfs_unlock(dir->i_sb);
304                 return -EPERM;
305         }
306         err = -ENOSPC;
307         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
308         if (!fnode)
309                 goto bail;
310         memset(&dee, 0, sizeof dee);
311         dee.archive = 1;
312         dee.hidden = name[0] == '.';
313         dee.fnode = fno;
314         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
315
316         result = new_inode(dir->i_sb);
317         if (!result)
318                 goto bail1;
319         result->i_ino = fno;
320         hpfs_init_inode(result);
321         hpfs_i(result)->i_parent_dir = dir->i_ino;
322         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
323         result->i_ctime.tv_nsec = 0;
324         result->i_mtime.tv_nsec = 0;
325         result->i_atime.tv_nsec = 0;
326         hpfs_i(result)->i_ea_size = 0;
327         result->i_mode = S_IFLNK | 0777;
328         result->i_uid = current_fsuid();
329         result->i_gid = current_fsgid();
330         result->i_blocks = 1;
331         result->i_nlink = 1;
332         result->i_size = strlen(symlink);
333         result->i_op = &page_symlink_inode_operations;
334         result->i_data.a_ops = &hpfs_symlink_aops;
335
336         mutex_lock(&hpfs_i(dir)->i_mutex);
337         r = hpfs_add_dirent(dir, name, len, &dee, 0);
338         if (r == 1)
339                 goto bail2;
340         if (r == -1) {
341                 err = -EEXIST;
342                 goto bail2;
343         }
344         fnode->len = len;
345         memcpy(fnode->name, name, len > 15 ? 15 : len);
346         fnode->up = dir->i_ino;
347         hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
348         mark_buffer_dirty(bh);
349         brelse(bh);
350
351         insert_inode_hash(result);
352
353         hpfs_write_inode_nolock(result);
354         d_instantiate(dentry, result);
355         mutex_unlock(&hpfs_i(dir)->i_mutex);
356         hpfs_unlock(dir->i_sb);
357         return 0;
358 bail2:
359         mutex_unlock(&hpfs_i(dir)->i_mutex);
360         iput(result);
361 bail1:
362         brelse(bh);
363         hpfs_free_sectors(dir->i_sb, fno, 1);
364 bail:
365         hpfs_unlock(dir->i_sb);
366         return err;
367 }
368
369 static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
370 {
371         const unsigned char *name = dentry->d_name.name;
372         unsigned len = dentry->d_name.len;
373         struct quad_buffer_head qbh;
374         struct hpfs_dirent *de;
375         struct inode *inode = dentry->d_inode;
376         dnode_secno dno;
377         fnode_secno fno;
378         int r;
379         int rep = 0;
380         int err;
381
382         hpfs_lock(dir->i_sb);
383         hpfs_adjust_length(name, &len);
384 again:
385         mutex_lock(&hpfs_i(inode)->i_parent_mutex);
386         mutex_lock(&hpfs_i(dir)->i_mutex);
387         err = -ENOENT;
388         de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
389         if (!de)
390                 goto out;
391
392         err = -EPERM;
393         if (de->first)
394                 goto out1;
395
396         err = -EISDIR;
397         if (de->directory)
398                 goto out1;
399
400         fno = de->fnode;
401         r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
402         switch (r) {
403         case 1:
404                 hpfs_error(dir->i_sb, "there was error when removing dirent");
405                 err = -EFSERROR;
406                 break;
407         case 2:         /* no space for deleting, try to truncate file */
408
409                 err = -ENOSPC;
410                 if (rep++)
411                         break;
412
413                 mutex_unlock(&hpfs_i(dir)->i_mutex);
414                 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
415                 dentry_unhash(dentry);
416                 if (!d_unhashed(dentry)) {
417                         hpfs_unlock(dir->i_sb);
418                         return -ENOSPC;
419                 }
420                 if (generic_permission(inode, MAY_WRITE, 0, NULL) ||
421                     !S_ISREG(inode->i_mode) ||
422                     get_write_access(inode)) {
423                         d_rehash(dentry);
424                 } else {
425                         struct iattr newattrs;
426                         /*printk("HPFS: truncating file before delete.\n");*/
427                         newattrs.ia_size = 0;
428                         newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
429                         err = notify_change(dentry, &newattrs);
430                         put_write_access(inode);
431                         if (!err)
432                                 goto again;
433                 }
434                 hpfs_unlock(dir->i_sb);
435                 return -ENOSPC;
436         default:
437                 drop_nlink(inode);
438                 err = 0;
439         }
440         goto out;
441
442 out1:
443         hpfs_brelse4(&qbh);
444 out:
445         mutex_unlock(&hpfs_i(dir)->i_mutex);
446         mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
447         hpfs_unlock(dir->i_sb);
448         return err;
449 }
450
451 static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
452 {
453         const unsigned char *name = dentry->d_name.name;
454         unsigned len = dentry->d_name.len;
455         struct quad_buffer_head qbh;
456         struct hpfs_dirent *de;
457         struct inode *inode = dentry->d_inode;
458         dnode_secno dno;
459         fnode_secno fno;
460         int n_items = 0;
461         int err;
462         int r;
463
464         dentry_unhash(dentry);
465
466         hpfs_adjust_length(name, &len);
467         hpfs_lock(dir->i_sb);
468         mutex_lock(&hpfs_i(inode)->i_parent_mutex);
469         mutex_lock(&hpfs_i(dir)->i_mutex);
470         err = -ENOENT;
471         de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
472         if (!de)
473                 goto out;
474
475         err = -EPERM;
476         if (de->first)
477                 goto out1;
478
479         err = -ENOTDIR;
480         if (!de->directory)
481                 goto out1;
482
483         hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
484         err = -ENOTEMPTY;
485         if (n_items)
486                 goto out1;
487
488         fno = de->fnode;
489         r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
490         switch (r) {
491         case 1:
492                 hpfs_error(dir->i_sb, "there was error when removing dirent");
493                 err = -EFSERROR;
494                 break;
495         case 2:
496                 err = -ENOSPC;
497                 break;
498         default:
499                 drop_nlink(dir);
500                 clear_nlink(inode);
501                 err = 0;
502         }
503         goto out;
504 out1:
505         hpfs_brelse4(&qbh);
506 out:
507         mutex_unlock(&hpfs_i(dir)->i_mutex);
508         mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
509         hpfs_unlock(dir->i_sb);
510         return err;
511 }
512
513 static int hpfs_symlink_readpage(struct file *file, struct page *page)
514 {
515         char *link = kmap(page);
516         struct inode *i = page->mapping->host;
517         struct fnode *fnode;
518         struct buffer_head *bh;
519         int err;
520
521         err = -EIO;
522         hpfs_lock(i->i_sb);
523         if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
524                 goto fail;
525         err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
526         brelse(bh);
527         if (err)
528                 goto fail;
529         hpfs_unlock(i->i_sb);
530         SetPageUptodate(page);
531         kunmap(page);
532         unlock_page(page);
533         return 0;
534
535 fail:
536         hpfs_unlock(i->i_sb);
537         SetPageError(page);
538         kunmap(page);
539         unlock_page(page);
540         return err;
541 }
542
543 const struct address_space_operations hpfs_symlink_aops = {
544         .readpage       = hpfs_symlink_readpage
545 };
546         
547 static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
548                 struct inode *new_dir, struct dentry *new_dentry)
549 {
550         const unsigned char *old_name = old_dentry->d_name.name;
551         unsigned old_len = old_dentry->d_name.len;
552         const unsigned char *new_name = new_dentry->d_name.name;
553         unsigned new_len = new_dentry->d_name.len;
554         struct inode *i = old_dentry->d_inode;
555         struct inode *new_inode = new_dentry->d_inode;
556         struct quad_buffer_head qbh, qbh1;
557         struct hpfs_dirent *dep, *nde;
558         struct hpfs_dirent de;
559         dnode_secno dno;
560         int r;
561         struct buffer_head *bh;
562         struct fnode *fnode;
563         int err;
564
565         if (new_inode && S_ISDIR(new_inode->i_mode))
566                 dentry_unhash(new_dentry);
567
568         if ((err = hpfs_chk_name(new_name, &new_len))) return err;
569         err = 0;
570         hpfs_adjust_length(old_name, &old_len);
571
572         hpfs_lock(i->i_sb);
573         /* order doesn't matter, due to VFS exclusion */
574         mutex_lock(&hpfs_i(i)->i_parent_mutex);
575         if (new_inode)
576                 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
577         mutex_lock(&hpfs_i(old_dir)->i_mutex);
578         if (new_dir != old_dir)
579                 mutex_lock(&hpfs_i(new_dir)->i_mutex);
580         
581         /* Erm? Moving over the empty non-busy directory is perfectly legal */
582         if (new_inode && S_ISDIR(new_inode->i_mode)) {
583                 err = -EINVAL;
584                 goto end1;
585         }
586
587         if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
588                 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
589                 err = -ENOENT;
590                 goto end1;
591         }
592         copy_de(&de, dep);
593         de.hidden = new_name[0] == '.';
594
595         if (new_inode) {
596                 int r;
597                 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
598                         if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
599                                 clear_nlink(new_inode);
600                                 copy_de(nde, &de);
601                                 memcpy(nde->name, new_name, new_len);
602                                 hpfs_mark_4buffers_dirty(&qbh1);
603                                 hpfs_brelse4(&qbh1);
604                                 goto end;
605                         }
606                         hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
607                         err = -EFSERROR;
608                         goto end1;
609                 }
610                 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
611                 goto end1;
612         }
613
614         if (new_dir == old_dir) hpfs_brelse4(&qbh);
615
616         hpfs_lock_creation(i->i_sb);
617         if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
618                 hpfs_unlock_creation(i->i_sb);
619                 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
620                 err = r == 1 ? -ENOSPC : -EFSERROR;
621                 if (new_dir != old_dir) hpfs_brelse4(&qbh);
622                 goto end1;
623         }
624         
625         if (new_dir == old_dir)
626                 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
627                         hpfs_unlock_creation(i->i_sb);
628                         hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
629                         err = -ENOENT;
630                         goto end1;
631                 }
632
633         if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
634                 hpfs_unlock_creation(i->i_sb);
635                 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
636                 err = r == 2 ? -ENOSPC : -EFSERROR;
637                 goto end1;
638         }
639         hpfs_unlock_creation(i->i_sb);
640         
641         end:
642         hpfs_i(i)->i_parent_dir = new_dir->i_ino;
643         if (S_ISDIR(i->i_mode)) {
644                 inc_nlink(new_dir);
645                 drop_nlink(old_dir);
646         }
647         if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
648                 fnode->up = new_dir->i_ino;
649                 fnode->len = new_len;
650                 memcpy(fnode->name, new_name, new_len>15?15:new_len);
651                 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
652                 mark_buffer_dirty(bh);
653                 brelse(bh);
654         }
655         hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
656         hpfs_decide_conv(i, new_name, new_len);
657 end1:
658         if (old_dir != new_dir)
659                 mutex_unlock(&hpfs_i(new_dir)->i_mutex);
660         mutex_unlock(&hpfs_i(old_dir)->i_mutex);
661         mutex_unlock(&hpfs_i(i)->i_parent_mutex);
662         if (new_inode)
663                 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
664         hpfs_unlock(i->i_sb);
665         return err;
666 }
667
668 const struct inode_operations hpfs_dir_iops =
669 {
670         .create         = hpfs_create,
671         .lookup         = hpfs_lookup,
672         .unlink         = hpfs_unlink,
673         .symlink        = hpfs_symlink,
674         .mkdir          = hpfs_mkdir,
675         .rmdir          = hpfs_rmdir,
676         .mknod          = hpfs_mknod,
677         .rename         = hpfs_rename,
678         .setattr        = hpfs_setattr,
679 };