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",
102 uspi
->s_fpbshift
, uspi
->s_apbmask
,
103 (unsigned long long)mask
);
111 if ((flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
)
114 block
= ufsi
->i_u1
.i_data
[*p
++];
118 struct buffer_head
*bh
;
121 bh
= sb_bread(sb
, uspi
->s_sbbase
+ fs32_to_cpu(sb
, block
)+(n
>>shift
));
124 block
= ((__fs32
*) bh
->b_data
)[n
& mask
];
129 ret
= (u64
) (uspi
->s_sbbase
+ fs32_to_cpu(sb
, block
) + (frag
& uspi
->s_fpbmask
));
132 u2_block
= ufsi
->i_u1
.u2_i_data
[*p
++];
138 struct buffer_head
*bh
;
142 temp
= (u64
)(uspi
->s_sbbase
) + fs64_to_cpu(sb
, u2_block
);
143 bh
= sb_bread(sb
, temp
+(u64
) (n
>>shift
));
146 u2_block
= ((__fs64
*)bh
->b_data
)[n
& mask
];
151 temp
= (u64
)uspi
->s_sbbase
+ fs64_to_cpu(sb
, u2_block
);
152 ret
= temp
+ (u64
) (frag
& uspi
->s_fpbmask
);
160 * ufs_inode_getfrag() - allocate new fragment(s)
161 * @inode - pointer to inode
162 * @fragment - number of `fragment' which hold pointer
163 * to new allocated fragment(s)
164 * @new_fragment - number of new allocated fragment(s)
165 * @required - how many fragment(s) we require
166 * @err - we set it if something wrong
167 * @phys - pointer to where we save physical number of new allocated fragments,
168 * NULL if we allocate not data(indirect blocks for example).
169 * @new - we set it if we allocate new block
170 * @locked_page - for ufs_new_fragments()
172 static struct buffer_head
*
173 ufs_inode_getfrag(struct inode
*inode
, unsigned int fragment
,
174 sector_t new_fragment
, unsigned int required
, int *err
,
175 long *phys
, int *new, struct page
*locked_page
)
177 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
178 struct super_block
*sb
= inode
->i_sb
;
179 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
180 struct buffer_head
* result
;
181 unsigned block
, blockoff
, lastfrag
, lastblock
, lastblockoff
;
185 UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, required %u, "
186 "metadata %d\n", inode
->i_ino
, fragment
,
187 (unsigned long long)new_fragment
, required
, !phys
);
189 /* TODO : to be done for write support
190 if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
194 block
= ufs_fragstoblks (fragment
);
195 blockoff
= ufs_fragnum (fragment
);
196 p
= ufsi
->i_u1
.i_data
+ block
;
200 tmp
= fs32_to_cpu(sb
, *p
);
201 lastfrag
= ufsi
->i_lastfrag
;
202 if (tmp
&& fragment
< lastfrag
) {
204 result
= sb_getblk(sb
, uspi
->s_sbbase
+ tmp
+ blockoff
);
205 if (tmp
== fs32_to_cpu(sb
, *p
)) {
206 UFSD("EXIT, result %u\n", tmp
+ blockoff
);
212 *phys
= tmp
+ blockoff
;
217 lastblock
= ufs_fragstoblks (lastfrag
);
218 lastblockoff
= ufs_fragnum (lastfrag
);
220 * We will extend file into new block beyond last allocated block
222 if (lastblock
< block
) {
224 * We must reallocate last allocated block
227 p2
= ufsi
->i_u1
.i_data
+ lastblock
;
228 tmp
= ufs_new_fragments (inode
, p2
, lastfrag
,
229 fs32_to_cpu(sb
, *p2
), uspi
->s_fpb
- lastblockoff
,
232 if (lastfrag
!= ufsi
->i_lastfrag
)
237 lastfrag
= ufsi
->i_lastfrag
;
240 tmp
= fs32_to_cpu(sb
, ufsi
->i_u1
.i_data
[lastblock
]);
242 goal
= tmp
+ uspi
->s_fpb
;
243 tmp
= ufs_new_fragments (inode
, p
, fragment
- blockoff
,
244 goal
, required
+ blockoff
,
246 phys
!= NULL
? locked_page
: NULL
);
249 * We will extend last allocated block
251 else if (lastblock
== block
) {
252 tmp
= ufs_new_fragments(inode
, p
, fragment
- (blockoff
- lastblockoff
),
253 fs32_to_cpu(sb
, *p
), required
+ (blockoff
- lastblockoff
),
254 err
, phys
!= NULL
? locked_page
: NULL
);
255 } else /* (lastblock > block) */ {
257 * We will allocate new block before last allocated block
260 tmp
= fs32_to_cpu(sb
, ufsi
->i_u1
.i_data
[block
-1]);
262 goal
= tmp
+ uspi
->s_fpb
;
264 tmp
= ufs_new_fragments(inode
, p
, fragment
- blockoff
,
265 goal
, uspi
->s_fpb
, err
,
266 phys
!= NULL
? locked_page
: NULL
);
269 if ((!blockoff
&& *p
) ||
270 (blockoff
&& lastfrag
!= ufsi
->i_lastfrag
))
277 result
= sb_getblk(sb
, tmp
+ blockoff
);
279 *phys
= tmp
+ blockoff
;
285 inode
->i_ctime
= CURRENT_TIME_SEC
;
287 ufs_sync_inode (inode
);
288 mark_inode_dirty(inode
);
289 UFSD("EXIT, result %u\n", tmp
+ blockoff
);
292 /* This part : To be implemented ....
293 Required only for writing, not required for READ-ONLY.
296 u2_block = ufs_fragstoblks(fragment);
297 u2_blockoff = ufs_fragnum(fragment);
298 p = ufsi->i_u1.u2_i_data + block;
302 tmp = fs32_to_cpu(sb, *p);
303 lastfrag = ufsi->i_lastfrag;
309 * ufs_inode_getblock() - allocate new block
310 * @inode - pointer to inode
311 * @bh - pointer to block which hold "pointer" to new allocated block
312 * @fragment - number of `fragment' which hold pointer
313 * to new allocated block
314 * @new_fragment - number of new allocated fragment
315 * (block will hold this fragment and also uspi->s_fpb-1)
316 * @err - see ufs_inode_getfrag()
317 * @phys - see ufs_inode_getfrag()
318 * @new - see ufs_inode_getfrag()
319 * @locked_page - see ufs_inode_getfrag()
321 static struct buffer_head
*
322 ufs_inode_getblock(struct inode
*inode
, struct buffer_head
*bh
,
323 unsigned int fragment
, sector_t new_fragment
, int *err
,
324 long *phys
, int *new, struct page
*locked_page
)
326 struct super_block
*sb
= inode
->i_sb
;
327 struct ufs_sb_private_info
*uspi
= UFS_SB(sb
)->s_uspi
;
328 struct buffer_head
* result
;
329 unsigned tmp
, goal
, block
, blockoff
;
332 block
= ufs_fragstoblks (fragment
);
333 blockoff
= ufs_fragnum (fragment
);
335 UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, metadata %d\n",
336 inode
->i_ino
, fragment
, (unsigned long long)new_fragment
, !phys
);
341 if (!buffer_uptodate(bh
)) {
342 ll_rw_block (READ
, 1, &bh
);
344 if (!buffer_uptodate(bh
))
348 p
= (__fs32
*) bh
->b_data
+ block
;
350 tmp
= fs32_to_cpu(sb
, *p
);
353 result
= sb_getblk(sb
, uspi
->s_sbbase
+ tmp
+ blockoff
);
354 if (tmp
== fs32_to_cpu(sb
, *p
))
359 *phys
= tmp
+ blockoff
;
364 if (block
&& (tmp
= fs32_to_cpu(sb
, ((__fs32
*)bh
->b_data
)[block
-1])))
365 goal
= tmp
+ uspi
->s_fpb
;
367 goal
= bh
->b_blocknr
+ uspi
->s_fpb
;
368 tmp
= ufs_new_fragments(inode
, p
, ufs_blknum(new_fragment
), goal
,
369 uspi
->s_fpb
, err
, locked_page
);
371 if (fs32_to_cpu(sb
, *p
))
378 result
= sb_getblk(sb
, tmp
+ blockoff
);
380 *phys
= tmp
+ blockoff
;
384 mark_buffer_dirty(bh
);
386 sync_dirty_buffer(bh
);
387 inode
->i_ctime
= CURRENT_TIME_SEC
;
388 mark_inode_dirty(inode
);
389 UFSD("result %u\n", tmp
+ blockoff
);
397 * ufs_getfrag_bloc() - `get_block_t' function, interface between UFS and
398 * readpage, writepage and so on
401 int ufs_getfrag_block(struct inode
*inode
, sector_t fragment
, struct buffer_head
*bh_result
, int create
)
403 struct super_block
* sb
= inode
->i_sb
;
404 struct ufs_sb_private_info
* uspi
= UFS_SB(sb
)->s_uspi
;
405 struct buffer_head
* bh
;
407 unsigned long ptr
,phys
;
411 phys64
= ufs_frag_map(inode
, fragment
);
412 UFSD("phys64 = %llu\n", (unsigned long long)phys64
);
414 map_bh(bh_result
, sb
, phys64
);
418 /* This code entered only while writing ....? */
427 UFSD("ENTER, ino %lu, fragment %llu\n", inode
->i_ino
, (unsigned long long)fragment
);
431 ((UFS_NDADDR
+ uspi
->s_apb
+ uspi
->s_2apb
+ uspi
->s_3apb
)
432 << uspi
->s_fpbshift
))
439 * ok, these macros clean the logic up a bit and make
440 * it much more readable:
442 #define GET_INODE_DATABLOCK(x) \
443 ufs_inode_getfrag(inode, x, fragment, 1, &err, &phys, &new,\
445 #define GET_INODE_PTR(x) \
446 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, NULL, NULL,\
448 #define GET_INDIRECT_DATABLOCK(x) \
449 ufs_inode_getblock(inode, bh, x, fragment, \
450 &err, &phys, &new, bh_result->b_page)
451 #define GET_INDIRECT_PTR(x) \
452 ufs_inode_getblock(inode, bh, x, fragment, \
453 &err, NULL, NULL, NULL)
455 if (ptr
< UFS_NDIR_FRAGMENT
) {
456 bh
= GET_INODE_DATABLOCK(ptr
);
459 ptr
-= UFS_NDIR_FRAGMENT
;
460 if (ptr
< (1 << (uspi
->s_apbshift
+ uspi
->s_fpbshift
))) {
461 bh
= GET_INODE_PTR(UFS_IND_FRAGMENT
+ (ptr
>> uspi
->s_apbshift
));
464 ptr
-= 1 << (uspi
->s_apbshift
+ uspi
->s_fpbshift
);
465 if (ptr
< (1 << (uspi
->s_2apbshift
+ uspi
->s_fpbshift
))) {
466 bh
= GET_INODE_PTR(UFS_DIND_FRAGMENT
+ (ptr
>> uspi
->s_2apbshift
));
469 ptr
-= 1 << (uspi
->s_2apbshift
+ uspi
->s_fpbshift
);
470 bh
= GET_INODE_PTR(UFS_TIND_FRAGMENT
+ (ptr
>> uspi
->s_3apbshift
));
471 bh
= GET_INDIRECT_PTR((ptr
>> uspi
->s_2apbshift
) & uspi
->s_apbmask
);
473 bh
= GET_INDIRECT_PTR((ptr
>> uspi
->s_apbshift
) & uspi
->s_apbmask
);
475 bh
= GET_INDIRECT_DATABLOCK(ptr
& uspi
->s_apbmask
);
477 #undef GET_INODE_DATABLOCK
479 #undef GET_INDIRECT_DATABLOCK
480 #undef GET_INDIRECT_PTR
486 set_buffer_new(bh_result
);
487 map_bh(bh_result
, sb
, phys
);
493 ufs_warning(sb
, "ufs_get_block", "block < 0");
497 ufs_warning(sb
, "ufs_get_block", "block > big");
501 static struct buffer_head
*ufs_getfrag(struct inode
*inode
,
502 unsigned int fragment
,
503 int create
, int *err
)
505 struct buffer_head dummy
;
509 dummy
.b_blocknr
= -1000;
510 error
= ufs_getfrag_block(inode
, fragment
, &dummy
, create
);
512 if (!error
&& buffer_mapped(&dummy
)) {
513 struct buffer_head
*bh
;
514 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
515 if (buffer_new(&dummy
)) {
516 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
517 set_buffer_uptodate(bh
);
518 mark_buffer_dirty(bh
);
525 struct buffer_head
* ufs_bread (struct inode
* inode
, unsigned fragment
,
526 int create
, int * err
)
528 struct buffer_head
* bh
;
530 UFSD("ENTER, ino %lu, fragment %u\n", inode
->i_ino
, fragment
);
531 bh
= ufs_getfrag (inode
, fragment
, create
, err
);
532 if (!bh
|| buffer_uptodate(bh
))
534 ll_rw_block (READ
, 1, &bh
);
536 if (buffer_uptodate(bh
))
543 static int ufs_writepage(struct page
*page
, struct writeback_control
*wbc
)
545 return block_write_full_page(page
,ufs_getfrag_block
,wbc
);
547 static int ufs_readpage(struct file
*file
, struct page
*page
)
549 return block_read_full_page(page
,ufs_getfrag_block
);
551 static int ufs_prepare_write(struct file
*file
, struct page
*page
, unsigned from
, unsigned to
)
553 return block_prepare_write(page
,from
,to
,ufs_getfrag_block
);
555 static sector_t
ufs_bmap(struct address_space
*mapping
, sector_t block
)
557 return generic_block_bmap(mapping
,block
,ufs_getfrag_block
);
559 const struct address_space_operations ufs_aops
= {
560 .readpage
= ufs_readpage
,
561 .writepage
= ufs_writepage
,
562 .sync_page
= block_sync_page
,
563 .prepare_write
= ufs_prepare_write
,
564 .commit_write
= generic_commit_write
,
568 static void ufs_set_inode_ops(struct inode
*inode
)
570 if (S_ISREG(inode
->i_mode
)) {
571 inode
->i_op
= &ufs_file_inode_operations
;
572 inode
->i_fop
= &ufs_file_operations
;
573 inode
->i_mapping
->a_ops
= &ufs_aops
;
574 } else if (S_ISDIR(inode
->i_mode
)) {
575 inode
->i_op
= &ufs_dir_inode_operations
;
576 inode
->i_fop
= &ufs_dir_operations
;
577 inode
->i_mapping
->a_ops
= &ufs_aops
;
578 } else if (S_ISLNK(inode
->i_mode
)) {
579 if (!inode
->i_blocks
)
580 inode
->i_op
= &ufs_fast_symlink_inode_operations
;
582 inode
->i_op
= &page_symlink_inode_operations
;
583 inode
->i_mapping
->a_ops
= &ufs_aops
;
586 init_special_inode(inode
, inode
->i_mode
,
587 ufs_get_inode_dev(inode
->i_sb
, UFS_I(inode
)));
590 static void ufs1_read_inode(struct inode
*inode
, struct ufs_inode
*ufs_inode
)
592 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
593 struct super_block
*sb
= inode
->i_sb
;
598 * Copy data to the in-core inode.
600 inode
->i_mode
= mode
= fs16_to_cpu(sb
, ufs_inode
->ui_mode
);
601 inode
->i_nlink
= fs16_to_cpu(sb
, ufs_inode
->ui_nlink
);
602 if (inode
->i_nlink
== 0)
603 ufs_error (sb
, "ufs_read_inode", "inode %lu has zero nlink\n", inode
->i_ino
);
606 * Linux now has 32-bit uid and gid, so we can support EFT.
608 inode
->i_uid
= ufs_get_inode_uid(sb
, ufs_inode
);
609 inode
->i_gid
= ufs_get_inode_gid(sb
, ufs_inode
);
611 inode
->i_size
= fs64_to_cpu(sb
, ufs_inode
->ui_size
);
612 inode
->i_atime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_atime
.tv_sec
);
613 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_ctime
.tv_sec
);
614 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sb
, ufs_inode
->ui_mtime
.tv_sec
);
615 inode
->i_mtime
.tv_nsec
= 0;
616 inode
->i_atime
.tv_nsec
= 0;
617 inode
->i_ctime
.tv_nsec
= 0;
618 inode
->i_blocks
= fs32_to_cpu(sb
, ufs_inode
->ui_blocks
);
619 ufsi
->i_flags
= fs32_to_cpu(sb
, ufs_inode
->ui_flags
);
620 ufsi
->i_gen
= fs32_to_cpu(sb
, ufs_inode
->ui_gen
);
621 ufsi
->i_shadow
= fs32_to_cpu(sb
, ufs_inode
->ui_u3
.ui_sun
.ui_shadow
);
622 ufsi
->i_oeftflag
= fs32_to_cpu(sb
, ufs_inode
->ui_u3
.ui_sun
.ui_oeftflag
);
625 if (S_ISCHR(mode
) || S_ISBLK(mode
) || inode
->i_blocks
) {
626 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
627 ufsi
->i_u1
.i_data
[i
] = ufs_inode
->ui_u2
.ui_addr
.ui_db
[i
];
629 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
630 ufsi
->i_u1
.i_symlink
[i
] = ufs_inode
->ui_u2
.ui_symlink
[i
];
634 static void ufs2_read_inode(struct inode
*inode
, struct ufs2_inode
*ufs2_inode
)
636 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
637 struct super_block
*sb
= inode
->i_sb
;
641 UFSD("Reading ufs2 inode, ino %lu\n", inode
->i_ino
);
643 * Copy data to the in-core inode.
645 inode
->i_mode
= mode
= fs16_to_cpu(sb
, ufs2_inode
->ui_mode
);
646 inode
->i_nlink
= fs16_to_cpu(sb
, ufs2_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
= fs32_to_cpu(sb
, ufs2_inode
->ui_uid
);
654 inode
->i_gid
= fs32_to_cpu(sb
, ufs2_inode
->ui_gid
);
656 inode
->i_size
= fs64_to_cpu(sb
, ufs2_inode
->ui_size
);
657 inode
->i_atime
.tv_sec
= fs32_to_cpu(sb
, ufs2_inode
->ui_atime
.tv_sec
);
658 inode
->i_ctime
.tv_sec
= fs32_to_cpu(sb
, ufs2_inode
->ui_ctime
.tv_sec
);
659 inode
->i_mtime
.tv_sec
= fs32_to_cpu(sb
, ufs2_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
= fs64_to_cpu(sb
, ufs2_inode
->ui_blocks
);
664 ufsi
->i_flags
= fs32_to_cpu(sb
, ufs2_inode
->ui_flags
);
665 ufsi
->i_gen
= fs32_to_cpu(sb
, ufs2_inode
->ui_gen
);
667 ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
668 ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
671 if (S_ISCHR(mode
) || S_ISBLK(mode
) || inode
->i_blocks
) {
672 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
673 ufsi
->i_u1
.u2_i_data
[i
] =
674 ufs2_inode
->ui_u2
.ui_addr
.ui_db
[i
];
676 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
677 ufsi
->i_u1
.i_symlink
[i
] = ufs2_inode
->ui_u2
.ui_symlink
[i
];
681 void ufs_read_inode(struct inode
* inode
)
683 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
684 struct super_block
* sb
;
685 struct ufs_sb_private_info
* uspi
;
686 struct buffer_head
* bh
;
688 UFSD("ENTER, ino %lu\n", inode
->i_ino
);
691 uspi
= UFS_SB(sb
)->s_uspi
;
693 if (inode
->i_ino
< UFS_ROOTINO
||
694 inode
->i_ino
> (uspi
->s_ncg
* uspi
->s_ipg
)) {
695 ufs_warning(sb
, "ufs_read_inode", "bad inode number (%lu)\n",
700 bh
= sb_bread(sb
, uspi
->s_sbbase
+ ufs_inotofsba(inode
->i_ino
));
702 ufs_warning(sb
, "ufs_read_inode", "unable to read inode %lu\n",
706 if ((UFS_SB(sb
)->s_flags
& UFS_TYPE_MASK
) == UFS_TYPE_UFS2
) {
707 struct ufs2_inode
*ufs2_inode
= (struct ufs2_inode
*)bh
->b_data
;
709 ufs2_read_inode(inode
,
710 ufs2_inode
+ ufs_inotofsbo(inode
->i_ino
));
712 struct ufs_inode
*ufs_inode
= (struct ufs_inode
*)bh
->b_data
;
714 ufs1_read_inode(inode
, ufs_inode
+ ufs_inotofsbo(inode
->i_ino
));
719 (inode
->i_size
+ uspi
->s_fsize
- 1) >> uspi
->s_fshift
;
720 ufsi
->i_dir_start_lookup
= 0;
723 ufs_set_inode_ops(inode
);
731 make_bad_inode(inode
);
734 static int ufs_update_inode(struct inode
* inode
, int do_sync
)
736 struct ufs_inode_info
*ufsi
= UFS_I(inode
);
737 struct super_block
* sb
;
738 struct ufs_sb_private_info
* uspi
;
739 struct buffer_head
* bh
;
740 struct ufs_inode
* ufs_inode
;
744 UFSD("ENTER, ino %lu\n", inode
->i_ino
);
747 uspi
= UFS_SB(sb
)->s_uspi
;
748 flags
= UFS_SB(sb
)->s_flags
;
750 if (inode
->i_ino
< UFS_ROOTINO
||
751 inode
->i_ino
> (uspi
->s_ncg
* uspi
->s_ipg
)) {
752 ufs_warning (sb
, "ufs_read_inode", "bad inode number (%lu)\n", inode
->i_ino
);
756 bh
= sb_bread(sb
, ufs_inotofsba(inode
->i_ino
));
758 ufs_warning (sb
, "ufs_read_inode", "unable to read inode %lu\n", inode
->i_ino
);
761 ufs_inode
= (struct ufs_inode
*) (bh
->b_data
+ ufs_inotofsbo(inode
->i_ino
) * sizeof(struct ufs_inode
));
763 ufs_inode
->ui_mode
= cpu_to_fs16(sb
, inode
->i_mode
);
764 ufs_inode
->ui_nlink
= cpu_to_fs16(sb
, inode
->i_nlink
);
766 ufs_set_inode_uid(sb
, ufs_inode
, inode
->i_uid
);
767 ufs_set_inode_gid(sb
, ufs_inode
, inode
->i_gid
);
769 ufs_inode
->ui_size
= cpu_to_fs64(sb
, inode
->i_size
);
770 ufs_inode
->ui_atime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_atime
.tv_sec
);
771 ufs_inode
->ui_atime
.tv_usec
= 0;
772 ufs_inode
->ui_ctime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_ctime
.tv_sec
);
773 ufs_inode
->ui_ctime
.tv_usec
= 0;
774 ufs_inode
->ui_mtime
.tv_sec
= cpu_to_fs32(sb
, inode
->i_mtime
.tv_sec
);
775 ufs_inode
->ui_mtime
.tv_usec
= 0;
776 ufs_inode
->ui_blocks
= cpu_to_fs32(sb
, inode
->i_blocks
);
777 ufs_inode
->ui_flags
= cpu_to_fs32(sb
, ufsi
->i_flags
);
778 ufs_inode
->ui_gen
= cpu_to_fs32(sb
, ufsi
->i_gen
);
780 if ((flags
& UFS_UID_MASK
) == UFS_UID_EFT
) {
781 ufs_inode
->ui_u3
.ui_sun
.ui_shadow
= cpu_to_fs32(sb
, ufsi
->i_shadow
);
782 ufs_inode
->ui_u3
.ui_sun
.ui_oeftflag
= cpu_to_fs32(sb
, ufsi
->i_oeftflag
);
785 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
786 /* ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, inode->i_rdev); */
787 ufs_inode
->ui_u2
.ui_addr
.ui_db
[0] = ufsi
->i_u1
.i_data
[0];
788 } else if (inode
->i_blocks
) {
789 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
); i
++)
790 ufs_inode
->ui_u2
.ui_addr
.ui_db
[i
] = ufsi
->i_u1
.i_data
[i
];
793 for (i
= 0; i
< (UFS_NDADDR
+ UFS_NINDIR
) * 4; i
++)
794 ufs_inode
->ui_u2
.ui_symlink
[i
] = ufsi
->i_u1
.i_symlink
[i
];
798 memset (ufs_inode
, 0, sizeof(struct ufs_inode
));
800 mark_buffer_dirty(bh
);
802 sync_dirty_buffer(bh
);
809 int ufs_write_inode (struct inode
* inode
, int wait
)
813 ret
= ufs_update_inode (inode
, wait
);
818 int ufs_sync_inode (struct inode
*inode
)
820 return ufs_update_inode (inode
, 1);
823 void ufs_delete_inode (struct inode
* inode
)
827 truncate_inode_pages(&inode
->i_data
, 0);
828 /*UFS_I(inode)->i_dtime = CURRENT_TIME;*/
830 mark_inode_dirty(inode
);
831 ufs_update_inode(inode
, IS_SYNC(inode
));
832 old_i_size
= inode
->i_size
;
834 if (inode
->i_blocks
&& ufs_truncate(inode
, old_i_size
))
835 ufs_warning(inode
->i_sb
, __FUNCTION__
, "ufs_truncate failed\n");
836 ufs_free_inode (inode
);