[PATCH] ufs: fix hang during `rm'
[linux-2.6.git] / fs / ufs / inode.c
1 /*
2  *  linux/fs/ufs/inode.c
3  *
4  * Copyright (C) 1998
5  * Daniel Pirkl <daniel.pirkl@email.cz>
6  * Charles University, Faculty of Mathematics and Physics
7  *
8  *  from
9  *
10  *  linux/fs/ext2/inode.c
11  *
12  * Copyright (C) 1992, 1993, 1994, 1995
13  * Remy Card (card@masi.ibp.fr)
14  * Laboratoire MASI - Institut Blaise Pascal
15  * Universite Pierre et Marie Curie (Paris VI)
16  *
17  *  from
18  *
19  *  linux/fs/minix/inode.c
20  *
21  *  Copyright (C) 1991, 1992  Linus Torvalds
22  *
23  *  Goal-directed block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
24  *  Big-endian to little-endian byte-swapping/bitmaps by
25  *        David S. Miller (davem@caip.rutgers.edu), 1995
26  */
27
28 #include <asm/uaccess.h>
29 #include <asm/system.h>
30
31 #include <linux/errno.h>
32 #include <linux/fs.h>
33 #include <linux/ufs_fs.h>
34 #include <linux/time.h>
35 #include <linux/stat.h>
36 #include <linux/string.h>
37 #include <linux/mm.h>
38 #include <linux/smp_lock.h>
39 #include <linux/buffer_head.h>
40
41 #include "swab.h"
42 #include "util.h"
43
44 #undef UFS_INODE_DEBUG
45 #undef UFS_INODE_DEBUG_MORE
46
47 #ifdef UFS_INODE_DEBUG
48 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
49 #else
50 #define UFSD(x)
51 #endif
52
53 static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t offsets[4])
54 {
55         struct ufs_sb_private_info *uspi = UFS_SB(inode->i_sb)->s_uspi;
56         int ptrs = uspi->s_apb;
57         int ptrs_bits = uspi->s_apbshift;
58         const long direct_blocks = UFS_NDADDR,
59                 indirect_blocks = ptrs,
60                 double_blocks = (1 << (ptrs_bits * 2));
61         int n = 0;
62
63
64         UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks));
65         if (i_block < 0) {
66                 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0");
67         } else if (i_block < direct_blocks) {
68                 offsets[n++] = i_block;
69         } else if ((i_block -= direct_blocks) < indirect_blocks) {
70                 offsets[n++] = UFS_IND_BLOCK;
71                 offsets[n++] = i_block;
72         } else if ((i_block -= indirect_blocks) < double_blocks) {
73                 offsets[n++] = UFS_DIND_BLOCK;
74                 offsets[n++] = i_block >> ptrs_bits;
75                 offsets[n++] = i_block & (ptrs - 1);
76         } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
77                 offsets[n++] = UFS_TIND_BLOCK;
78                 offsets[n++] = i_block >> (ptrs_bits * 2);
79                 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
80                 offsets[n++] = i_block & (ptrs - 1);
81         } else {
82                 ufs_warning(inode->i_sb, "ufs_block_to_path", "block > big");
83         }
84         return n;
85 }
86
87 /*
88  * Returns the location of the fragment from
89  * the begining of the filesystem.
90  */
91
92 u64  ufs_frag_map(struct inode *inode, sector_t frag)
93 {
94         struct ufs_inode_info *ufsi = UFS_I(inode);
95         struct super_block *sb = inode->i_sb;
96         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
97         u64 mask = (u64) uspi->s_apbmask>>uspi->s_fpbshift;
98         int shift = uspi->s_apbshift-uspi->s_fpbshift;
99         sector_t offsets[4], *p;
100         int depth = ufs_block_to_path(inode, frag >> uspi->s_fpbshift, offsets);
101         u64  ret = 0L;
102         __fs32 block;
103         __fs64 u2_block = 0L;
104         unsigned flags = UFS_SB(sb)->s_flags;
105         u64 temp = 0L;
106
107         UFSD((": frag = %llu  depth = %d\n", (unsigned long long)frag, depth));
108         UFSD((": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask));
109
110         if (depth == 0)
111                 return 0;
112
113         p = offsets;
114
115         lock_kernel();
116         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
117                 goto ufs2;
118
119         block = ufsi->i_u1.i_data[*p++];
120         if (!block)
121                 goto out;
122         while (--depth) {
123                 struct buffer_head *bh;
124                 sector_t n = *p++;
125
126                 bh = sb_bread(sb, uspi->s_sbbase + fs32_to_cpu(sb, block)+(n>>shift));
127                 if (!bh)
128                         goto out;
129                 block = ((__fs32 *) bh->b_data)[n & mask];
130                 brelse (bh);
131                 if (!block)
132                         goto out;
133         }
134         ret = (u64) (uspi->s_sbbase + fs32_to_cpu(sb, block) + (frag & uspi->s_fpbmask));
135         goto out;
136 ufs2:
137         u2_block = ufsi->i_u1.u2_i_data[*p++];
138         if (!u2_block)
139                 goto out;
140
141
142         while (--depth) {
143                 struct buffer_head *bh;
144                 sector_t n = *p++;
145
146
147                 temp = (u64)(uspi->s_sbbase) + fs64_to_cpu(sb, u2_block);
148                 bh = sb_bread(sb, temp +(u64) (n>>shift));
149                 if (!bh)
150                         goto out;
151                 u2_block = ((__fs64 *)bh->b_data)[n & mask];
152                 brelse(bh);
153                 if (!u2_block)
154                         goto out;
155         }
156         temp = (u64)uspi->s_sbbase + fs64_to_cpu(sb, u2_block);
157         ret = temp + (u64) (frag & uspi->s_fpbmask);
158
159 out:
160         unlock_kernel();
161         return ret;
162 }
163
164 static struct buffer_head * ufs_inode_getfrag (struct inode *inode,
165         unsigned int fragment, unsigned int new_fragment,
166         unsigned int required, int *err, int metadata, long *phys, int *new)
167 {
168         struct ufs_inode_info *ufsi = UFS_I(inode);
169         struct super_block * sb;
170         struct ufs_sb_private_info * uspi;
171         struct buffer_head * result;
172         unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
173         unsigned tmp, goal;
174         __fs32 * p, * p2;
175         unsigned flags = 0;
176
177         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u, required %u\n",
178                 inode->i_ino, fragment, new_fragment, required))         
179
180         sb = inode->i_sb;
181         uspi = UFS_SB(sb)->s_uspi;
182
183         flags = UFS_SB(sb)->s_flags;
184         /* TODO : to be done for write support
185         if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
186              goto ufs2;
187          */
188
189         block = ufs_fragstoblks (fragment);
190         blockoff = ufs_fragnum (fragment);
191         p = ufsi->i_u1.i_data + block;
192         goal = 0;
193
194 repeat:
195         tmp = fs32_to_cpu(sb, *p);
196         lastfrag = ufsi->i_lastfrag;
197         if (tmp && fragment < lastfrag) {
198                 if (metadata) {
199                         result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
200                         if (tmp == fs32_to_cpu(sb, *p)) {
201                                 UFSD(("EXIT, result %u\n", tmp + blockoff))
202                                 return result;
203                         }
204                         brelse (result);
205                         goto repeat;
206                 } else {
207                         *phys = tmp;
208                         return NULL;
209                 }
210         }
211
212         lastblock = ufs_fragstoblks (lastfrag);
213         lastblockoff = ufs_fragnum (lastfrag);
214         /*
215          * We will extend file into new block beyond last allocated block
216          */
217         if (lastblock < block) {
218                 /*
219                  * We must reallocate last allocated block
220                  */
221                 if (lastblockoff) {
222                         p2 = ufsi->i_u1.i_data + lastblock;
223                         tmp = ufs_new_fragments (inode, p2, lastfrag, 
224                                 fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff, err);
225                         if (!tmp) {
226                                 if (lastfrag != ufsi->i_lastfrag)
227                                         goto repeat;
228                                 else
229                                         return NULL;
230                         }
231                         lastfrag = ufsi->i_lastfrag;
232                         
233                 }
234                 goal = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock]) + uspi->s_fpb;
235                 tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
236                         goal, required + blockoff, err);
237         }
238         /*
239          * We will extend last allocated block
240          */
241         else if (lastblock == block) {
242                 tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
243                         fs32_to_cpu(sb, *p), required +  (blockoff - lastblockoff), err);
244         }
245         /*
246          * We will allocate new block before last allocated block
247          */
248         else /* (lastblock > block) */ {
249                 if (lastblock && (tmp = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock-1])))
250                         goal = tmp + uspi->s_fpb;
251                 tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
252                         goal, uspi->s_fpb, err);
253         }
254         if (!tmp) {
255                 if ((!blockoff && *p) || 
256                     (blockoff && lastfrag != ufsi->i_lastfrag))
257                         goto repeat;
258                 *err = -ENOSPC;
259                 return NULL;
260         }
261
262         /* The nullification of framgents done in ufs/balloc.c is
263          * something I don't have the stomache to move into here right
264          * now. -DaveM
265          */
266         if (metadata) {
267                 result = sb_getblk(inode->i_sb, tmp + blockoff);
268         } else {
269                 *phys = tmp;
270                 result = NULL;
271                 *err = 0;
272                 *new = 1;
273         }
274
275         inode->i_ctime = CURRENT_TIME_SEC;
276         if (IS_SYNC(inode))
277                 ufs_sync_inode (inode);
278         mark_inode_dirty(inode);
279         UFSD(("EXIT, result %u\n", tmp + blockoff))
280         return result;
281
282      /* This part : To be implemented ....
283         Required only for writing, not required for READ-ONLY.
284 ufs2:
285
286         u2_block = ufs_fragstoblks(fragment);
287         u2_blockoff = ufs_fragnum(fragment);
288         p = ufsi->i_u1.u2_i_data + block;
289         goal = 0;
290
291 repeat2:
292         tmp = fs32_to_cpu(sb, *p);
293         lastfrag = ufsi->i_lastfrag;
294
295      */
296 }
297
298 static struct buffer_head * ufs_block_getfrag (struct inode *inode,
299         struct buffer_head *bh, unsigned int fragment, unsigned int new_fragment, 
300         unsigned int blocksize, int * err, int metadata, long *phys, int *new)
301 {
302         struct super_block * sb;
303         struct ufs_sb_private_info * uspi;
304         struct buffer_head * result;
305         unsigned tmp, goal, block, blockoff;
306         __fs32 * p;
307
308         sb = inode->i_sb;
309         uspi = UFS_SB(sb)->s_uspi;
310         block = ufs_fragstoblks (fragment);
311         blockoff = ufs_fragnum (fragment);
312
313         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u\n", inode->i_ino, fragment, new_fragment))  
314
315         result = NULL;
316         if (!bh)
317                 goto out;
318         if (!buffer_uptodate(bh)) {
319                 ll_rw_block (READ, 1, &bh);
320                 wait_on_buffer (bh);
321                 if (!buffer_uptodate(bh))
322                         goto out;
323         }
324
325         p = (__fs32 *) bh->b_data + block;
326 repeat:
327         tmp = fs32_to_cpu(sb, *p);
328         if (tmp) {
329                 if (metadata) {
330                         result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
331                         if (tmp == fs32_to_cpu(sb, *p))
332                                 goto out;
333                         brelse (result);
334                         goto repeat;
335                 } else {
336                         *phys = tmp;
337                         goto out;
338                 }
339         }
340
341         if (block && (tmp = fs32_to_cpu(sb, ((__fs32*)bh->b_data)[block-1]) + uspi->s_fpb))
342                 goal = tmp + uspi->s_fpb;
343         else
344                 goal = bh->b_blocknr + uspi->s_fpb;
345         tmp = ufs_new_fragments (inode, p, ufs_blknum(new_fragment), goal, uspi->s_fpb, err);
346         if (!tmp) {
347                 if (fs32_to_cpu(sb, *p))
348                         goto repeat;
349                 goto out;
350         }               
351
352         /* The nullification of framgents done in ufs/balloc.c is
353          * something I don't have the stomache to move into here right
354          * now. -DaveM
355          */
356         if (metadata) {
357                 result = sb_getblk(sb, tmp + blockoff);
358         } else {
359                 *phys = tmp;
360                 *new = 1;
361         }
362
363         mark_buffer_dirty(bh);
364         if (IS_SYNC(inode))
365                 sync_dirty_buffer(bh);
366         inode->i_ctime = CURRENT_TIME_SEC;
367         mark_inode_dirty(inode);
368         UFSD(("result %u\n", tmp + blockoff));
369 out:
370         brelse (bh);
371         UFSD(("EXIT\n"));
372         return result;
373 }
374
375 /*
376  * This function gets the block which contains the fragment.
377  */
378
379 int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
380 {
381         struct super_block * sb = inode->i_sb;
382         struct ufs_sb_private_info * uspi = UFS_SB(sb)->s_uspi;
383         struct buffer_head * bh;
384         int ret, err, new;
385         unsigned long ptr,phys;
386         u64 phys64 = 0;
387         
388         if (!create) {
389                 phys64 = ufs_frag_map(inode, fragment);
390                 UFSD(("phys64 = %llu \n",phys64));
391                 if (phys64)
392                         map_bh(bh_result, sb, phys64);
393                 return 0;
394         }
395
396         /* This code entered only while writing ....? */
397
398         err = -EIO;
399         new = 0;
400         ret = 0;
401         bh = NULL;
402
403         lock_kernel();
404
405         UFSD(("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment))
406         if (fragment < 0)
407                 goto abort_negative;
408         if (fragment >
409             ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb)
410              << uspi->s_fpbshift))
411                 goto abort_too_big;
412
413         err = 0;
414         ptr = fragment;
415           
416         /*
417          * ok, these macros clean the logic up a bit and make
418          * it much more readable:
419          */
420 #define GET_INODE_DATABLOCK(x) \
421                 ufs_inode_getfrag(inode, x, fragment, 1, &err, 0, &phys, &new)
422 #define GET_INODE_PTR(x) \
423                 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, 1, NULL, NULL)
424 #define GET_INDIRECT_DATABLOCK(x) \
425                 ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
426                                   &err, 0, &phys, &new);
427 #define GET_INDIRECT_PTR(x) \
428                 ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
429                                   &err, 1, NULL, NULL);
430
431         if (ptr < UFS_NDIR_FRAGMENT) {
432                 bh = GET_INODE_DATABLOCK(ptr);
433                 goto out;
434         }
435         ptr -= UFS_NDIR_FRAGMENT;
436         if (ptr < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
437                 bh = GET_INODE_PTR(UFS_IND_FRAGMENT + (ptr >> uspi->s_apbshift));
438                 goto get_indirect;
439         }
440         ptr -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
441         if (ptr < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
442                 bh = GET_INODE_PTR(UFS_DIND_FRAGMENT + (ptr >> uspi->s_2apbshift));
443                 goto get_double;
444         }
445         ptr -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
446         bh = GET_INODE_PTR(UFS_TIND_FRAGMENT + (ptr >> uspi->s_3apbshift));
447         bh = GET_INDIRECT_PTR((ptr >> uspi->s_2apbshift) & uspi->s_apbmask);
448 get_double:
449         bh = GET_INDIRECT_PTR((ptr >> uspi->s_apbshift) & uspi->s_apbmask);
450 get_indirect:
451         bh = GET_INDIRECT_DATABLOCK(ptr & uspi->s_apbmask);
452
453 #undef GET_INODE_DATABLOCK
454 #undef GET_INODE_PTR
455 #undef GET_INDIRECT_DATABLOCK
456 #undef GET_INDIRECT_PTR
457
458 out:
459         if (err)
460                 goto abort;
461         if (new)
462                 set_buffer_new(bh_result);
463         map_bh(bh_result, sb, phys);
464 abort:
465         unlock_kernel();
466         return err;
467
468 abort_negative:
469         ufs_warning(sb, "ufs_get_block", "block < 0");
470         goto abort;
471
472 abort_too_big:
473         ufs_warning(sb, "ufs_get_block", "block > big");
474         goto abort;
475 }
476
477 struct buffer_head *ufs_getfrag(struct inode *inode, unsigned int fragment,
478                                 int create, int *err)
479 {
480         struct buffer_head dummy;
481         int error;
482
483         dummy.b_state = 0;
484         dummy.b_blocknr = -1000;
485         error = ufs_getfrag_block(inode, fragment, &dummy, create);
486         *err = error;
487         if (!error && buffer_mapped(&dummy)) {
488                 struct buffer_head *bh;
489                 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
490                 if (buffer_new(&dummy)) {
491                         memset(bh->b_data, 0, inode->i_sb->s_blocksize);
492                         set_buffer_uptodate(bh);
493                         mark_buffer_dirty(bh);
494                 }
495                 return bh;
496         }
497         return NULL;
498 }
499
500 struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
501         int create, int * err)
502 {
503         struct buffer_head * bh;
504
505         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
506         bh = ufs_getfrag (inode, fragment, create, err);
507         if (!bh || buffer_uptodate(bh))                 
508                 return bh;
509         ll_rw_block (READ, 1, &bh);
510         wait_on_buffer (bh);
511         if (buffer_uptodate(bh))
512                 return bh;
513         brelse (bh);
514         *err = -EIO;
515         return NULL;
516 }
517
518 static int ufs_writepage(struct page *page, struct writeback_control *wbc)
519 {
520         return block_write_full_page(page,ufs_getfrag_block,wbc);
521 }
522 static int ufs_readpage(struct file *file, struct page *page)
523 {
524         return block_read_full_page(page,ufs_getfrag_block);
525 }
526 static int ufs_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
527 {
528         return block_prepare_write(page,from,to,ufs_getfrag_block);
529 }
530 static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
531 {
532         return generic_block_bmap(mapping,block,ufs_getfrag_block);
533 }
534 struct address_space_operations ufs_aops = {
535         .readpage = ufs_readpage,
536         .writepage = ufs_writepage,
537         .sync_page = block_sync_page,
538         .prepare_write = ufs_prepare_write,
539         .commit_write = generic_commit_write,
540         .bmap = ufs_bmap
541 };
542
543 void ufs_read_inode (struct inode * inode)
544 {
545         struct ufs_inode_info *ufsi = UFS_I(inode);
546         struct super_block * sb;
547         struct ufs_sb_private_info * uspi;
548         struct ufs_inode * ufs_inode;   
549         struct ufs2_inode *ufs2_inode;
550         struct buffer_head * bh;
551         mode_t mode;
552         unsigned i;
553         unsigned flags;
554         
555         UFSD(("ENTER, ino %lu\n", inode->i_ino))
556         
557         sb = inode->i_sb;
558         uspi = UFS_SB(sb)->s_uspi;
559         flags = UFS_SB(sb)->s_flags;
560
561         if (inode->i_ino < UFS_ROOTINO || 
562             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
563                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
564                 goto bad_inode;
565         }
566         
567         bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
568         if (!bh) {
569                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
570                 goto bad_inode;
571         }
572         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
573                 goto ufs2_inode;
574
575         ufs_inode = (struct ufs_inode *) (bh->b_data + sizeof(struct ufs_inode) * ufs_inotofsbo(inode->i_ino));
576
577         /*
578          * Copy data to the in-core inode.
579          */
580         inode->i_mode = mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
581         inode->i_nlink = fs16_to_cpu(sb, ufs_inode->ui_nlink);
582         if (inode->i_nlink == 0)
583                 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
584         
585         /*
586          * Linux now has 32-bit uid and gid, so we can support EFT.
587          */
588         inode->i_uid = ufs_get_inode_uid(sb, ufs_inode);
589         inode->i_gid = ufs_get_inode_gid(sb, ufs_inode);
590
591         inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);
592         inode->i_atime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);
593         inode->i_ctime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);
594         inode->i_mtime.tv_sec = fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);
595         inode->i_mtime.tv_nsec = 0;
596         inode->i_atime.tv_nsec = 0;
597         inode->i_ctime.tv_nsec = 0;
598         inode->i_blocks = fs32_to_cpu(sb, ufs_inode->ui_blocks);
599         inode->i_blksize = PAGE_SIZE;   /* This is the optimal IO size (for stat) */
600         inode->i_version++;
601         ufsi->i_flags = fs32_to_cpu(sb, ufs_inode->ui_flags);
602         ufsi->i_gen = fs32_to_cpu(sb, ufs_inode->ui_gen);
603         ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
604         ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
605         ufsi->i_lastfrag = (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
606         
607         if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
608                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
609                         ufsi->i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
610         }
611         else {
612                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
613                         ufsi->i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
614         }
615         ufsi->i_osync = 0;
616
617         if (S_ISREG(inode->i_mode)) {
618                 inode->i_op = &ufs_file_inode_operations;
619                 inode->i_fop = &ufs_file_operations;
620                 inode->i_mapping->a_ops = &ufs_aops;
621         } else if (S_ISDIR(inode->i_mode)) {
622                 inode->i_op = &ufs_dir_inode_operations;
623                 inode->i_fop = &ufs_dir_operations;
624         } else if (S_ISLNK(inode->i_mode)) {
625                 if (!inode->i_blocks)
626                         inode->i_op = &ufs_fast_symlink_inode_operations;
627                 else {
628                         inode->i_op = &page_symlink_inode_operations;
629                         inode->i_mapping->a_ops = &ufs_aops;
630                 }
631         } else
632                 init_special_inode(inode, inode->i_mode,
633                         ufs_get_inode_dev(sb, ufsi));
634
635         brelse (bh);
636
637         UFSD(("EXIT\n"))
638         return;
639
640 bad_inode:
641         make_bad_inode(inode);
642         return;
643
644 ufs2_inode :
645         UFSD(("Reading ufs2 inode, ino %lu\n", inode->i_ino))
646
647         ufs2_inode = (struct ufs2_inode *)(bh->b_data + sizeof(struct ufs2_inode) * ufs_inotofsbo(inode->i_ino));
648
649         /*
650          * Copy data to the in-core inode.
651          */
652         inode->i_mode = mode = fs16_to_cpu(sb, ufs2_inode->ui_mode);
653         inode->i_nlink = fs16_to_cpu(sb, ufs2_inode->ui_nlink);
654         if (inode->i_nlink == 0)
655                 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
656
657         /*
658          * Linux now has 32-bit uid and gid, so we can support EFT.
659          */
660         inode->i_uid = fs32_to_cpu(sb, ufs2_inode->ui_uid);
661         inode->i_gid = fs32_to_cpu(sb, ufs2_inode->ui_gid);
662
663         inode->i_size = fs64_to_cpu(sb, ufs2_inode->ui_size);
664         inode->i_atime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_atime.tv_sec);
665         inode->i_ctime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_ctime.tv_sec);
666         inode->i_mtime.tv_sec = fs32_to_cpu(sb, ufs2_inode->ui_mtime.tv_sec);
667         inode->i_mtime.tv_nsec = 0;
668         inode->i_atime.tv_nsec = 0;
669         inode->i_ctime.tv_nsec = 0;
670         inode->i_blocks = fs64_to_cpu(sb, ufs2_inode->ui_blocks);
671         inode->i_blksize = PAGE_SIZE; /*This is the optimal IO size(for stat)*/
672
673         inode->i_version++;
674         ufsi->i_flags = fs32_to_cpu(sb, ufs2_inode->ui_flags);
675         ufsi->i_gen = fs32_to_cpu(sb, ufs2_inode->ui_gen);
676         /*
677         ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
678         ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
679         */
680         ufsi->i_lastfrag= (inode->i_size + uspi->s_fsize- 1) >> uspi->s_fshift;
681
682         if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
683                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
684                         ufsi->i_u1.u2_i_data[i] =
685                                 ufs2_inode->ui_u2.ui_addr.ui_db[i];
686         }
687         else {
688                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
689                         ufsi->i_u1.i_symlink[i] = ufs2_inode->ui_u2.ui_symlink[i];
690         }
691         ufsi->i_osync = 0;
692
693         if (S_ISREG(inode->i_mode)) {
694                 inode->i_op = &ufs_file_inode_operations;
695                 inode->i_fop = &ufs_file_operations;
696                 inode->i_mapping->a_ops = &ufs_aops;
697         } else if (S_ISDIR(inode->i_mode)) {
698                 inode->i_op = &ufs_dir_inode_operations;
699                 inode->i_fop = &ufs_dir_operations;
700         } else if (S_ISLNK(inode->i_mode)) {
701                 if (!inode->i_blocks)
702                         inode->i_op = &ufs_fast_symlink_inode_operations;
703                 else {
704                         inode->i_op = &page_symlink_inode_operations;
705                         inode->i_mapping->a_ops = &ufs_aops;
706                 }
707         } else   /* TODO  : here ...*/
708                 init_special_inode(inode, inode->i_mode,
709                         ufs_get_inode_dev(sb, ufsi));
710
711         brelse(bh);
712
713         UFSD(("EXIT\n"))
714         return;
715 }
716
717 static int ufs_update_inode(struct inode * inode, int do_sync)
718 {
719         struct ufs_inode_info *ufsi = UFS_I(inode);
720         struct super_block * sb;
721         struct ufs_sb_private_info * uspi;
722         struct buffer_head * bh;
723         struct ufs_inode * ufs_inode;
724         unsigned i;
725         unsigned flags;
726
727         UFSD(("ENTER, ino %lu\n", inode->i_ino))
728
729         sb = inode->i_sb;
730         uspi = UFS_SB(sb)->s_uspi;
731         flags = UFS_SB(sb)->s_flags;
732
733         if (inode->i_ino < UFS_ROOTINO || 
734             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
735                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
736                 return -1;
737         }
738
739         bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
740         if (!bh) {
741                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
742                 return -1;
743         }
744         ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));
745
746         ufs_inode->ui_mode = cpu_to_fs16(sb, inode->i_mode);
747         ufs_inode->ui_nlink = cpu_to_fs16(sb, inode->i_nlink);
748
749         ufs_set_inode_uid(sb, ufs_inode, inode->i_uid);
750         ufs_set_inode_gid(sb, ufs_inode, inode->i_gid);
751                 
752         ufs_inode->ui_size = cpu_to_fs64(sb, inode->i_size);
753         ufs_inode->ui_atime.tv_sec = cpu_to_fs32(sb, inode->i_atime.tv_sec);
754         ufs_inode->ui_atime.tv_usec = 0;
755         ufs_inode->ui_ctime.tv_sec = cpu_to_fs32(sb, inode->i_ctime.tv_sec);
756         ufs_inode->ui_ctime.tv_usec = 0;
757         ufs_inode->ui_mtime.tv_sec = cpu_to_fs32(sb, inode->i_mtime.tv_sec);
758         ufs_inode->ui_mtime.tv_usec = 0;
759         ufs_inode->ui_blocks = cpu_to_fs32(sb, inode->i_blocks);
760         ufs_inode->ui_flags = cpu_to_fs32(sb, ufsi->i_flags);
761         ufs_inode->ui_gen = cpu_to_fs32(sb, ufsi->i_gen);
762
763         if ((flags & UFS_UID_MASK) == UFS_UID_EFT) {
764                 ufs_inode->ui_u3.ui_sun.ui_shadow = cpu_to_fs32(sb, ufsi->i_shadow);
765                 ufs_inode->ui_u3.ui_sun.ui_oeftflag = cpu_to_fs32(sb, ufsi->i_oeftflag);
766         }
767
768         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
769                 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
770                 ufs_inode->ui_u2.ui_addr.ui_db[0] = ufsi->i_u1.i_data[0];
771         } else if (inode->i_blocks) {
772                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
773                         ufs_inode->ui_u2.ui_addr.ui_db[i] = ufsi->i_u1.i_data[i];
774         }
775         else {
776                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
777                         ufs_inode->ui_u2.ui_symlink[i] = ufsi->i_u1.i_symlink[i];
778         }
779
780         if (!inode->i_nlink)
781                 memset (ufs_inode, 0, sizeof(struct ufs_inode));
782                 
783         mark_buffer_dirty(bh);
784         if (do_sync)
785                 sync_dirty_buffer(bh);
786         brelse (bh);
787         
788         UFSD(("EXIT\n"))
789         return 0;
790 }
791
792 int ufs_write_inode (struct inode * inode, int wait)
793 {
794         int ret;
795         lock_kernel();
796         ret = ufs_update_inode (inode, wait);
797         unlock_kernel();
798         return ret;
799 }
800
801 int ufs_sync_inode (struct inode *inode)
802 {
803         return ufs_update_inode (inode, 1);
804 }
805
806 void ufs_delete_inode (struct inode * inode)
807 {
808         truncate_inode_pages(&inode->i_data, 0);
809         /*UFS_I(inode)->i_dtime = CURRENT_TIME;*/
810         lock_kernel();
811         mark_inode_dirty(inode);
812         ufs_update_inode(inode, IS_SYNC(inode));
813         inode->i_size = 0;
814         if (inode->i_blocks)
815                 ufs_truncate (inode);
816         ufs_free_inode (inode);
817         unlock_kernel();
818 }