5 * Inode handling routines for the OSTA-UDF(tm) filesystem.
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
13 * (C) 1998 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
19 * 10/04/98 dgb Added rudimentary directory functions
20 * 10/07/98 Fully working udf_block_map! It works!
21 * 11/25/98 bmap altered to better support extents
22 * 12/06/98 blf partition support in udf_iget, udf_block_map
24 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
25 * block boundaries (which is not actually allowed)
26 * 12/20/98 added support for strategy 4096
27 * 03/07/99 rewrote udf_block_map (again)
28 * New funcs, inode_bmap, udf_next_aext
29 * 04/19/99 Support for writing device EA's for major/minor #
34 #include <linux/smp_lock.h>
35 #include <linux/module.h>
36 #include <linux/pagemap.h>
37 #include <linux/buffer_head.h>
38 #include <linux/writeback.h>
39 #include <linux/slab.h>
44 MODULE_AUTHOR("Ben Fennema");
45 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
46 MODULE_LICENSE("GPL");
48 #define EXTENT_MERGE_SIZE 5
50 static mode_t
udf_convert_permissions(struct fileEntry
*);
51 static int udf_update_inode(struct inode
*, int);
52 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
53 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
54 static struct buffer_head
*inode_getblk(struct inode
*, sector_t
, int *,
56 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
57 kernel_lb_addr
, uint32_t);
58 static void udf_split_extents(struct inode
*, int *, int, int,
59 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
60 static void udf_prealloc_extents(struct inode
*, int, int,
61 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
62 static void udf_merge_extents(struct inode
*,
63 kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
64 static void udf_update_extents(struct inode
*,
65 kernel_long_ad
[EXTENT_MERGE_SIZE
], int, int,
66 struct extent_position
*);
67 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
70 void udf_delete_inode(struct inode
*inode
)
72 truncate_inode_pages(&inode
->i_data
, 0);
74 if (is_bad_inode(inode
))
81 udf_update_inode(inode
, IS_SYNC(inode
));
82 udf_free_inode(inode
);
92 * If we are going to release inode from memory, we discard preallocation and
93 * truncate last inode extent to proper length. We could use drop_inode() but
94 * it's called under inode_lock and thus we cannot mark inode dirty there. We
95 * use clear_inode() but we have to make sure to write inode as it's not written
98 void udf_clear_inode(struct inode
*inode
)
100 struct udf_inode_info
*iinfo
;
101 if (!(inode
->i_sb
->s_flags
& MS_RDONLY
)) {
103 /* Discard preallocation for directories, symlinks, etc. */
104 udf_discard_prealloc(inode
);
105 udf_truncate_tail_extent(inode
);
107 write_inode_now(inode
, 0);
109 iinfo
= UDF_I(inode
);
110 kfree(iinfo
->i_ext
.i_data
);
111 iinfo
->i_ext
.i_data
= NULL
;
114 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
116 return block_write_full_page(page
, udf_get_block
, wbc
);
119 static int udf_readpage(struct file
*file
, struct page
*page
)
121 return block_read_full_page(page
, udf_get_block
);
124 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
125 loff_t pos
, unsigned len
, unsigned flags
,
126 struct page
**pagep
, void **fsdata
)
129 return block_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
133 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
135 return generic_block_bmap(mapping
, block
, udf_get_block
);
138 const struct address_space_operations udf_aops
= {
139 .readpage
= udf_readpage
,
140 .writepage
= udf_writepage
,
141 .sync_page
= block_sync_page
,
142 .write_begin
= udf_write_begin
,
143 .write_end
= generic_write_end
,
147 void udf_expand_file_adinicb(struct inode
*inode
, int newsize
, int *err
)
151 struct udf_inode_info
*iinfo
= UDF_I(inode
);
152 struct writeback_control udf_wbc
= {
153 .sync_mode
= WB_SYNC_NONE
,
157 /* from now on we have normal address_space methods */
158 inode
->i_data
.a_ops
= &udf_aops
;
160 if (!iinfo
->i_lenAlloc
) {
161 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
162 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
164 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
165 mark_inode_dirty(inode
);
169 page
= grab_cache_page(inode
->i_mapping
, 0);
170 BUG_ON(!PageLocked(page
));
172 if (!PageUptodate(page
)) {
174 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
175 PAGE_CACHE_SIZE
- iinfo
->i_lenAlloc
);
176 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
178 flush_dcache_page(page
);
179 SetPageUptodate(page
);
182 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
184 iinfo
->i_lenAlloc
= 0;
185 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
186 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
188 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
190 inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
191 page_cache_release(page
);
193 mark_inode_dirty(inode
);
196 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
200 struct buffer_head
*dbh
= NULL
;
204 struct extent_position epos
;
206 struct udf_fileident_bh sfibh
, dfibh
;
207 loff_t f_pos
= udf_ext0_offset(inode
);
208 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
209 struct fileIdentDesc cfi
, *sfi
, *dfi
;
210 struct udf_inode_info
*iinfo
= UDF_I(inode
);
212 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
213 alloctype
= ICBTAG_FLAG_AD_SHORT
;
215 alloctype
= ICBTAG_FLAG_AD_LONG
;
217 if (!inode
->i_size
) {
218 iinfo
->i_alloc_type
= alloctype
;
219 mark_inode_dirty(inode
);
223 /* alloc block, and copy data to it */
224 *block
= udf_new_block(inode
->i_sb
, inode
,
225 iinfo
->i_location
.partitionReferenceNum
,
226 iinfo
->i_location
.logicalBlockNum
, err
);
229 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
230 iinfo
->i_location
.partitionReferenceNum
,
234 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
238 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
239 set_buffer_uptodate(dbh
);
241 mark_buffer_dirty_inode(dbh
, inode
);
243 sfibh
.soffset
= sfibh
.eoffset
=
244 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
245 sfibh
.sbh
= sfibh
.ebh
= NULL
;
246 dfibh
.soffset
= dfibh
.eoffset
= 0;
247 dfibh
.sbh
= dfibh
.ebh
= dbh
;
248 while (f_pos
< size
) {
249 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
250 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
256 iinfo
->i_alloc_type
= alloctype
;
257 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
258 dfibh
.soffset
= dfibh
.eoffset
;
259 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
260 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
261 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
263 le16_to_cpu(sfi
->lengthOfImpUse
))) {
264 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
269 mark_buffer_dirty_inode(dbh
, inode
);
271 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
273 iinfo
->i_lenAlloc
= 0;
274 eloc
.logicalBlockNum
= *block
;
275 eloc
.partitionReferenceNum
=
276 iinfo
->i_location
.partitionReferenceNum
;
277 elen
= inode
->i_sb
->s_blocksize
;
278 iinfo
->i_lenExtents
= elen
;
280 epos
.block
= iinfo
->i_location
;
281 epos
.offset
= udf_file_entry_alloc_offset(inode
);
282 udf_add_aext(inode
, &epos
, eloc
, elen
, 0);
286 mark_inode_dirty(inode
);
290 static int udf_get_block(struct inode
*inode
, sector_t block
,
291 struct buffer_head
*bh_result
, int create
)
294 struct buffer_head
*bh
;
296 struct udf_inode_info
*iinfo
;
299 phys
= udf_block_map(inode
, block
);
301 map_bh(bh_result
, inode
->i_sb
, phys
);
311 iinfo
= UDF_I(inode
);
312 if (block
== iinfo
->i_next_alloc_block
+ 1) {
313 iinfo
->i_next_alloc_block
++;
314 iinfo
->i_next_alloc_goal
++;
319 bh
= inode_getblk(inode
, block
, &err
, &phys
, &new);
326 set_buffer_new(bh_result
);
327 map_bh(bh_result
, inode
->i_sb
, phys
);
334 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
335 int create
, int *err
)
337 struct buffer_head
*bh
;
338 struct buffer_head dummy
;
341 dummy
.b_blocknr
= -1000;
342 *err
= udf_get_block(inode
, block
, &dummy
, create
);
343 if (!*err
&& buffer_mapped(&dummy
)) {
344 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
345 if (buffer_new(&dummy
)) {
347 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
348 set_buffer_uptodate(bh
);
350 mark_buffer_dirty_inode(bh
, inode
);
358 /* Extend the file by 'blocks' blocks, return the number of extents added */
359 int udf_extend_file(struct inode
*inode
, struct extent_position
*last_pos
,
360 kernel_long_ad
*last_ext
, sector_t blocks
)
363 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
364 struct super_block
*sb
= inode
->i_sb
;
365 kernel_lb_addr prealloc_loc
= {};
366 int prealloc_len
= 0;
367 struct udf_inode_info
*iinfo
;
369 /* The previous extent is fake and we should not extend by anything
370 * - there's nothing to do... */
374 iinfo
= UDF_I(inode
);
375 /* Round the last extent up to a multiple of block size */
376 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
377 last_ext
->extLength
=
378 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
379 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
380 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
381 iinfo
->i_lenExtents
=
382 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
383 ~(sb
->s_blocksize
- 1);
386 /* Last extent are just preallocated blocks? */
387 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
388 EXT_NOT_RECORDED_ALLOCATED
) {
389 /* Save the extent so that we can reattach it to the end */
390 prealloc_loc
= last_ext
->extLocation
;
391 prealloc_len
= last_ext
->extLength
;
392 /* Mark the extent as a hole */
393 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
394 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
395 last_ext
->extLocation
.logicalBlockNum
= 0;
396 last_ext
->extLocation
.partitionReferenceNum
= 0;
399 /* Can we merge with the previous extent? */
400 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
401 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
402 add
= ((1 << 30) - sb
->s_blocksize
-
403 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
404 sb
->s_blocksize_bits
;
408 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
412 udf_add_aext(inode
, last_pos
, last_ext
->extLocation
,
413 last_ext
->extLength
, 1);
416 udf_write_aext(inode
, last_pos
, last_ext
->extLocation
,
417 last_ext
->extLength
, 1);
419 /* Managed to do everything necessary? */
423 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
424 last_ext
->extLocation
.logicalBlockNum
= 0;
425 last_ext
->extLocation
.partitionReferenceNum
= 0;
426 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
427 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
428 (add
<< sb
->s_blocksize_bits
);
430 /* Create enough extents to cover the whole hole */
431 while (blocks
> add
) {
433 if (udf_add_aext(inode
, last_pos
, last_ext
->extLocation
,
434 last_ext
->extLength
, 1) == -1)
439 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
440 (blocks
<< sb
->s_blocksize_bits
);
441 if (udf_add_aext(inode
, last_pos
, last_ext
->extLocation
,
442 last_ext
->extLength
, 1) == -1)
448 /* Do we have some preallocated blocks saved? */
450 if (udf_add_aext(inode
, last_pos
, prealloc_loc
,
451 prealloc_len
, 1) == -1)
453 last_ext
->extLocation
= prealloc_loc
;
454 last_ext
->extLength
= prealloc_len
;
458 /* last_pos should point to the last written extent... */
459 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
460 last_pos
->offset
-= sizeof(short_ad
);
461 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
462 last_pos
->offset
-= sizeof(long_ad
);
469 static struct buffer_head
*inode_getblk(struct inode
*inode
, sector_t block
,
470 int *err
, sector_t
*phys
, int *new)
472 static sector_t last_block
;
473 struct buffer_head
*result
= NULL
;
474 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
475 struct extent_position prev_epos
, cur_epos
, next_epos
;
476 int count
= 0, startnum
= 0, endnum
= 0;
477 uint32_t elen
= 0, tmpelen
;
478 kernel_lb_addr eloc
, tmpeloc
;
480 loff_t lbcount
= 0, b_off
= 0;
481 uint32_t newblocknum
, newblock
;
484 struct udf_inode_info
*iinfo
= UDF_I(inode
);
485 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
488 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
489 prev_epos
.block
= iinfo
->i_location
;
491 cur_epos
= next_epos
= prev_epos
;
492 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
494 /* find the extent which contains the block we are looking for.
495 alternate between laarr[0] and laarr[1] for locations of the
496 current extent, and the previous extent */
498 if (prev_epos
.bh
!= cur_epos
.bh
) {
499 brelse(prev_epos
.bh
);
501 prev_epos
.bh
= cur_epos
.bh
;
503 if (cur_epos
.bh
!= next_epos
.bh
) {
505 get_bh(next_epos
.bh
);
506 cur_epos
.bh
= next_epos
.bh
;
511 prev_epos
.block
= cur_epos
.block
;
512 cur_epos
.block
= next_epos
.block
;
514 prev_epos
.offset
= cur_epos
.offset
;
515 cur_epos
.offset
= next_epos
.offset
;
517 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
523 laarr
[c
].extLength
= (etype
<< 30) | elen
;
524 laarr
[c
].extLocation
= eloc
;
526 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
527 pgoal
= eloc
.logicalBlockNum
+
528 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
529 inode
->i_sb
->s_blocksize_bits
);
532 } while (lbcount
+ elen
<= b_off
);
535 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
537 * Move prev_epos and cur_epos into indirect extent if we are at
540 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
541 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
543 /* if the extent is allocated and recorded, return the block
544 if the extent is not a multiple of the blocksize, round up */
546 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
547 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
548 elen
= EXT_RECORDED_ALLOCATED
|
549 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
550 ~(inode
->i_sb
->s_blocksize
- 1));
551 etype
= udf_write_aext(inode
, &cur_epos
, eloc
, elen
, 1);
553 brelse(prev_epos
.bh
);
555 brelse(next_epos
.bh
);
556 newblock
= udf_get_lb_pblock(inode
->i_sb
, eloc
, offset
);
562 /* Are we beyond EOF? */
571 /* Create a fake extent when there's not one */
572 memset(&laarr
[0].extLocation
, 0x00,
573 sizeof(kernel_lb_addr
));
574 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
575 /* Will udf_extend_file() create real extent from
577 startnum
= (offset
> 0);
579 /* Create extents for the hole between EOF and offset */
580 ret
= udf_extend_file(inode
, &prev_epos
, laarr
, offset
);
582 brelse(prev_epos
.bh
);
584 brelse(next_epos
.bh
);
585 /* We don't really know the error here so we just make
593 /* We are not covered by a preallocated extent? */
594 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
595 EXT_NOT_RECORDED_ALLOCATED
) {
596 /* Is there any real extent? - otherwise we overwrite
600 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
601 inode
->i_sb
->s_blocksize
;
602 memset(&laarr
[c
].extLocation
, 0x00,
603 sizeof(kernel_lb_addr
));
610 endnum
= startnum
= ((count
> 2) ? 2 : count
);
612 /* if the current extent is in position 0,
613 swap it with the previous */
614 if (!c
&& count
!= 1) {
621 /* if the current block is located in an extent,
622 read the next extent */
623 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
625 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
626 laarr
[c
+ 1].extLocation
= eloc
;
634 /* if the current extent is not recorded but allocated, get the
635 * block in the extent corresponding to the requested block */
636 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
637 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
638 else { /* otherwise, allocate a new block */
639 if (iinfo
->i_next_alloc_block
== block
)
640 goal
= iinfo
->i_next_alloc_goal
;
643 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
644 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
647 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
648 iinfo
->i_location
.partitionReferenceNum
,
651 brelse(prev_epos
.bh
);
655 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
658 /* if the extent the requsted block is located in contains multiple
659 * blocks, split the extent into at most three extents. blocks prior
660 * to requested block, requested block, and blocks after requested
662 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
664 #ifdef UDF_PREALLOCATE
665 /* preallocate blocks */
666 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
669 /* merge any continuous blocks in laarr */
670 udf_merge_extents(inode
, laarr
, &endnum
);
672 /* write back the new extents, inserting new extents if the new number
673 * of extents is greater than the old number, and deleting extents if
674 * the new number of extents is less than the old number */
675 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
677 brelse(prev_epos
.bh
);
679 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
680 iinfo
->i_location
.partitionReferenceNum
, 0);
686 iinfo
->i_next_alloc_block
= block
;
687 iinfo
->i_next_alloc_goal
= newblocknum
;
688 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
691 udf_sync_inode(inode
);
693 mark_inode_dirty(inode
);
698 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
700 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
703 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
704 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
706 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
707 (laarr
[*c
].extLength
>> 30) ==
708 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
710 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
711 blocksize
- 1) >> blocksize_bits
;
712 int8_t etype
= (laarr
[curr
].extLength
>> 30);
716 else if (!offset
|| blen
== offset
+ 1) {
717 laarr
[curr
+ 2] = laarr
[curr
+ 1];
718 laarr
[curr
+ 1] = laarr
[curr
];
720 laarr
[curr
+ 3] = laarr
[curr
+ 1];
721 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
725 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
726 udf_free_blocks(inode
->i_sb
, inode
,
727 laarr
[curr
].extLocation
,
729 laarr
[curr
].extLength
=
730 EXT_NOT_RECORDED_NOT_ALLOCATED
|
731 (offset
<< blocksize_bits
);
732 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
733 laarr
[curr
].extLocation
.
734 partitionReferenceNum
= 0;
736 laarr
[curr
].extLength
= (etype
<< 30) |
737 (offset
<< blocksize_bits
);
743 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
744 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
745 laarr
[curr
].extLocation
.partitionReferenceNum
=
746 UDF_I(inode
)->i_location
.partitionReferenceNum
;
747 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
751 if (blen
!= offset
+ 1) {
752 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
753 laarr
[curr
].extLocation
.logicalBlockNum
+=
755 laarr
[curr
].extLength
= (etype
<< 30) |
756 ((blen
- (offset
+ 1)) << blocksize_bits
);
763 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
764 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
767 int start
, length
= 0, currlength
= 0, i
;
769 if (*endnum
>= (c
+ 1)) {
775 if ((laarr
[c
+ 1].extLength
>> 30) ==
776 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
778 length
= currlength
=
779 (((laarr
[c
+ 1].extLength
&
780 UDF_EXTENT_LENGTH_MASK
) +
781 inode
->i_sb
->s_blocksize
- 1) >>
782 inode
->i_sb
->s_blocksize_bits
);
787 for (i
= start
+ 1; i
<= *endnum
; i
++) {
790 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
791 } else if ((laarr
[i
].extLength
>> 30) ==
792 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
793 length
+= (((laarr
[i
].extLength
&
794 UDF_EXTENT_LENGTH_MASK
) +
795 inode
->i_sb
->s_blocksize
- 1) >>
796 inode
->i_sb
->s_blocksize_bits
);
802 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
803 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
804 inode
->i_sb
->s_blocksize
- 1) >>
805 inode
->i_sb
->s_blocksize_bits
);
806 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
807 laarr
[start
].extLocation
.partitionReferenceNum
,
808 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
809 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
812 if (start
== (c
+ 1))
813 laarr
[start
].extLength
+=
815 inode
->i_sb
->s_blocksize_bits
);
817 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
818 sizeof(long_ad
) * (*endnum
- (c
+ 1)));
820 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
821 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
822 laarr
[c
].extLocation
.
823 partitionReferenceNum
;
824 laarr
[c
+ 1].extLength
=
825 EXT_NOT_RECORDED_ALLOCATED
|
827 inode
->i_sb
->s_blocksize_bits
);
831 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
832 int elen
= ((laarr
[i
].extLength
&
833 UDF_EXTENT_LENGTH_MASK
) +
834 inode
->i_sb
->s_blocksize
- 1) >>
835 inode
->i_sb
->s_blocksize_bits
;
837 if (elen
> numalloc
) {
838 laarr
[i
].extLength
-=
840 inode
->i_sb
->s_blocksize_bits
);
844 if (*endnum
> (i
+ 1))
848 (*endnum
- (i
+ 1)));
853 UDF_I(inode
)->i_lenExtents
+=
854 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
859 static void udf_merge_extents(struct inode
*inode
,
860 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
864 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
865 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
867 for (i
= 0; i
< (*endnum
- 1); i
++) {
868 kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
869 kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
871 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
872 (((li
->extLength
>> 30) ==
873 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
874 ((lip1
->extLocation
.logicalBlockNum
-
875 li
->extLocation
.logicalBlockNum
) ==
876 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
877 blocksize
- 1) >> blocksize_bits
)))) {
879 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
880 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
881 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
882 lip1
->extLength
= (lip1
->extLength
-
884 UDF_EXTENT_LENGTH_MASK
) +
885 UDF_EXTENT_LENGTH_MASK
) &
887 li
->extLength
= (li
->extLength
&
888 UDF_EXTENT_FLAG_MASK
) +
889 (UDF_EXTENT_LENGTH_MASK
+ 1) -
891 lip1
->extLocation
.logicalBlockNum
=
892 li
->extLocation
.logicalBlockNum
+
894 UDF_EXTENT_LENGTH_MASK
) >>
897 li
->extLength
= lip1
->extLength
+
899 UDF_EXTENT_LENGTH_MASK
) +
900 blocksize
- 1) & ~(blocksize
- 1));
901 if (*endnum
> (i
+ 2))
902 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
904 (*endnum
- (i
+ 2)));
908 } else if (((li
->extLength
>> 30) ==
909 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
910 ((lip1
->extLength
>> 30) ==
911 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
912 udf_free_blocks(inode
->i_sb
, inode
, li
->extLocation
, 0,
914 UDF_EXTENT_LENGTH_MASK
) +
915 blocksize
- 1) >> blocksize_bits
);
916 li
->extLocation
.logicalBlockNum
= 0;
917 li
->extLocation
.partitionReferenceNum
= 0;
919 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
920 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
921 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
922 lip1
->extLength
= (lip1
->extLength
-
924 UDF_EXTENT_LENGTH_MASK
) +
925 UDF_EXTENT_LENGTH_MASK
) &
927 li
->extLength
= (li
->extLength
&
928 UDF_EXTENT_FLAG_MASK
) +
929 (UDF_EXTENT_LENGTH_MASK
+ 1) -
932 li
->extLength
= lip1
->extLength
+
934 UDF_EXTENT_LENGTH_MASK
) +
935 blocksize
- 1) & ~(blocksize
- 1));
936 if (*endnum
> (i
+ 2))
937 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
939 (*endnum
- (i
+ 2)));
943 } else if ((li
->extLength
>> 30) ==
944 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
945 udf_free_blocks(inode
->i_sb
, inode
,
948 UDF_EXTENT_LENGTH_MASK
) +
949 blocksize
- 1) >> blocksize_bits
);
950 li
->extLocation
.logicalBlockNum
= 0;
951 li
->extLocation
.partitionReferenceNum
= 0;
952 li
->extLength
= (li
->extLength
&
953 UDF_EXTENT_LENGTH_MASK
) |
954 EXT_NOT_RECORDED_NOT_ALLOCATED
;
959 static void udf_update_extents(struct inode
*inode
,
960 kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
961 int startnum
, int endnum
,
962 struct extent_position
*epos
)
965 kernel_lb_addr tmploc
;
968 if (startnum
> endnum
) {
969 for (i
= 0; i
< (startnum
- endnum
); i
++)
970 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
972 } else if (startnum
< endnum
) {
973 for (i
= 0; i
< (endnum
- startnum
); i
++) {
974 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
976 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
977 &laarr
[i
].extLength
, 1);
982 for (i
= start
; i
< endnum
; i
++) {
983 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
984 udf_write_aext(inode
, epos
, laarr
[i
].extLocation
,
985 laarr
[i
].extLength
, 1);
989 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
990 int create
, int *err
)
992 struct buffer_head
*bh
= NULL
;
994 bh
= udf_getblk(inode
, block
, create
, err
);
998 if (buffer_uptodate(bh
))
1001 ll_rw_block(READ
, 1, &bh
);
1004 if (buffer_uptodate(bh
))
1012 void udf_truncate(struct inode
*inode
)
1016 struct udf_inode_info
*iinfo
;
1018 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1019 S_ISLNK(inode
->i_mode
)))
1021 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1025 iinfo
= UDF_I(inode
);
1026 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1027 if (inode
->i_sb
->s_blocksize
<
1028 (udf_file_entry_alloc_offset(inode
) +
1030 udf_expand_file_adinicb(inode
, inode
->i_size
, &err
);
1031 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1032 inode
->i_size
= iinfo
->i_lenAlloc
;
1036 udf_truncate_extents(inode
);
1038 offset
= inode
->i_size
& (inode
->i_sb
->s_blocksize
- 1);
1039 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ offset
,
1040 0x00, inode
->i_sb
->s_blocksize
-
1041 offset
- udf_file_entry_alloc_offset(inode
));
1042 iinfo
->i_lenAlloc
= inode
->i_size
;
1045 block_truncate_page(inode
->i_mapping
, inode
->i_size
,
1047 udf_truncate_extents(inode
);
1050 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1052 udf_sync_inode(inode
);
1054 mark_inode_dirty(inode
);
1058 static void __udf_read_inode(struct inode
*inode
)
1060 struct buffer_head
*bh
= NULL
;
1061 struct fileEntry
*fe
;
1063 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1066 * Set defaults, but the inode is still incomplete!
1067 * Note: get_new_inode() sets the following on a new inode:
1070 * i_flags = sb->s_flags
1072 * clean_inode(): zero fills and sets
1077 bh
= udf_read_ptagged(inode
->i_sb
, iinfo
->i_location
, 0, &ident
);
1079 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) failed !bh\n",
1081 make_bad_inode(inode
);
1085 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1086 ident
!= TAG_IDENT_USE
) {
1087 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) "
1088 "failed ident=%d\n", inode
->i_ino
, ident
);
1090 make_bad_inode(inode
);
1094 fe
= (struct fileEntry
*)bh
->b_data
;
1096 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1097 struct buffer_head
*ibh
;
1099 ibh
= udf_read_ptagged(inode
->i_sb
, iinfo
->i_location
, 1,
1101 if (ident
== TAG_IDENT_IE
&& ibh
) {
1102 struct buffer_head
*nbh
= NULL
;
1104 struct indirectEntry
*ie
;
1106 ie
= (struct indirectEntry
*)ibh
->b_data
;
1107 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1109 if (ie
->indirectICB
.extLength
&&
1110 (nbh
= udf_read_ptagged(inode
->i_sb
, loc
, 0,
1112 if (ident
== TAG_IDENT_FE
||
1113 ident
== TAG_IDENT_EFE
) {
1114 memcpy(&iinfo
->i_location
,
1116 sizeof(kernel_lb_addr
));
1120 __udf_read_inode(inode
);
1127 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1128 printk(KERN_ERR
"udf: unsupported strategy type: %d\n",
1129 le16_to_cpu(fe
->icbTag
.strategyType
));
1131 make_bad_inode(inode
);
1134 udf_fill_inode(inode
, bh
);
1139 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1141 struct fileEntry
*fe
;
1142 struct extendedFileEntry
*efe
;
1144 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1145 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1147 fe
= (struct fileEntry
*)bh
->b_data
;
1148 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1150 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1151 iinfo
->i_strat4096
= 0;
1152 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1153 iinfo
->i_strat4096
= 1;
1155 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1156 ICBTAG_FLAG_AD_MASK
;
1157 iinfo
->i_unique
= 0;
1158 iinfo
->i_lenEAttr
= 0;
1159 iinfo
->i_lenExtents
= 0;
1160 iinfo
->i_lenAlloc
= 0;
1161 iinfo
->i_next_alloc_block
= 0;
1162 iinfo
->i_next_alloc_goal
= 0;
1163 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1166 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1167 sizeof(struct extendedFileEntry
))) {
1168 make_bad_inode(inode
);
1171 memcpy(iinfo
->i_ext
.i_data
,
1172 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1173 inode
->i_sb
->s_blocksize
-
1174 sizeof(struct extendedFileEntry
));
1175 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1178 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1179 sizeof(struct fileEntry
))) {
1180 make_bad_inode(inode
);
1183 memcpy(iinfo
->i_ext
.i_data
,
1184 bh
->b_data
+ sizeof(struct fileEntry
),
1185 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1186 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1189 iinfo
->i_lenAlloc
= le32_to_cpu(
1190 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1192 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1193 sizeof(struct unallocSpaceEntry
))) {
1194 make_bad_inode(inode
);
1197 memcpy(iinfo
->i_ext
.i_data
,
1198 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1199 inode
->i_sb
->s_blocksize
-
1200 sizeof(struct unallocSpaceEntry
));
1204 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1205 if (inode
->i_uid
== -1 ||
1206 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1207 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1208 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1210 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1211 if (inode
->i_gid
== -1 ||
1212 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1213 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1214 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1216 inode
->i_nlink
= le16_to_cpu(fe
->fileLinkCount
);
1217 if (!inode
->i_nlink
)
1220 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1221 iinfo
->i_lenExtents
= inode
->i_size
;
1223 inode
->i_mode
= udf_convert_permissions(fe
);
1224 inode
->i_mode
&= ~UDF_SB(inode
->i_sb
)->s_umask
;
1226 if (iinfo
->i_efe
== 0) {
1227 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1228 (inode
->i_sb
->s_blocksize_bits
- 9);
1230 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1231 inode
->i_atime
= sbi
->s_record_time
;
1233 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1234 fe
->modificationTime
))
1235 inode
->i_mtime
= sbi
->s_record_time
;
1237 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1238 inode
->i_ctime
= sbi
->s_record_time
;
1240 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1241 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1242 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1243 offset
= sizeof(struct fileEntry
) + iinfo
->i_lenEAttr
;
1245 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1246 (inode
->i_sb
->s_blocksize_bits
- 9);
1248 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1249 inode
->i_atime
= sbi
->s_record_time
;
1251 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1252 efe
->modificationTime
))
1253 inode
->i_mtime
= sbi
->s_record_time
;
1255 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1256 iinfo
->i_crtime
= sbi
->s_record_time
;
1258 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1259 inode
->i_ctime
= sbi
->s_record_time
;
1261 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1262 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1263 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1264 offset
= sizeof(struct extendedFileEntry
) +
1268 switch (fe
->icbTag
.fileType
) {
1269 case ICBTAG_FILE_TYPE_DIRECTORY
:
1270 inode
->i_op
= &udf_dir_inode_operations
;
1271 inode
->i_fop
= &udf_dir_operations
;
1272 inode
->i_mode
|= S_IFDIR
;
1275 case ICBTAG_FILE_TYPE_REALTIME
:
1276 case ICBTAG_FILE_TYPE_REGULAR
:
1277 case ICBTAG_FILE_TYPE_UNDEF
:
1278 case ICBTAG_FILE_TYPE_VAT20
:
1279 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1280 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1282 inode
->i_data
.a_ops
= &udf_aops
;
1283 inode
->i_op
= &udf_file_inode_operations
;
1284 inode
->i_fop
= &udf_file_operations
;
1285 inode
->i_mode
|= S_IFREG
;
1287 case ICBTAG_FILE_TYPE_BLOCK
:
1288 inode
->i_mode
|= S_IFBLK
;
1290 case ICBTAG_FILE_TYPE_CHAR
:
1291 inode
->i_mode
|= S_IFCHR
;
1293 case ICBTAG_FILE_TYPE_FIFO
:
1294 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1296 case ICBTAG_FILE_TYPE_SOCKET
:
1297 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1299 case ICBTAG_FILE_TYPE_SYMLINK
:
1300 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1301 inode
->i_op
= &page_symlink_inode_operations
;
1302 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1304 case ICBTAG_FILE_TYPE_MAIN
:
1305 udf_debug("METADATA FILE-----\n");
1307 case ICBTAG_FILE_TYPE_MIRROR
:
1308 udf_debug("METADATA MIRROR FILE-----\n");
1310 case ICBTAG_FILE_TYPE_BITMAP
:
1311 udf_debug("METADATA BITMAP FILE-----\n");
1314 printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown "
1315 "file type=%d\n", inode
->i_ino
,
1316 fe
->icbTag
.fileType
);
1317 make_bad_inode(inode
);
1320 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1321 struct deviceSpec
*dsea
=
1322 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1324 init_special_inode(inode
, inode
->i_mode
,
1325 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1326 le32_to_cpu(dsea
->minorDeviceIdent
)));
1327 /* Developer ID ??? */
1329 make_bad_inode(inode
);
1333 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1335 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1336 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1338 if (!iinfo
->i_ext
.i_data
) {
1339 printk(KERN_ERR
"udf:udf_alloc_i_data (ino %ld) "
1340 "no free memory\n", inode
->i_ino
);
1347 static mode_t
udf_convert_permissions(struct fileEntry
*fe
)
1350 uint32_t permissions
;
1353 permissions
= le32_to_cpu(fe
->permissions
);
1354 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1356 mode
= ((permissions
) & S_IRWXO
) |
1357 ((permissions
>> 2) & S_IRWXG
) |
1358 ((permissions
>> 4) & S_IRWXU
) |
1359 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1360 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1361 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1366 int udf_write_inode(struct inode
*inode
, int sync
)
1371 ret
= udf_update_inode(inode
, sync
);
1377 int udf_sync_inode(struct inode
*inode
)
1379 return udf_update_inode(inode
, 1);
1382 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1384 struct buffer_head
*bh
= NULL
;
1385 struct fileEntry
*fe
;
1386 struct extendedFileEntry
*efe
;
1391 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1392 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1393 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1395 bh
= udf_tread(inode
->i_sb
,
1396 udf_get_lb_pblock(inode
->i_sb
,
1397 iinfo
->i_location
, 0));
1399 udf_debug("bread failure\n");
1403 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1405 fe
= (struct fileEntry
*)bh
->b_data
;
1406 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1408 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1409 struct unallocSpaceEntry
*use
=
1410 (struct unallocSpaceEntry
*)bh
->b_data
;
1412 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1413 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1414 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1415 sizeof(struct unallocSpaceEntry
));
1416 crclen
= sizeof(struct unallocSpaceEntry
) +
1417 iinfo
->i_lenAlloc
- sizeof(tag
);
1418 use
->descTag
.tagLocation
= cpu_to_le32(
1421 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1422 use
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)use
+
1423 sizeof(tag
), crclen
,
1425 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1427 mark_buffer_dirty(bh
);
1432 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1433 fe
->uid
= cpu_to_le32(-1);
1435 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1437 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1438 fe
->gid
= cpu_to_le32(-1);
1440 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1442 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1443 ((inode
->i_mode
& S_IRWXG
) << 2) |
1444 ((inode
->i_mode
& S_IRWXU
) << 4);
1446 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1447 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1448 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1449 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1450 fe
->permissions
= cpu_to_le32(udfperms
);
1452 if (S_ISDIR(inode
->i_mode
))
1453 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1455 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1457 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1459 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1461 struct deviceSpec
*dsea
=
1462 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1464 dsea
= (struct deviceSpec
*)
1465 udf_add_extendedattr(inode
,
1466 sizeof(struct deviceSpec
) +
1467 sizeof(regid
), 12, 0x3);
1468 dsea
->attrType
= cpu_to_le32(12);
1469 dsea
->attrSubtype
= 1;
1470 dsea
->attrLength
= cpu_to_le32(
1471 sizeof(struct deviceSpec
) +
1473 dsea
->impUseLength
= cpu_to_le32(sizeof(regid
));
1475 eid
= (regid
*)dsea
->impUse
;
1476 memset(eid
, 0, sizeof(regid
));
1477 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1478 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1479 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1480 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1481 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1484 if (iinfo
->i_efe
== 0) {
1485 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1486 iinfo
->i_ext
.i_data
,
1487 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1488 fe
->logicalBlocksRecorded
= cpu_to_le64(
1489 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1490 (blocksize_bits
- 9));
1492 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1493 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1494 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1495 memset(&(fe
->impIdent
), 0, sizeof(regid
));
1496 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1497 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1498 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1499 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1500 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1501 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1502 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1503 crclen
= sizeof(struct fileEntry
);
1505 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1506 iinfo
->i_ext
.i_data
,
1507 inode
->i_sb
->s_blocksize
-
1508 sizeof(struct extendedFileEntry
));
1509 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1510 efe
->logicalBlocksRecorded
= cpu_to_le64(
1511 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1512 (blocksize_bits
- 9));
1514 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1515 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1516 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1517 iinfo
->i_crtime
= inode
->i_atime
;
1519 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1520 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1521 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1522 iinfo
->i_crtime
= inode
->i_mtime
;
1524 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1525 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1526 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1527 iinfo
->i_crtime
= inode
->i_ctime
;
1529 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1530 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1531 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1532 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1534 memset(&(efe
->impIdent
), 0, sizeof(regid
));
1535 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1536 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1537 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1538 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1539 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1540 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1541 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1542 crclen
= sizeof(struct extendedFileEntry
);
1544 if (iinfo
->i_strat4096
) {
1545 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1546 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1547 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1549 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1550 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1553 if (S_ISDIR(inode
->i_mode
))
1554 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1555 else if (S_ISREG(inode
->i_mode
))
1556 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1557 else if (S_ISLNK(inode
->i_mode
))
1558 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1559 else if (S_ISBLK(inode
->i_mode
))
1560 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1561 else if (S_ISCHR(inode
->i_mode
))
1562 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1563 else if (S_ISFIFO(inode
->i_mode
))
1564 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1565 else if (S_ISSOCK(inode
->i_mode
))
1566 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1568 icbflags
= iinfo
->i_alloc_type
|
1569 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1570 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1571 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1572 (le16_to_cpu(fe
->icbTag
.flags
) &
1573 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1574 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1576 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1577 if (sbi
->s_udfrev
>= 0x0200)
1578 fe
->descTag
.descVersion
= cpu_to_le16(3);
1580 fe
->descTag
.descVersion
= cpu_to_le16(2);
1581 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1582 fe
->descTag
.tagLocation
= cpu_to_le32(
1583 iinfo
->i_location
.logicalBlockNum
);
1584 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
-
1586 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1587 fe
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)fe
+ sizeof(tag
),
1589 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1591 /* write the data blocks */
1592 mark_buffer_dirty(bh
);
1594 sync_dirty_buffer(bh
);
1595 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
1596 printk(KERN_WARNING
"IO error syncing udf inode "
1597 "[%s:%08lx]\n", inode
->i_sb
->s_id
,
1607 struct inode
*udf_iget(struct super_block
*sb
, kernel_lb_addr ino
)
1609 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1610 struct inode
*inode
= iget_locked(sb
, block
);
1615 if (inode
->i_state
& I_NEW
) {
1616 memcpy(&UDF_I(inode
)->i_location
, &ino
, sizeof(kernel_lb_addr
));
1617 __udf_read_inode(inode
);
1618 unlock_new_inode(inode
);
1621 if (is_bad_inode(inode
))
1624 if (ino
.logicalBlockNum
>= UDF_SB(sb
)->
1625 s_partmaps
[ino
.partitionReferenceNum
].s_partition_len
) {
1626 udf_debug("block=%d, partition=%d out of range\n",
1627 ino
.logicalBlockNum
, ino
.partitionReferenceNum
);
1628 make_bad_inode(inode
);
1639 int8_t udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1640 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1643 short_ad
*sad
= NULL
;
1644 long_ad
*lad
= NULL
;
1645 struct allocExtDesc
*aed
;
1648 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1651 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1652 udf_file_entry_alloc_offset(inode
) +
1655 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1657 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1658 adsize
= sizeof(short_ad
);
1659 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1660 adsize
= sizeof(long_ad
);
1664 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1666 struct buffer_head
*nbh
;
1668 kernel_lb_addr obloc
= epos
->block
;
1670 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1671 obloc
.partitionReferenceNum
,
1672 obloc
.logicalBlockNum
, &err
);
1673 if (!epos
->block
.logicalBlockNum
)
1675 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1681 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1682 set_buffer_uptodate(nbh
);
1684 mark_buffer_dirty_inode(nbh
, inode
);
1686 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1687 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1688 aed
->previousAllocExtLocation
=
1689 cpu_to_le32(obloc
.logicalBlockNum
);
1690 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1691 loffset
= epos
->offset
;
1692 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1693 sptr
= ptr
- adsize
;
1694 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1695 memcpy(dptr
, sptr
, adsize
);
1696 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1698 loffset
= epos
->offset
+ adsize
;
1699 aed
->lengthAllocDescs
= cpu_to_le32(0);
1701 epos
->offset
= sizeof(struct allocExtDesc
);
1704 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1705 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1707 iinfo
->i_lenAlloc
+= adsize
;
1708 mark_inode_dirty(inode
);
1711 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1712 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1713 epos
->block
.logicalBlockNum
, sizeof(tag
));
1715 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1716 epos
->block
.logicalBlockNum
, sizeof(tag
));
1717 switch (iinfo
->i_alloc_type
) {
1718 case ICBTAG_FLAG_AD_SHORT
:
1719 sad
= (short_ad
*)sptr
;
1720 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1721 inode
->i_sb
->s_blocksize
);
1723 cpu_to_le32(epos
->block
.logicalBlockNum
);
1725 case ICBTAG_FLAG_AD_LONG
:
1726 lad
= (long_ad
*)sptr
;
1727 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1728 inode
->i_sb
->s_blocksize
);
1729 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1730 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1734 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1735 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1736 udf_update_tag(epos
->bh
->b_data
, loffset
);
1738 udf_update_tag(epos
->bh
->b_data
,
1739 sizeof(struct allocExtDesc
));
1740 mark_buffer_dirty_inode(epos
->bh
, inode
);
1743 mark_inode_dirty(inode
);
1748 etype
= udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1751 iinfo
->i_lenAlloc
+= adsize
;
1752 mark_inode_dirty(inode
);
1754 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1755 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1756 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1757 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1758 udf_update_tag(epos
->bh
->b_data
,
1759 epos
->offset
+ (inc
? 0 : adsize
));
1761 udf_update_tag(epos
->bh
->b_data
,
1762 sizeof(struct allocExtDesc
));
1763 mark_buffer_dirty_inode(epos
->bh
, inode
);
1769 int8_t udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1770 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1776 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1779 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1780 udf_file_entry_alloc_offset(inode
) +
1783 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1785 switch (iinfo
->i_alloc_type
) {
1786 case ICBTAG_FLAG_AD_SHORT
:
1787 sad
= (short_ad
*)ptr
;
1788 sad
->extLength
= cpu_to_le32(elen
);
1789 sad
->extPosition
= cpu_to_le32(eloc
.logicalBlockNum
);
1790 adsize
= sizeof(short_ad
);
1792 case ICBTAG_FLAG_AD_LONG
:
1793 lad
= (long_ad
*)ptr
;
1794 lad
->extLength
= cpu_to_le32(elen
);
1795 lad
->extLocation
= cpu_to_lelb(eloc
);
1796 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1797 adsize
= sizeof(long_ad
);
1804 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1805 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1806 struct allocExtDesc
*aed
=
1807 (struct allocExtDesc
*)epos
->bh
->b_data
;
1808 udf_update_tag(epos
->bh
->b_data
,
1809 le32_to_cpu(aed
->lengthAllocDescs
) +
1810 sizeof(struct allocExtDesc
));
1812 mark_buffer_dirty_inode(epos
->bh
, inode
);
1814 mark_inode_dirty(inode
);
1818 epos
->offset
+= adsize
;
1820 return (elen
>> 30);
1823 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1824 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1828 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1829 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1831 epos
->block
= *eloc
;
1832 epos
->offset
= sizeof(struct allocExtDesc
);
1834 block
= udf_get_lb_pblock(inode
->i_sb
, epos
->block
, 0);
1835 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1837 udf_debug("reading block %d failed!\n", block
);
1845 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1846 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1853 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1857 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1858 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1859 udf_file_entry_alloc_offset(inode
) +
1861 alen
= udf_file_entry_alloc_offset(inode
) +
1865 epos
->offset
= sizeof(struct allocExtDesc
);
1866 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1867 alen
= sizeof(struct allocExtDesc
) +
1868 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1872 switch (iinfo
->i_alloc_type
) {
1873 case ICBTAG_FLAG_AD_SHORT
:
1874 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1877 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1878 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1879 eloc
->partitionReferenceNum
=
1880 iinfo
->i_location
.partitionReferenceNum
;
1881 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1883 case ICBTAG_FLAG_AD_LONG
:
1884 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
1887 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1888 *eloc
= lelb_to_cpu(lad
->extLocation
);
1889 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1892 udf_debug("alloc_type = %d unsupported\n",
1893 iinfo
->i_alloc_type
);
1900 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
1901 kernel_lb_addr neloc
, uint32_t nelen
)
1903 kernel_lb_addr oeloc
;
1910 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
1911 udf_write_aext(inode
, &epos
, neloc
, nelen
, 1);
1913 nelen
= (etype
<< 30) | oelen
;
1915 udf_add_aext(inode
, &epos
, neloc
, nelen
, 1);
1918 return (nelen
>> 30);
1921 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
1922 kernel_lb_addr eloc
, uint32_t elen
)
1924 struct extent_position oepos
;
1927 struct allocExtDesc
*aed
;
1928 struct udf_inode_info
*iinfo
;
1935 iinfo
= UDF_I(inode
);
1936 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1937 adsize
= sizeof(short_ad
);
1938 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1939 adsize
= sizeof(long_ad
);
1944 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
1947 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
1948 udf_write_aext(inode
, &oepos
, eloc
, (etype
<< 30) | elen
, 1);
1949 if (oepos
.bh
!= epos
.bh
) {
1950 oepos
.block
= epos
.block
;
1954 oepos
.offset
= epos
.offset
- adsize
;
1957 memset(&eloc
, 0x00, sizeof(kernel_lb_addr
));
1960 if (epos
.bh
!= oepos
.bh
) {
1961 udf_free_blocks(inode
->i_sb
, inode
, epos
.block
, 0, 1);
1962 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1963 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1965 iinfo
->i_lenAlloc
-= (adsize
* 2);
1966 mark_inode_dirty(inode
);
1968 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1969 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
1970 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1971 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1972 udf_update_tag(oepos
.bh
->b_data
,
1973 oepos
.offset
- (2 * adsize
));
1975 udf_update_tag(oepos
.bh
->b_data
,
1976 sizeof(struct allocExtDesc
));
1977 mark_buffer_dirty_inode(oepos
.bh
, inode
);
1980 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1982 iinfo
->i_lenAlloc
-= adsize
;
1983 mark_inode_dirty(inode
);
1985 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
1986 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
1987 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1988 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1989 udf_update_tag(oepos
.bh
->b_data
,
1990 epos
.offset
- adsize
);
1992 udf_update_tag(oepos
.bh
->b_data
,
1993 sizeof(struct allocExtDesc
));
1994 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2001 return (elen
>> 30);
2004 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2005 struct extent_position
*pos
, kernel_lb_addr
*eloc
,
2006 uint32_t *elen
, sector_t
*offset
)
2008 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2009 loff_t lbcount
= 0, bcount
=
2010 (loff_t
) block
<< blocksize_bits
;
2012 struct udf_inode_info
*iinfo
;
2014 iinfo
= UDF_I(inode
);
2016 pos
->block
= iinfo
->i_location
;
2021 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2023 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2024 iinfo
->i_lenExtents
= lbcount
;
2028 } while (lbcount
<= bcount
);
2030 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2035 long udf_block_map(struct inode
*inode
, sector_t block
)
2037 kernel_lb_addr eloc
;
2040 struct extent_position epos
= {};
2045 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2046 (EXT_RECORDED_ALLOCATED
>> 30))
2047 ret
= udf_get_lb_pblock(inode
->i_sb
, eloc
, offset
);
2054 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2055 return udf_fixed_to_variable(ret
);