5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
10 * linux/fs/ext2/inode.c
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)
19 * linux/fs/minix/inode.c
21 * Copyright (C) 1991, 1992 Linus Torvalds
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
28 #include <asm/uaccess.h>
29 #include <asm/system.h>
31 #include <linux/errno.h>
33 #include <linux/ufs_fs.h>
34 #include <linux/time.h>
35 #include <linux/stat.h>
36 #include <linux/string.h>
38 #include <linux/smp_lock.h>
39 #include <linux/buffer_head.h>
44 static u64
ufs_frag_map(struct inode
*inode
, sector_t frag
);
46 static int ufs_block_to_path(struct inode
*inode
, sector_t i_block
, sector_t offsets
[4])
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));
57 UFSD("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs
,double_blocks
);
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);
75 ufs_warning(inode
->i_sb
, "ufs_block_to_path", "block > big");
81 * Returns the location of the fragment from
82 * the begining of the filesystem.
85 static u64
ufs_frag_map(struct inode
*inode
, sector_t frag
)
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
);
97 unsigned flags
= UFS_SB(sb
)->s_flags
;
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
);
109 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
112 block
= ufsi
->i_u1
.i_data
[*p
++];
116 struct buffer_head
*bh
;
119 bh
= sb_bread(sb
, uspi
->s_sbbase
+ fs32_to_cpu(sb
, block
)+(n
>>shift
));
122 block
= ((__fs32
*) bh
->b_data
)[n
& mask
];
127 ret
= (u64
) (uspi
->s_sbbase
+ fs32_to_cpu(sb
, block
) + (frag
& uspi
->s_fpbmask
));
130 u2_block
= ufsi
->i_u1
.u2_i_data
[*p
++];
136 struct buffer_head
*bh
;
140 temp
= (u64
)(uspi
->s_sbbase
) + fs64_to_cpu(sb
, u2_block
);
141 bh
= sb_bread(sb
, temp
+(u64
) (n
>>shift
));
144 u2_block
= ((__fs64
*)bh
->b_data
)[n
& mask
];
149 temp
= (u64
)uspi
->s_sbbase
+ fs64_to_cpu(sb
, u2_block
);
150 ret
= temp
+ (u64
) (frag
& uspi
->s_fpbmask
);
157 static void ufs_clear_frag(struct inode
*inode
, struct buffer_head
*bh
)
160 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
161 set_buffer_uptodate(bh
);
162 mark_buffer_dirty(bh
);
165 sync_dirty_buffer(bh
);
168 static struct buffer_head
*
169 ufs_clear_frags(struct inode
*inode
, sector_t beg
,
172 struct buffer_head
*res
, *bh
;
173 sector_t end
= beg
+ n
;
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
);
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()
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
)
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
;
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
);
215 /* TODO : to be done for write support
216 if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
220 block
= ufs_fragstoblks (fragment
);
221 blockoff
= ufs_fragnum (fragment
);
222 p
= ufsi
->i_u1
.i_data
+ block
;
226 tmp
= fs32_to_cpu(sb
, *p
);
227 lastfrag
= ufsi
->i_lastfrag
;
228 if (tmp
&& fragment
< lastfrag
) {
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
);
238 *phys
= tmp
+ blockoff
;
243 lastblock
= ufs_fragstoblks (lastfrag
);
244 lastblockoff
= ufs_fragnum (lastfrag
);
246 * We will extend file into new block beyond last allocated block
248 if (lastblock
< block
) {
250 * We must reallocate last allocated block
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
,
258 if (lastfrag
!= ufsi
->i_lastfrag
)
263 lastfrag
= ufsi
->i_lastfrag
;
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
,
272 * We will extend last allocated block
274 else if (lastblock
== block
) {
275 tmp
= ufs_new_fragments(inode
, p
, fragment
- (blockoff
- lastblockoff
),
276 fs32_to_cpu(sb
, *p
), required
+ (blockoff
- lastblockoff
),
280 * We will allocate new block before last allocated block
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
);
289 if ((!blockoff
&& *p
) ||
290 (blockoff
&& lastfrag
!= ufsi
->i_lastfrag
))
297 result
= ufs_clear_frags(inode
, tmp
+ blockoff
, required
);
299 *phys
= tmp
+ blockoff
;
305 inode
->i_ctime
= CURRENT_TIME_SEC
;
307 ufs_sync_inode (inode
);
308 mark_inode_dirty(inode
);
309 UFSD("EXIT, result %u\n", tmp
+ blockoff
);
312 /* This part : To be implemented ....
313 Required only for writing, not required for READ-ONLY.
316 u2_block = ufs_fragstoblks(fragment);
317 u2_blockoff = ufs_fragnum(fragment);
318 p = ufsi->i_u1.u2_i_data + block;
322 tmp = fs32_to_cpu(sb, *p);
323 lastfrag = ufsi->i_lastfrag;
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()
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
)
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
;
352 block
= ufs_fragstoblks (fragment
);
353 blockoff
= ufs_fragnum (fragment
);
355 UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, metadata %d\n",
356 inode
->i_ino
, fragment
, (unsigned long long)new_fragment
, !phys
);
361 if (!buffer_uptodate(bh
)) {
362 ll_rw_block (READ
, 1, &bh
);
364 if (!buffer_uptodate(bh
))
368 p
= (__fs32
*) bh
->b_data
+ block
;
370 tmp
= fs32_to_cpu(sb
, *p
);
373 result
= sb_getblk(sb
, uspi
->s_sbbase
+ tmp
+ blockoff
);
374 if (tmp
== fs32_to_cpu(sb
, *p
))
379 *phys
= tmp
+ blockoff
;
384 if (block
&& (tmp
= fs32_to_cpu(sb
, ((__fs32
*)bh
->b_data
)[block
-1]) + uspi
->s_fpb
))
385 goal
= tmp
+ uspi
->s_fpb
;
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
);
391 if (fs32_to_cpu(sb
, *p
))
398 result
= ufs_clear_frags(inode
, tmp
+ blockoff
, uspi
->s_fpb
);
400 *phys
= tmp
+ blockoff
;
404 mark_buffer_dirty(bh
);
406 sync_dirty_buffer(bh
);
407 inode
->i_ctime
= CURRENT_TIME_SEC
;
408 mark_inode_dirty(inode
);
409 UFSD("result %u\n", tmp
+ blockoff
);
417 * ufs_getfrag_bloc() - `get_block_t' function, interface between UFS and
418 * readpage, writepage and so on
421 int ufs_getfrag_block(struct inode
*inode
, sector_t fragment
, struct buffer_head
*bh_result
, int create
)
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
;
427 unsigned long ptr
,phys
;
431 phys64
= ufs_frag_map(inode
, fragment
);
432 UFSD("phys64 = %llu \n",phys64
);
434 map_bh(bh_result
, sb
, phys64
);
438 /* This code entered only while writing ....? */
447 UFSD("ENTER, ino %lu, fragment %llu\n", inode
->i_ino
, (unsigned long long)fragment
);
451 ((UFS_NDADDR
+ uspi
->s_apb
+ uspi
->s_2apb
+ uspi
->s_3apb
)
452 << uspi
->s_fpbshift
))
459 * ok, these macros clean the logic up a bit and make
460 * it much more readable:
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);
473 if (ptr
< UFS_NDIR_FRAGMENT
) {
474 bh
= GET_INODE_DATABLOCK(ptr
);
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
));
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
));
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
);
491 bh
= GET_INDIRECT_PTR((ptr
>> uspi
->s_apbshift
) & uspi
->s_apbmask
);
493 bh
= GET_INDIRECT_DATABLOCK(ptr
& uspi
->s_apbmask
);
495 #undef GET_INODE_DATABLOCK
497 #undef GET_INDIRECT_DATABLOCK
498 #undef GET_INDIRECT_PTR
504 set_buffer_new(bh_result
);
505 map_bh(bh_result
, sb
, phys
);
511 ufs_warning(sb
, "ufs_get_block", "block < 0");
515 ufs_warning(sb
, "ufs_get_block", "block > big");
519 static struct buffer_head
*ufs_getfrag(struct inode
*inode
,
520 unsigned int fragment
,
521 int create
, int *err
)
523 struct buffer_head dummy
;
527 dummy
.b_blocknr
= -1000;
528 error
= ufs_getfrag_block(inode
, fragment
, &dummy
, create
);
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
);
543 struct buffer_head
* ufs_bread (struct inode
* inode
, unsigned fragment
,
544 int create
, int * err
)
546 struct buffer_head
* bh
;
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
))
552 ll_rw_block (READ
, 1, &bh
);
554 if (buffer_uptodate(bh
))
561 static int ufs_writepage(struct page
*page
, struct writeback_control
*wbc
)
563 return block_write_full_page(page
,ufs_getfrag_block
,wbc
);
565 static int ufs_readpage(struct file
*file
, struct page
*page
)
567 return block_read_full_page(page
,ufs_getfrag_block
);
569 static int ufs_prepare_write(struct file
*file
, struct page
*page
, unsigned from
, unsigned to
)
571 return block_prepare_write(page
,from
,to
,ufs_getfrag_block
);
573 static sector_t
ufs_bmap(struct address_space
*mapping
, sector_t block
)
575 return generic_block_bmap(mapping
,block
,ufs_getfrag_block
);
577 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
,
586 static void ufs_set_inode_ops(struct inode
*inode
)
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
;
600 inode
->i_op
= &page_symlink_inode_operations
;
601 inode
->i_mapping
->a_ops
= &ufs_aops
;
604 init_special_inode(inode
, inode
->i_mode
,
605 ufs_get_inode_dev(inode
->i_sb
, UFS_I(inode
)));
608 void ufs_read_inode (struct inode
* inode
)
610 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
611 struct super_block
* sb
;
612 struct ufs_sb_private_info
* uspi
;
613 struct ufs_inode
* ufs_inode
;
614 struct ufs2_inode
*ufs2_inode
;
615 struct buffer_head
* bh
;
620 UFSD("ENTER, ino %lu\n", inode
->i_ino
);
623 uspi
= UFS_SB(sb
)->s_uspi
;
624 flags
= UFS_SB(sb
)->s_flags
;
626 if (inode
->i_ino
< UFS_ROOTINO
||
627 inode
->i_ino
> (uspi
->s_ncg
* uspi
->s_ipg
)) {
628 ufs_warning (sb
, "ufs_read_inode", "bad inode number (%lu)\n", inode
->i_ino
);
632 bh
= sb_bread(sb
, uspi
->s_sbbase
+ ufs_inotofsba(inode
->i_ino
));
634 ufs_warning (sb
, "ufs_read_inode", "unable to read inode %lu\n", inode
->i_ino
);
637 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
640 ufs_inode
= (struct ufs_inode
*) (bh
->b_data
+ sizeof(struct ufs_inode
) * ufs_inotofsbo(inode
->i_ino
));
643 * Copy data to the in-core inode.
645 inode
->i_mode
= mode
= fs16_to_cpu(sb
, ufs_inode
->ui_mode
);
646 inode
->i_nlink
= fs16_to_cpu(sb
, ufs_inode
->ui_nlink
);
647 if (inode
->i_nlink
== 0)
648 ufs_error (sb
, "ufs_read_inode", "inode %lu has zero nlink\n", inode
->i_ino
);
651 * Linux now has 32-bit uid and gid, so we can support EFT.
653 inode
->i_uid
= ufs_get_inode_uid(sb
, ufs_inode
);
654 inode
->i_gid
= ufs_get_inode_gid(sb
, ufs_inode
);
656 inode
->i_size
= fs64_to_cpu(sb
, ufs_inode
->ui_size
);
657 inode
->i_atime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_atime
.tv_sec
);
658 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_ctime
.tv_sec
);
659 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_mtime
.tv_sec
);
660 inode
->i_mtime
.tv_nsec
= 0;
661 inode
->i_atime
.tv_nsec
= 0;
662 inode
->i_ctime
.tv_nsec
= 0;
663 inode
->i_blocks
= fs32_to_cpu(sb
, ufs_inode
->ui_blocks
);
664 inode
->i_blksize
= PAGE_SIZE
; /* This is the optimal IO size (for stat) */
666 ufsi
->i_flags
= fs32_to_cpu(sb
, ufs_inode
->ui_flags
);
667 ufsi
->i_gen
= fs32_to_cpu(sb
, ufs_inode
->ui_gen
);
668 ufsi
->i_shadow
= fs32_to_cpu(sb
, ufs_inode
->ui_u3
.ui_sun
.ui_shadow
);
669 ufsi
->i_oeftflag
= fs32_to_cpu(sb
, ufs_inode
->ui_u3
.ui_sun
.ui_oeftflag
);
670 ufsi
->i_lastfrag
= (inode
->i_size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
671 ufsi
->i_dir_start_lookup
= 0;
673 if (S_ISCHR(mode
) || S_ISBLK(mode
) || inode
->i_blocks
) {
674 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
675 ufsi
->i_u1
.i_data
[i
] = ufs_inode
->ui_u2
.ui_addr
.ui_db
[i
];
677 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
678 ufsi
->i_u1
.i_symlink
[i
] = ufs_inode
->ui_u2
.ui_symlink
[i
];
682 ufs_set_inode_ops(inode
);
690 make_bad_inode(inode
);
694 UFSD("Reading ufs2 inode, ino %lu\n", inode
->i_ino
);
696 ufs2_inode
= (struct ufs2_inode
*)(bh
->b_data
+ sizeof(struct ufs2_inode
) * ufs_inotofsbo(inode
->i_ino
));
699 * Copy data to the in-core inode.
701 inode
->i_mode
= mode
= fs16_to_cpu(sb
, ufs2_inode
->ui_mode
);
702 inode
->i_nlink
= fs16_to_cpu(sb
, ufs2_inode
->ui_nlink
);
703 if (inode
->i_nlink
== 0)
704 ufs_error (sb
, "ufs_read_inode", "inode %lu has zero nlink\n", inode
->i_ino
);
707 * Linux now has 32-bit uid and gid, so we can support EFT.
709 inode
->i_uid
= fs32_to_cpu(sb
, ufs2_inode
->ui_uid
);
710 inode
->i_gid
= fs32_to_cpu(sb
, ufs2_inode
->ui_gid
);
712 inode
->i_size
= fs64_to_cpu(sb
, ufs2_inode
->ui_size
);
713 inode
->i_atime
.tv_sec
= fs32_to_cpu(sb
, ufs2_inode
->ui_atime
.tv_sec
);
714 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sb
, ufs2_inode
->ui_ctime
.tv_sec
);
715 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sb
, ufs2_inode
->ui_mtime
.tv_sec
);
716 inode
->i_mtime
.tv_nsec
= 0;
717 inode
->i_atime
.tv_nsec
= 0;
718 inode
->i_ctime
.tv_nsec
= 0;
719 inode
->i_blocks
= fs64_to_cpu(sb
, ufs2_inode
->ui_blocks
);
720 inode
->i_blksize
= PAGE_SIZE
; /*This is the optimal IO size(for stat)*/
723 ufsi
->i_flags
= fs32_to_cpu(sb
, ufs2_inode
->ui_flags
);
724 ufsi
->i_gen
= fs32_to_cpu(sb
, ufs2_inode
->ui_gen
);
726 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
727 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
729 ufsi
->i_lastfrag
= (inode
->i_size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
731 if (S_ISCHR(mode
) || S_ISBLK(mode
) || inode
->i_blocks
) {
732 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
733 ufsi
->i_u1
.u2_i_data
[i
] =
734 ufs2_inode
->ui_u2
.ui_addr
.ui_db
[i
];
737 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
738 ufsi
->i_u1
.i_symlink
[i
] = ufs2_inode
->ui_u2
.ui_symlink
[i
];
742 ufs_set_inode_ops(inode
);
750 static int ufs_update_inode(struct inode
* inode
, int do_sync
)
752 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
753 struct super_block
* sb
;
754 struct ufs_sb_private_info
* uspi
;
755 struct buffer_head
* bh
;
756 struct ufs_inode
* ufs_inode
;
760 UFSD("ENTER, ino %lu\n", inode
->i_ino
);
763 uspi
= UFS_SB(sb
)->s_uspi
;
764 flags
= UFS_SB(sb
)->s_flags
;
766 if (inode
->i_ino
< UFS_ROOTINO
||
767 inode
->i_ino
> (uspi
->s_ncg
* uspi
->s_ipg
)) {
768 ufs_warning (sb
, "ufs_read_inode", "bad inode number (%lu)\n", inode
->i_ino
);
772 bh
= sb_bread(sb
, ufs_inotofsba(inode
->i_ino
));
774 ufs_warning (sb
, "ufs_read_inode", "unable to read inode %lu\n", inode
->i_ino
);
777 ufs_inode
= (struct ufs_inode
*) (bh
->b_data
+ ufs_inotofsbo(inode
->i_ino
) * sizeof(struct ufs_inode
));
779 ufs_inode
->ui_mode
= cpu_to_fs16(sb
, inode
->i_mode
);
780 ufs_inode
->ui_nlink
= cpu_to_fs16(sb
, inode
->i_nlink
);
782 ufs_set_inode_uid(sb
, ufs_inode
, inode
->i_uid
);
783 ufs_set_inode_gid(sb
, ufs_inode
, inode
->i_gid
);
785 ufs_inode
->ui_size
= cpu_to_fs64(sb
, inode
->i_size
);
786 ufs_inode
->ui_atime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_atime
.tv_sec
);
787 ufs_inode
->ui_atime
.tv_usec
= 0;
788 ufs_inode
->ui_ctime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_ctime
.tv_sec
);
789 ufs_inode
->ui_ctime
.tv_usec
= 0;
790 ufs_inode
->ui_mtime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_mtime
.tv_sec
);
791 ufs_inode
->ui_mtime
.tv_usec
= 0;
792 ufs_inode
->ui_blocks
= cpu_to_fs32(sb
, inode
->i_blocks
);
793 ufs_inode
->ui_flags
= cpu_to_fs32(sb
, ufsi
->i_flags
);
794 ufs_inode
->ui_gen
= cpu_to_fs32(sb
, ufsi
->i_gen
);
796 if ((flags
& UFS_UID_MASK
) == UFS_UID_EFT
) {
797 ufs_inode
->ui_u3
.ui_sun
.ui_shadow
= cpu_to_fs32(sb
, ufsi
->i_shadow
);
798 ufs_inode
->ui_u3
.ui_sun
.ui_oeftflag
= cpu_to_fs32(sb
, ufsi
->i_oeftflag
);
801 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
802 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
803 ufs_inode
->ui_u2
.ui_addr
.ui_db
[0] = ufsi
->i_u1
.i_data
[0];
804 } else if (inode
->i_blocks
) {
805 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
806 ufs_inode
->ui_u2
.ui_addr
.ui_db
[i
] = ufsi
->i_u1
.i_data
[i
];
809 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
810 ufs_inode
->ui_u2
.ui_symlink
[i
] = ufsi
->i_u1
.i_symlink
[i
];
814 memset (ufs_inode
, 0, sizeof(struct ufs_inode
));
816 mark_buffer_dirty(bh
);
818 sync_dirty_buffer(bh
);
825 int ufs_write_inode (struct inode
* inode
, int wait
)
829 ret
= ufs_update_inode (inode
, wait
);
834 int ufs_sync_inode (struct inode
*inode
)
836 return ufs_update_inode (inode
, 1);
839 void ufs_delete_inode (struct inode
* inode
)
841 truncate_inode_pages(&inode
->i_data
, 0);
842 /*UFS_I(inode)->i_dtime = CURRENT_TIME;*/
844 mark_inode_dirty(inode
);
845 ufs_update_inode(inode
, IS_SYNC(inode
));
848 ufs_truncate (inode
);
849 ufs_free_inode (inode
);