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