Whamcloud - gitweb
Added code for obdfs to do writes to files and reads of directories and
[fs/lustre-release.git] / lustre / obdfs / namei.c
1 /*
2  *  linux/fs/ext2/namei.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  *  from
10  *
11  *  linux/fs/minix/namei.c
12  *
13  *  Copyright (C) 1991, 1992  Linus Torvalds
14  *
15  *  Big-endian to little-endian byte-swapping/bitmaps by
16  *        David S. Miller (davem@caip.rutgers.edu), 1995
17  *  Directory entry file type support and forward compatibility hooks
18  *      for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
19  * 
20  *  Changes for use in OBDFS
21  *  Copyright (c) 1999, Seagate Technology Inc.
22  * 
23  */
24
25 #include <asm/uaccess.h>
26
27 #include <linux/errno.h>
28 #include <linux/fs.h>
29 #include <linux/ext2_fs.h>
30 #include <linux/fcntl.h>
31 #include <linux/sched.h>
32 #include <linux/stat.h>
33 #include <linux/string.h>
34 #include <linux/locks.h>
35 #include <linux/quotaops.h>
36 #include <linux/iobuf.h>
37 #include "obdfs.h"
38
39 /*
40  * define how far ahead to read directories while searching them.
41  */
42 #define NAMEI_RA_CHUNKS  2
43 #define NAMEI_RA_BLOCKS  4
44 #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
45 #define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
46
47 /*
48  * NOTE! unlike strncmp, ext2_match returns 1 for success, 0 for failure.
49  *
50  * `len <= EXT2_NAME_LEN' is guaranteed by caller.
51  * `de != NULL' is guaranteed by caller.
52  */
53 static inline int ext2_match (int len, const char * const name,
54                        struct ext2_dir_entry_2 * de)
55 {
56         if (len != de->name_len)
57                 return 0;
58         if (!de->inode)
59                 return 0;
60         return !memcmp(name, de->name, len);
61 }
62
63 /*
64  *      ext2_find_entry()
65  *
66  * finds an entry in the specified directory with the wanted name. It
67  * returns the cache buffer in which the entry was found, and the entry
68  * itself (as a parameter - res_dir). It does NOT read the inode of the
69  * entry - you'll have to do that yourself if you want to.
70  */
71 struct page * obdfs_find_entry (struct inode * dir,
72                                              const char * const name, int namelen,
73                                              struct ext2_dir_entry_2 ** res_dir)
74 {
75         struct super_block * sb;
76         unsigned long offset;
77         struct page * page;
78
79         *res_dir = NULL;
80         sb = dir->i_sb;
81
82         if (namelen > EXT2_NAME_LEN)
83                 return NULL;
84
85         for (page = 0, offset = 0; offset < dir->i_size; page++) {
86                 struct ext2_dir_entry_2 * de;
87                 char * dlimit;
88
89                 page = obdfs_getpage(dir, offset);
90
91                 de = (struct ext2_dir_entry_2 *) page_address(page);
92                 dlimit = (char *)page_address(page) + PAGE_SIZE; 
93                 while ((char *) de < dlimit) {
94                         /* this code is executed quadratically often */
95                         /* do minimal checking `by hand' */
96                         int de_len;
97
98                         if ((char *) de + namelen <= dlimit &&
99                             ext2_match (namelen, name, de)) {
100                                 /* found a match -
101                                    just to be sure, do a full check */
102 #if 0
103                                 if (!ext2_check_dir_entry("ext2_find_entry",
104                                                           dir, de, bh, offset))
105                                         goto failure;
106 #endif
107                                 *res_dir = de;
108                                 return page;
109                         }
110                         /* prevent looping on a bad block */
111                         de_len = le16_to_cpu(de->rec_len);
112                         if (de_len <= 0)
113                                 goto failure;
114                         offset += de_len;
115                         de = (struct ext2_dir_entry_2 *)
116                                 ((char *) de + de_len);
117                 }
118                 page_cache_release(page);
119         }
120
121 failure:
122         return NULL;
123 }
124
125 struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
126 {
127         struct inode * inode;
128         struct ext2_dir_entry_2 * de;
129         struct page * page;
130
131         if (dentry->d_name.len > EXT2_NAME_LEN)
132                 return ERR_PTR(-ENAMETOOLONG);
133
134         page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
135         inode = NULL;
136         if (page) {
137                 unsigned long ino = le32_to_cpu(de->inode);
138                 page_cache_release(page);
139                 inode = iget(dir->i_sb, ino);
140
141                 if (!inode)
142                         return ERR_PTR(-EACCES);
143         }
144         d_add(dentry, inode);
145         return NULL;
146 }
147
148
149 #if 0
150 /*
151  *      ext2_add_entry()
152  *
153  * adds a file entry to the specified directory, using the same
154  * semantics as ext2_find_entry(). It returns NULL if it failed.
155  *
156  * NOTE!! The inode part of 'de' is left at 0 - which means you
157  * may not sleep between calling this and putting something into
158  * the entry, as someone else might have used it while you slept.
159  */
160 static struct buffer_head * ext2_add_entry (struct inode * dir,
161                                             const char * name, int namelen,
162                                             struct ext2_dir_entry_2 ** res_dir,
163                                             int *err)
164 {
165         unsigned long offset;
166         unsigned short rec_len;
167         struct buffer_head * bh;
168         struct ext2_dir_entry_2 * de, * de1;
169         struct super_block * sb;
170
171         *err = -EINVAL;
172         *res_dir = NULL;
173         if (!dir || !dir->i_nlink)
174                 return NULL;
175         sb = dir->i_sb;
176
177         if (!namelen)
178                 return NULL;
179         /*
180          * Is this a busy deleted directory?  Can't create new files if so
181          */
182         if (dir->i_size == 0)
183         {
184                 *err = -ENOENT;
185                 return NULL;
186         }
187         bh = ext2_bread (dir, 0, 0, err);
188         if (!bh)
189                 return NULL;
190         rec_len = EXT2_DIR_REC_LEN(namelen);
191         offset = 0;
192         de = (struct ext2_dir_entry_2 *) bh->b_data;
193         *err = -ENOSPC;
194         while (1) {
195                 if ((char *)de >= sb->s_blocksize + bh->b_data) {
196                         brelse (bh);
197                         bh = NULL;
198                         bh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
199                         if (!bh)
200                                 return NULL;
201                         if (dir->i_size <= offset) {
202                                 if (dir->i_size == 0) {
203                                         *err = -ENOENT;
204                                         return NULL;
205                                 }
206
207                                 ext2_debug ("creating next block\n");
208
209                                 de = (struct ext2_dir_entry_2 *) bh->b_data;
210                                 de->inode = 0;
211                                 de->rec_len = le16_to_cpu(sb->s_blocksize);
212                                 dir->i_size = offset + sb->s_blocksize;
213                                 dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
214                                 mark_inode_dirty(dir);
215                         } else {
216
217                                 ext2_debug ("skipping to next block\n");
218
219                                 de = (struct ext2_dir_entry_2 *) bh->b_data;
220                         }
221                 }
222                 if (!ext2_check_dir_entry ("ext2_add_entry", dir, de, bh,
223                                            offset)) {
224                         *err = -ENOENT;
225                         brelse (bh);
226                         return NULL;
227                 }
228                 if (ext2_match (namelen, name, de)) {
229                                 *err = -EEXIST;
230                                 brelse (bh);
231                                 return NULL;
232                 }
233                 if ((le32_to_cpu(de->inode) == 0 && le16_to_cpu(de->rec_len) >= rec_len) ||
234                     (le16_to_cpu(de->rec_len) >= EXT2_DIR_REC_LEN(de->name_len) + rec_len)) {
235                         offset += le16_to_cpu(de->rec_len);
236                         if (le32_to_cpu(de->inode)) {
237                                 de1 = (struct ext2_dir_entry_2 *) ((char *) de +
238                                         EXT2_DIR_REC_LEN(de->name_len));
239                                 de1->rec_len = cpu_to_le16(le16_to_cpu(de->rec_len) -
240                                         EXT2_DIR_REC_LEN(de->name_len));
241                                 de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
242                                 de = de1;
243                         }
244                         de->inode = 0;
245                         de->name_len = namelen;
246                         de->file_type = 0;
247                         memcpy (de->name, name, namelen);
248                         /*
249                          * XXX shouldn't update any times until successful
250                          * completion of syscall, but too many callers depend
251                          * on this.
252                          *
253                          * XXX similarly, too many callers depend on
254                          * ext2_new_inode() setting the times, but error
255                          * recovery deletes the inode, so the worst that can
256                          * happen is that the times are slightly out of date
257                          * and/or different from the directory change time.
258                          */
259                         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
260                         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
261                         mark_inode_dirty(dir);
262                         dir->i_version = ++event;
263                         mark_buffer_dirty(bh, 1);
264                         *res_dir = de;
265                         *err = 0;
266                         return bh;
267                 }
268                 offset += le16_to_cpu(de->rec_len);
269                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
270         }
271         brelse (bh);
272         return NULL;
273 }
274
275 /*
276  * ext2_delete_entry deletes a directory entry by merging it with the
277  * previous entry
278  */
279 static int ext2_delete_entry (struct ext2_dir_entry_2 * dir,
280                               struct buffer_head * bh)
281 {
282         struct ext2_dir_entry_2 * de, * pde;
283         int i;
284
285         i = 0;
286         pde = NULL;
287         de = (struct ext2_dir_entry_2 *) bh->b_data;
288         while (i < bh->b_size) {
289                 if (!ext2_check_dir_entry ("ext2_delete_entry", NULL, 
290                                            de, bh, i))
291                         return -EIO;
292                 if (de == dir)  {
293                         if (pde)
294                                 pde->rec_len =
295                                         cpu_to_le16(le16_to_cpu(pde->rec_len) +
296                                                     le16_to_cpu(dir->rec_len));
297                         else
298                                 dir->inode = 0;
299                         return 0;
300                 }
301                 i += le16_to_cpu(de->rec_len);
302                 pde = de;
303                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
304         }
305         return -ENOENT;
306 }
307
308 static inline void ext2_set_de_type(struct super_block *sb,
309                                 struct ext2_dir_entry_2 *de,
310                                 umode_t mode) {
311         if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_FILETYPE))
312                 return;
313         if (S_ISCHR(mode))
314                 de->file_type = EXT2_FT_CHRDEV;
315         else if (S_ISBLK(mode))
316                 de->file_type = EXT2_FT_BLKDEV;
317         else if (S_ISFIFO(mode))  
318                 de->file_type = EXT2_FT_FIFO;
319         else if (S_ISLNK(mode))
320                 de->file_type = EXT2_FT_SYMLINK;
321         else if (S_ISREG(mode))
322                 de->file_type = EXT2_FT_REG_FILE;
323         else if (S_ISDIR(mode))  
324                 de->file_type = EXT2_FT_DIR;
325 }
326
327 /*
328  * By the time this is called, we already have created
329  * the directory cache entry for the new file, but it
330  * is so far negative - it has no inode.
331  *
332  * If the create succeeds, we fill in the inode information
333  * with d_instantiate(). 
334  */
335 int ext2_create (struct inode * dir, struct dentry * dentry, int mode)
336 {
337         struct inode * inode;
338         struct buffer_head * bh;
339         struct ext2_dir_entry_2 * de;
340         int err = -EIO;
341
342         /*
343          * N.B. Several error exits in ext2_new_inode don't set err.
344          */
345         inode = ext2_new_inode (dir, mode, &err);
346         if (!inode)
347                 return err;
348
349         inode->i_op = &ext2_file_inode_operations;
350         inode->i_mode = mode;
351         mark_inode_dirty(inode);
352         bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
353         if (!bh) {
354                 inode->i_nlink--;
355                 mark_inode_dirty(inode);
356                 iput (inode);
357                 return err;
358         }
359         de->inode = cpu_to_le32(inode->i_ino);
360         ext2_set_de_type(dir->i_sb, de, S_IFREG);
361         dir->i_version = ++event;
362         mark_buffer_dirty(bh, 1);
363         if (IS_SYNC(dir)) {
364                 ll_rw_block (WRITE, 1, &bh);
365                 wait_on_buffer (bh);
366         }
367         brelse (bh);
368         d_instantiate(dentry, inode);
369         return 0;
370 }
371
372 int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
373 {
374         struct inode * inode;
375         struct buffer_head * bh;
376         struct ext2_dir_entry_2 * de;
377         int err = -EIO;
378
379         inode = ext2_new_inode (dir, mode, &err);
380         if (!inode)
381                 goto out;
382
383         inode->i_uid = current->fsuid;
384         init_special_inode(inode, mode, rdev);
385         bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
386         if (!bh)
387                 goto out_no_entry;
388         de->inode = cpu_to_le32(inode->i_ino);
389         dir->i_version = ++event;
390         ext2_set_de_type(dir->i_sb, de, inode->i_mode);
391         mark_inode_dirty(inode);
392         mark_buffer_dirty(bh, 1);
393         if (IS_SYNC(dir)) {
394                 ll_rw_block (WRITE, 1, &bh);
395                 wait_on_buffer (bh);
396         }
397         d_instantiate(dentry, inode);
398         brelse(bh);
399         err = 0;
400 out:
401         return err;
402
403 out_no_entry:
404         inode->i_nlink--;
405         mark_inode_dirty(inode);
406         iput(inode);
407         goto out;
408 }
409
410 int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
411 {
412         struct inode * inode;
413         struct buffer_head * bh, * dir_block;
414         struct ext2_dir_entry_2 * de;
415         int err;
416
417         err = -EMLINK;
418         if (dir->i_nlink >= EXT2_LINK_MAX)
419                 goto out;
420
421         err = -EIO;
422         inode = ext2_new_inode (dir, S_IFDIR, &err);
423         if (!inode)
424                 goto out;
425
426         inode->i_op = &ext2_dir_inode_operations;
427         inode->i_size = inode->i_sb->s_blocksize;
428         inode->i_blocks = 0;    
429         dir_block = ext2_bread (inode, 0, 1, &err);
430         if (!dir_block) {
431                 inode->i_nlink--; /* is this nlink == 0? */
432                 mark_inode_dirty(inode);
433                 iput (inode);
434                 return err;
435         }
436         de = (struct ext2_dir_entry_2 *) dir_block->b_data;
437         de->inode = cpu_to_le32(inode->i_ino);
438         de->name_len = 1;
439         de->rec_len = cpu_to_le16(EXT2_DIR_REC_LEN(de->name_len));
440         strcpy (de->name, ".");
441         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
442         de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
443         de->inode = cpu_to_le32(dir->i_ino);
444         de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize - EXT2_DIR_REC_LEN(1));
445         de->name_len = 2;
446         strcpy (de->name, "..");
447         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
448         inode->i_nlink = 2;
449         mark_buffer_dirty(dir_block, 1);
450         brelse (dir_block);
451         inode->i_mode = S_IFDIR | mode;
452         if (dir->i_mode & S_ISGID)
453                 inode->i_mode |= S_ISGID;
454         mark_inode_dirty(inode);
455         bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
456         if (!bh)
457                 goto out_no_entry;
458         de->inode = cpu_to_le32(inode->i_ino);
459         ext2_set_de_type(dir->i_sb, de, S_IFDIR);
460         dir->i_version = ++event;
461         mark_buffer_dirty(bh, 1);
462         if (IS_SYNC(dir)) {
463                 ll_rw_block (WRITE, 1, &bh);
464                 wait_on_buffer (bh);
465         }
466         dir->i_nlink++;
467         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
468         mark_inode_dirty(dir);
469         d_instantiate(dentry, inode);
470         brelse (bh);
471         err = 0;
472 out:
473         return err;
474
475 out_no_entry:
476         inode->i_nlink = 0;
477         mark_inode_dirty(inode);
478         iput (inode);
479         goto out;
480 }
481
482 /*
483  * routine to check that the specified directory is empty (for rmdir)
484  */
485 static int empty_dir (struct inode * inode)
486 {
487         unsigned long offset;
488         struct buffer_head * bh;
489         struct ext2_dir_entry_2 * de, * de1;
490         struct super_block * sb;
491         int err;
492
493         sb = inode->i_sb;
494         if (inode->i_size < EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) ||
495             !(bh = ext2_bread (inode, 0, 0, &err))) {
496                 ext2_warning (inode->i_sb, "empty_dir",
497                               "bad directory (dir #%lu) - no data block",
498                               inode->i_ino);
499                 return 1;
500         }
501         de = (struct ext2_dir_entry_2 *) bh->b_data;
502         de1 = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
503         if (le32_to_cpu(de->inode) != inode->i_ino || !le32_to_cpu(de1->inode) || 
504             strcmp (".", de->name) || strcmp ("..", de1->name)) {
505                 ext2_warning (inode->i_sb, "empty_dir",
506                               "bad directory (dir #%lu) - no `.' or `..'",
507                               inode->i_ino);
508                 brelse (bh);
509                 return 1;
510         }
511         offset = le16_to_cpu(de->rec_len) + le16_to_cpu(de1->rec_len);
512         de = (struct ext2_dir_entry_2 *) ((char *) de1 + le16_to_cpu(de1->rec_len));
513         while (offset < inode->i_size ) {
514                 if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
515                         brelse (bh);
516                         bh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 0, &err);
517                         if (!bh) {
518 #if 0
519                                 ext2_error (sb, "empty_dir",
520                                             "directory #%lu contains a hole at offset %lu",
521                                             inode->i_ino, offset);
522 #endif
523                                 offset += sb->s_blocksize;
524                                 continue;
525                         }
526                         de = (struct ext2_dir_entry_2 *) bh->b_data;
527                 }
528                 if (!ext2_check_dir_entry ("empty_dir", inode, de, bh,
529                                            offset)) {
530                         brelse (bh);
531                         return 1;
532                 }
533                 if (le32_to_cpu(de->inode)) {
534                         brelse (bh);
535                         return 0;
536                 }
537                 offset += le16_to_cpu(de->rec_len);
538                 de = (struct ext2_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
539         }
540         brelse (bh);
541         return 1;
542 }
543
544 int ext2_rmdir (struct inode * dir, struct dentry *dentry)
545 {
546         int retval;
547         struct inode * inode;
548         struct buffer_head * bh;
549         struct ext2_dir_entry_2 * de;
550
551         retval = -ENOENT;
552         bh = ext2_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
553         if (!bh)
554                 goto end_rmdir;
555
556         inode = dentry->d_inode;
557         DQUOT_INIT(inode);
558
559         retval = -EIO;
560         if (le32_to_cpu(de->inode) != inode->i_ino)
561                 goto end_rmdir;
562
563         retval = -ENOTEMPTY;
564         if (!empty_dir (inode))
565                 goto end_rmdir;
566
567         retval = ext2_delete_entry (de, bh);
568         dir->i_version = ++event;
569         if (retval)
570                 goto end_rmdir;
571         mark_buffer_dirty(bh, 1);
572         if (IS_SYNC(dir)) {
573                 ll_rw_block (WRITE, 1, &bh);
574                 wait_on_buffer (bh);
575         }
576         if (inode->i_nlink != 2)
577                 ext2_warning (inode->i_sb, "ext2_rmdir",
578                               "empty directory has nlink!=2 (%d)",
579                               inode->i_nlink);
580         inode->i_version = ++event;
581         inode->i_nlink = 0;
582         inode->i_size = 0;
583         mark_inode_dirty(inode);
584         dir->i_nlink--;
585         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
586         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
587         mark_inode_dirty(dir);
588         d_delete(dentry);
589
590 end_rmdir:
591         brelse (bh);
592         return retval;
593 }
594
595 int ext2_unlink(struct inode * dir, struct dentry *dentry)
596 {
597         int retval;
598         struct inode * inode;
599         struct buffer_head * bh;
600         struct ext2_dir_entry_2 * de;
601
602         retval = -ENOENT;
603         bh = ext2_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de);
604         if (!bh)
605                 goto end_unlink;
606
607         inode = dentry->d_inode;
608         DQUOT_INIT(inode);
609
610         retval = -EIO;
611         if (le32_to_cpu(de->inode) != inode->i_ino)
612                 goto end_unlink;
613         
614         if (!inode->i_nlink) {
615                 ext2_warning (inode->i_sb, "ext2_unlink",
616                               "Deleting nonexistent file (%lu), %d",
617                               inode->i_ino, inode->i_nlink);
618                 inode->i_nlink = 1;
619         }
620         retval = ext2_delete_entry (de, bh);
621         if (retval)
622                 goto end_unlink;
623         dir->i_version = ++event;
624         mark_buffer_dirty(bh, 1);
625         if (IS_SYNC(dir)) {
626                 ll_rw_block (WRITE, 1, &bh);
627                 wait_on_buffer (bh);
628         }
629         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
630         dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
631         mark_inode_dirty(dir);
632         inode->i_nlink--;
633         mark_inode_dirty(inode);
634         inode->i_ctime = dir->i_ctime;
635         retval = 0;
636         d_delete(dentry);       /* This also frees the inode */
637
638 end_unlink:
639         brelse (bh);
640         return retval;
641 }
642
643 int ext2_symlink (struct inode * dir, struct dentry *dentry, const char * symname)
644 {
645         struct ext2_dir_entry_2 * de;
646         struct inode * inode;
647         struct buffer_head * bh = NULL, * name_block = NULL;
648         char * link;
649         int i, l, err = -EIO;
650         char c;
651
652         if (!(inode = ext2_new_inode (dir, S_IFLNK, &err))) {
653                 return err;
654         }
655         inode->i_mode = S_IFLNK | S_IRWXUGO;
656         inode->i_op = &ext2_symlink_inode_operations;
657         for (l = 0; l < inode->i_sb->s_blocksize - 1 &&
658              symname [l]; l++)
659                 ;
660         if (l >= sizeof (inode->u.ext2_i.i_data)) {
661
662                 ext2_debug ("l=%d, normal symlink\n", l);
663
664                 name_block = ext2_bread (inode, 0, 1, &err);
665                 if (!name_block) {
666                         inode->i_nlink--;
667                         mark_inode_dirty(inode);
668                         iput (inode);
669                         return err;
670                 }
671                 link = name_block->b_data;
672         } else {
673                 link = (char *) inode->u.ext2_i.i_data;
674
675                 ext2_debug ("l=%d, fast symlink\n", l);
676
677         }
678         i = 0;
679         while (i < inode->i_sb->s_blocksize - 1 && (c = *(symname++)))
680                 link[i++] = c;
681         link[i] = 0;
682         if (name_block) {
683                 mark_buffer_dirty(name_block, 1);
684                 brelse (name_block);
685         }
686         inode->i_size = i;
687         mark_inode_dirty(inode);
688
689         bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
690         if (!bh)
691                 goto out_no_entry;
692         de->inode = cpu_to_le32(inode->i_ino);
693         ext2_set_de_type(dir->i_sb, de, S_IFLNK);
694         dir->i_version = ++event;
695         mark_buffer_dirty(bh, 1);
696         if (IS_SYNC(dir)) {
697                 ll_rw_block (WRITE, 1, &bh);
698                 wait_on_buffer (bh);
699         }
700         brelse (bh);
701         d_instantiate(dentry, inode);
702         err = 0;
703 out:
704         return err;
705
706 out_no_entry:
707         inode->i_nlink--;
708         mark_inode_dirty(inode);
709         iput (inode);
710         goto out;
711 }
712
713 int ext2_link (struct dentry * old_dentry,
714                 struct inode * dir, struct dentry *dentry)
715 {
716         struct inode *inode = old_dentry->d_inode;
717         struct ext2_dir_entry_2 * de;
718         struct buffer_head * bh;
719         int err;
720
721         if (S_ISDIR(inode->i_mode))
722                 return -EPERM;
723
724         if (inode->i_nlink >= EXT2_LINK_MAX)
725                 return -EMLINK;
726
727         bh = ext2_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
728         if (!bh)
729                 return err;
730
731         de->inode = cpu_to_le32(inode->i_ino);
732         ext2_set_de_type(dir->i_sb, de, inode->i_mode);
733         dir->i_version = ++event;
734         mark_buffer_dirty(bh, 1);
735         if (IS_SYNC(dir)) {
736                 ll_rw_block (WRITE, 1, &bh);
737                 wait_on_buffer (bh);
738         }
739         brelse (bh);
740         inode->i_nlink++;
741         inode->i_ctime = CURRENT_TIME;
742         mark_inode_dirty(inode);
743         inode->i_count++;
744         d_instantiate(dentry, inode);
745         return 0;
746 }
747
748 #define PARENT_INO(buffer) \
749         ((struct ext2_dir_entry_2 *) ((char *) buffer + \
750         le16_to_cpu(((struct ext2_dir_entry_2 *) buffer)->rec_len)))->inode
751
752 /*
753  * Anybody can rename anything with this: the permission checks are left to the
754  * higher-level routines.
755  */
756 int ext2_rename (struct inode * old_dir, struct dentry *old_dentry,
757                            struct inode * new_dir,struct dentry *new_dentry)
758 {
759         struct inode * old_inode, * new_inode;
760         struct buffer_head * old_bh, * new_bh, * dir_bh;
761         struct ext2_dir_entry_2 * old_de, * new_de;
762         int retval;
763
764         old_bh = new_bh = dir_bh = NULL;
765
766         old_bh = ext2_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_de);
767         /*
768          *  Check for inode number is _not_ due to possible IO errors.
769          *  We might rmdir the source, keep it as pwd of some process
770          *  and merrily kill the link to whatever was created under the
771          *  same name. Goodbye sticky bit ;-<
772          */
773         old_inode = old_dentry->d_inode;
774         retval = -ENOENT;
775         if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino)
776                 goto end_rename;
777
778         new_inode = new_dentry->d_inode;
779         new_bh = ext2_find_entry (new_dir, new_dentry->d_name.name,
780                                 new_dentry->d_name.len, &new_de);
781         if (new_bh) {
782                 if (!new_inode) {
783                         brelse (new_bh);
784                         new_bh = NULL;
785                 } else {
786                         DQUOT_INIT(new_inode);
787                 }
788         }
789         if (S_ISDIR(old_inode->i_mode)) {
790                 if (new_inode) {
791                         retval = -ENOTEMPTY;
792                         if (!empty_dir (new_inode))
793                                 goto end_rename;
794                 }
795                 retval = -EIO;
796                 dir_bh = ext2_bread (old_inode, 0, 0, &retval);
797                 if (!dir_bh)
798                         goto end_rename;
799                 if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
800                         goto end_rename;
801                 retval = -EMLINK;
802                 if (!new_inode && new_dir!=old_dir &&
803                                 new_dir->i_nlink >= EXT2_LINK_MAX)
804                         goto end_rename;
805         }
806         if (!new_bh) {
807                 new_bh = ext2_add_entry (new_dir, new_dentry->d_name.name,
808                                         new_dentry->d_name.len, &new_de,
809                                         &retval);
810                 if (!new_bh)
811                         goto end_rename;
812         }
813         new_dir->i_version = ++event;
814
815         /*
816          * ok, that's it
817          */
818         new_de->inode = le32_to_cpu(old_inode->i_ino);
819         if (EXT2_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
820                                       EXT2_FEATURE_INCOMPAT_FILETYPE))
821                 new_de->file_type = old_de->file_type;
822         
823         ext2_delete_entry (old_de, old_bh);
824
825         old_dir->i_version = ++event;
826         if (new_inode) {
827                 new_inode->i_nlink--;
828                 new_inode->i_ctime = CURRENT_TIME;
829                 mark_inode_dirty(new_inode);
830         }
831         old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
832         old_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
833         mark_inode_dirty(old_dir);
834         if (dir_bh) {
835                 PARENT_INO(dir_bh->b_data) = le32_to_cpu(new_dir->i_ino);
836                 mark_buffer_dirty(dir_bh, 1);
837                 old_dir->i_nlink--;
838                 mark_inode_dirty(old_dir);
839                 if (new_inode) {
840                         new_inode->i_nlink--;
841                         mark_inode_dirty(new_inode);
842                 } else {
843                         new_dir->i_nlink++;
844                         new_dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
845                         mark_inode_dirty(new_dir);
846                 }
847         }
848         mark_buffer_dirty(old_bh,  1);
849         if (IS_SYNC(old_dir)) {
850                 ll_rw_block (WRITE, 1, &old_bh);
851                 wait_on_buffer (old_bh);
852         }
853         mark_buffer_dirty(new_bh, 1);
854         if (IS_SYNC(new_dir)) {
855                 ll_rw_block (WRITE, 1, &new_bh);
856                 wait_on_buffer (new_bh);
857         }
858
859         retval = 0;
860
861 end_rename:
862         brelse (dir_bh);
863         brelse (old_bh);
864         brelse (new_bh);
865         return retval;
866 }
867 #endif