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
;
1146 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1147 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1149 fe
= (struct fileEntry
*)bh
->b_data
;
1150 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1152 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1153 iinfo
->i_strat4096
= 0;
1154 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1155 iinfo
->i_strat4096
= 1;
1157 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1158 ICBTAG_FLAG_AD_MASK
;
1159 iinfo
->i_unique
= 0;
1160 iinfo
->i_lenEAttr
= 0;
1161 iinfo
->i_lenExtents
= 0;
1162 iinfo
->i_lenAlloc
= 0;
1163 iinfo
->i_next_alloc_block
= 0;
1164 iinfo
->i_next_alloc_goal
= 0;
1165 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1168 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1169 sizeof(struct extendedFileEntry
))) {
1170 make_bad_inode(inode
);
1173 memcpy(iinfo
->i_ext
.i_data
,
1174 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1175 inode
->i_sb
->s_blocksize
-
1176 sizeof(struct extendedFileEntry
));
1177 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1180 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1181 sizeof(struct fileEntry
))) {
1182 make_bad_inode(inode
);
1185 memcpy(iinfo
->i_ext
.i_data
,
1186 bh
->b_data
+ sizeof(struct fileEntry
),
1187 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1188 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1191 iinfo
->i_lenAlloc
= le32_to_cpu(
1192 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1194 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1195 sizeof(struct unallocSpaceEntry
))) {
1196 make_bad_inode(inode
);
1199 memcpy(iinfo
->i_ext
.i_data
,
1200 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1201 inode
->i_sb
->s_blocksize
-
1202 sizeof(struct unallocSpaceEntry
));
1206 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1207 if (inode
->i_uid
== -1 ||
1208 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1209 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1210 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1212 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1213 if (inode
->i_gid
== -1 ||
1214 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1215 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1216 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1218 inode
->i_nlink
= le16_to_cpu(fe
->fileLinkCount
);
1219 if (!inode
->i_nlink
)
1222 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1223 iinfo
->i_lenExtents
= inode
->i_size
;
1225 inode
->i_mode
= udf_convert_permissions(fe
);
1226 inode
->i_mode
&= ~UDF_SB(inode
->i_sb
)->s_umask
;
1228 if (iinfo
->i_efe
== 0) {
1229 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1230 (inode
->i_sb
->s_blocksize_bits
- 9);
1232 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1233 lets_to_cpu(fe
->accessTime
))) {
1234 inode
->i_atime
.tv_sec
= convtime
;
1235 inode
->i_atime
.tv_nsec
= convtime_usec
* 1000;
1237 inode
->i_atime
= sbi
->s_record_time
;
1240 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1241 lets_to_cpu(fe
->modificationTime
))) {
1242 inode
->i_mtime
.tv_sec
= convtime
;
1243 inode
->i_mtime
.tv_nsec
= convtime_usec
* 1000;
1245 inode
->i_mtime
= sbi
->s_record_time
;
1248 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1249 lets_to_cpu(fe
->attrTime
))) {
1250 inode
->i_ctime
.tv_sec
= convtime
;
1251 inode
->i_ctime
.tv_nsec
= convtime_usec
* 1000;
1253 inode
->i_ctime
= sbi
->s_record_time
;
1256 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1257 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1258 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1259 offset
= sizeof(struct fileEntry
) + iinfo
->i_lenEAttr
;
1261 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1262 (inode
->i_sb
->s_blocksize_bits
- 9);
1264 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1265 lets_to_cpu(efe
->accessTime
))) {
1266 inode
->i_atime
.tv_sec
= convtime
;
1267 inode
->i_atime
.tv_nsec
= convtime_usec
* 1000;
1269 inode
->i_atime
= sbi
->s_record_time
;
1272 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1273 lets_to_cpu(efe
->modificationTime
))) {
1274 inode
->i_mtime
.tv_sec
= convtime
;
1275 inode
->i_mtime
.tv_nsec
= convtime_usec
* 1000;
1277 inode
->i_mtime
= sbi
->s_record_time
;
1280 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1281 lets_to_cpu(efe
->createTime
))) {
1282 iinfo
->i_crtime
.tv_sec
= convtime
;
1283 iinfo
->i_crtime
.tv_nsec
= convtime_usec
* 1000;
1285 iinfo
->i_crtime
= sbi
->s_record_time
;
1288 if (udf_stamp_to_time(&convtime
, &convtime_usec
,
1289 lets_to_cpu(efe
->attrTime
))) {
1290 inode
->i_ctime
.tv_sec
= convtime
;
1291 inode
->i_ctime
.tv_nsec
= convtime_usec
* 1000;
1293 inode
->i_ctime
= sbi
->s_record_time
;
1296 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1297 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1298 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1299 offset
= sizeof(struct extendedFileEntry
) +
1303 switch (fe
->icbTag
.fileType
) {
1304 case ICBTAG_FILE_TYPE_DIRECTORY
:
1305 inode
->i_op
= &udf_dir_inode_operations
;
1306 inode
->i_fop
= &udf_dir_operations
;
1307 inode
->i_mode
|= S_IFDIR
;
1310 case ICBTAG_FILE_TYPE_REALTIME
:
1311 case ICBTAG_FILE_TYPE_REGULAR
:
1312 case ICBTAG_FILE_TYPE_UNDEF
:
1313 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1314 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1316 inode
->i_data
.a_ops
= &udf_aops
;
1317 inode
->i_op
= &udf_file_inode_operations
;
1318 inode
->i_fop
= &udf_file_operations
;
1319 inode
->i_mode
|= S_IFREG
;
1321 case ICBTAG_FILE_TYPE_BLOCK
:
1322 inode
->i_mode
|= S_IFBLK
;
1324 case ICBTAG_FILE_TYPE_CHAR
:
1325 inode
->i_mode
|= S_IFCHR
;
1327 case ICBTAG_FILE_TYPE_FIFO
:
1328 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1330 case ICBTAG_FILE_TYPE_SOCKET
:
1331 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1333 case ICBTAG_FILE_TYPE_SYMLINK
:
1334 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1335 inode
->i_op
= &page_symlink_inode_operations
;
1336 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1339 printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown "
1340 "file type=%d\n", inode
->i_ino
,
1341 fe
->icbTag
.fileType
);
1342 make_bad_inode(inode
);
1345 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1346 struct deviceSpec
*dsea
=
1347 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1349 init_special_inode(inode
, inode
->i_mode
,
1350 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1351 le32_to_cpu(dsea
->minorDeviceIdent
)));
1352 /* Developer ID ??? */
1354 make_bad_inode(inode
);
1358 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1360 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1361 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1363 if (!iinfo
->i_ext
.i_data
) {
1364 printk(KERN_ERR
"udf:udf_alloc_i_data (ino %ld) "
1365 "no free memory\n", inode
->i_ino
);
1372 static mode_t
udf_convert_permissions(struct fileEntry
*fe
)
1375 uint32_t permissions
;
1378 permissions
= le32_to_cpu(fe
->permissions
);
1379 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1381 mode
= ((permissions
) & S_IRWXO
) |
1382 ((permissions
>> 2) & S_IRWXG
) |
1383 ((permissions
>> 4) & S_IRWXU
) |
1384 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1385 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1386 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1391 int udf_write_inode(struct inode
*inode
, int sync
)
1396 ret
= udf_update_inode(inode
, sync
);
1402 int udf_sync_inode(struct inode
*inode
)
1404 return udf_update_inode(inode
, 1);
1407 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1409 struct buffer_head
*bh
= NULL
;
1410 struct fileEntry
*fe
;
1411 struct extendedFileEntry
*efe
;
1415 kernel_timestamp cpu_time
;
1417 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1418 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1419 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1421 bh
= udf_tread(inode
->i_sb
,
1422 udf_get_lb_pblock(inode
->i_sb
,
1423 iinfo
->i_location
, 0));
1425 udf_debug("bread failure\n");
1429 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1431 fe
= (struct fileEntry
*)bh
->b_data
;
1432 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1434 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1435 struct unallocSpaceEntry
*use
=
1436 (struct unallocSpaceEntry
*)bh
->b_data
;
1438 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1439 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1440 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1441 sizeof(struct unallocSpaceEntry
));
1442 crclen
= sizeof(struct unallocSpaceEntry
) +
1443 iinfo
->i_lenAlloc
- sizeof(tag
);
1444 use
->descTag
.tagLocation
= cpu_to_le32(
1447 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1448 use
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)use
+
1449 sizeof(tag
), crclen
,
1451 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1453 mark_buffer_dirty(bh
);
1458 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1459 fe
->uid
= cpu_to_le32(-1);
1461 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1463 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1464 fe
->gid
= cpu_to_le32(-1);
1466 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1468 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1469 ((inode
->i_mode
& S_IRWXG
) << 2) |
1470 ((inode
->i_mode
& S_IRWXU
) << 4);
1472 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1473 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1474 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1475 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1476 fe
->permissions
= cpu_to_le32(udfperms
);
1478 if (S_ISDIR(inode
->i_mode
))
1479 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1481 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1483 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1485 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1487 struct deviceSpec
*dsea
=
1488 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1490 dsea
= (struct deviceSpec
*)
1491 udf_add_extendedattr(inode
,
1492 sizeof(struct deviceSpec
) +
1493 sizeof(regid
), 12, 0x3);
1494 dsea
->attrType
= cpu_to_le32(12);
1495 dsea
->attrSubtype
= 1;
1496 dsea
->attrLength
= cpu_to_le32(
1497 sizeof(struct deviceSpec
) +
1499 dsea
->impUseLength
= cpu_to_le32(sizeof(regid
));
1501 eid
= (regid
*)dsea
->impUse
;
1502 memset(eid
, 0, sizeof(regid
));
1503 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1504 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1505 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1506 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1507 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1510 if (iinfo
->i_efe
== 0) {
1511 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1512 iinfo
->i_ext
.i_data
,
1513 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1514 fe
->logicalBlocksRecorded
= cpu_to_le64(
1515 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1516 (blocksize_bits
- 9));
1518 if (udf_time_to_stamp(&cpu_time
, inode
->i_atime
))
1519 fe
->accessTime
= cpu_to_lets(cpu_time
);
1520 if (udf_time_to_stamp(&cpu_time
, inode
->i_mtime
))
1521 fe
->modificationTime
= cpu_to_lets(cpu_time
);
1522 if (udf_time_to_stamp(&cpu_time
, inode
->i_ctime
))
1523 fe
->attrTime
= cpu_to_lets(cpu_time
);
1524 memset(&(fe
->impIdent
), 0, sizeof(regid
));
1525 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1526 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1527 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1528 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1529 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1530 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1531 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1532 crclen
= sizeof(struct fileEntry
);
1534 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1535 iinfo
->i_ext
.i_data
,
1536 inode
->i_sb
->s_blocksize
-
1537 sizeof(struct extendedFileEntry
));
1538 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1539 efe
->logicalBlocksRecorded
= cpu_to_le64(
1540 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1541 (blocksize_bits
- 9));
1543 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1544 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1545 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1546 iinfo
->i_crtime
= inode
->i_atime
;
1548 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1549 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1550 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1551 iinfo
->i_crtime
= inode
->i_mtime
;
1553 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1554 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1555 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1556 iinfo
->i_crtime
= inode
->i_ctime
;
1558 if (udf_time_to_stamp(&cpu_time
, inode
->i_atime
))
1559 efe
->accessTime
= cpu_to_lets(cpu_time
);
1560 if (udf_time_to_stamp(&cpu_time
, inode
->i_mtime
))
1561 efe
->modificationTime
= cpu_to_lets(cpu_time
);
1562 if (udf_time_to_stamp(&cpu_time
, iinfo
->i_crtime
))
1563 efe
->createTime
= cpu_to_lets(cpu_time
);
1564 if (udf_time_to_stamp(&cpu_time
, inode
->i_ctime
))
1565 efe
->attrTime
= cpu_to_lets(cpu_time
);
1567 memset(&(efe
->impIdent
), 0, sizeof(regid
));
1568 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1569 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1570 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1571 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1572 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1573 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1574 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1575 crclen
= sizeof(struct extendedFileEntry
);
1577 if (iinfo
->i_strat4096
) {
1578 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1579 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1580 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1582 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1583 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1586 if (S_ISDIR(inode
->i_mode
))
1587 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1588 else if (S_ISREG(inode
->i_mode
))
1589 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1590 else if (S_ISLNK(inode
->i_mode
))
1591 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1592 else if (S_ISBLK(inode
->i_mode
))
1593 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1594 else if (S_ISCHR(inode
->i_mode
))
1595 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1596 else if (S_ISFIFO(inode
->i_mode
))
1597 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1598 else if (S_ISSOCK(inode
->i_mode
))
1599 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1601 icbflags
= iinfo
->i_alloc_type
|
1602 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1603 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1604 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1605 (le16_to_cpu(fe
->icbTag
.flags
) &
1606 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1607 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1609 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1610 if (sbi
->s_udfrev
>= 0x0200)
1611 fe
->descTag
.descVersion
= cpu_to_le16(3);
1613 fe
->descTag
.descVersion
= cpu_to_le16(2);
1614 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1615 fe
->descTag
.tagLocation
= cpu_to_le32(
1616 iinfo
->i_location
.logicalBlockNum
);
1617 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
-
1619 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1620 fe
->descTag
.descCRC
= cpu_to_le16(udf_crc((char *)fe
+ sizeof(tag
),
1622 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1624 /* write the data blocks */
1625 mark_buffer_dirty(bh
);
1627 sync_dirty_buffer(bh
);
1628 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
1629 printk(KERN_WARNING
"IO error syncing udf inode "
1630 "[%s:%08lx]\n", inode
->i_sb
->s_id
,
1640 struct inode
*udf_iget(struct super_block
*sb
, kernel_lb_addr ino
)
1642 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1643 struct inode
*inode
= iget_locked(sb
, block
);
1648 if (inode
->i_state
& I_NEW
) {
1649 memcpy(&UDF_I(inode
)->i_location
, &ino
, sizeof(kernel_lb_addr
));
1650 __udf_read_inode(inode
);
1651 unlock_new_inode(inode
);
1654 if (is_bad_inode(inode
))
1657 if (ino
.logicalBlockNum
>= UDF_SB(sb
)->
1658 s_partmaps
[ino
.partitionReferenceNum
].s_partition_len
) {
1659 udf_debug("block=%d, partition=%d out of range\n",
1660 ino
.logicalBlockNum
, ino
.partitionReferenceNum
);
1661 make_bad_inode(inode
);
1672 int8_t udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1673 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1676 short_ad
*sad
= NULL
;
1677 long_ad
*lad
= NULL
;
1678 struct allocExtDesc
*aed
;
1681 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1684 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1685 udf_file_entry_alloc_offset(inode
) +
1688 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1690 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1691 adsize
= sizeof(short_ad
);
1692 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1693 adsize
= sizeof(long_ad
);
1697 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1699 struct buffer_head
*nbh
;
1701 kernel_lb_addr obloc
= epos
->block
;
1703 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1704 obloc
.partitionReferenceNum
,
1705 obloc
.logicalBlockNum
, &err
);
1706 if (!epos
->block
.logicalBlockNum
)
1708 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1714 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1715 set_buffer_uptodate(nbh
);
1717 mark_buffer_dirty_inode(nbh
, inode
);
1719 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1720 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1721 aed
->previousAllocExtLocation
=
1722 cpu_to_le32(obloc
.logicalBlockNum
);
1723 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1724 loffset
= epos
->offset
;
1725 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1726 sptr
= ptr
- adsize
;
1727 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1728 memcpy(dptr
, sptr
, adsize
);
1729 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1731 loffset
= epos
->offset
+ adsize
;
1732 aed
->lengthAllocDescs
= cpu_to_le32(0);
1734 epos
->offset
= sizeof(struct allocExtDesc
);
1737 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1738 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1740 iinfo
->i_lenAlloc
+= adsize
;
1741 mark_inode_dirty(inode
);
1744 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1745 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1746 epos
->block
.logicalBlockNum
, sizeof(tag
));
1748 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1749 epos
->block
.logicalBlockNum
, sizeof(tag
));
1750 switch (iinfo
->i_alloc_type
) {
1751 case ICBTAG_FLAG_AD_SHORT
:
1752 sad
= (short_ad
*)sptr
;
1753 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1754 inode
->i_sb
->s_blocksize
);
1756 cpu_to_le32(epos
->block
.logicalBlockNum
);
1758 case ICBTAG_FLAG_AD_LONG
:
1759 lad
= (long_ad
*)sptr
;
1760 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1761 inode
->i_sb
->s_blocksize
);
1762 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1763 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1767 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1768 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1769 udf_update_tag(epos
->bh
->b_data
, loffset
);
1771 udf_update_tag(epos
->bh
->b_data
,
1772 sizeof(struct allocExtDesc
));
1773 mark_buffer_dirty_inode(epos
->bh
, inode
);
1776 mark_inode_dirty(inode
);
1781 etype
= udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1784 iinfo
->i_lenAlloc
+= adsize
;
1785 mark_inode_dirty(inode
);
1787 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1788 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1789 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1790 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1791 udf_update_tag(epos
->bh
->b_data
,
1792 epos
->offset
+ (inc
? 0 : adsize
));
1794 udf_update_tag(epos
->bh
->b_data
,
1795 sizeof(struct allocExtDesc
));
1796 mark_buffer_dirty_inode(epos
->bh
, inode
);
1802 int8_t udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1803 kernel_lb_addr eloc
, uint32_t elen
, int inc
)
1809 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1812 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1813 udf_file_entry_alloc_offset(inode
) +
1816 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1818 switch (iinfo
->i_alloc_type
) {
1819 case ICBTAG_FLAG_AD_SHORT
:
1820 sad
= (short_ad
*)ptr
;
1821 sad
->extLength
= cpu_to_le32(elen
);
1822 sad
->extPosition
= cpu_to_le32(eloc
.logicalBlockNum
);
1823 adsize
= sizeof(short_ad
);
1825 case ICBTAG_FLAG_AD_LONG
:
1826 lad
= (long_ad
*)ptr
;
1827 lad
->extLength
= cpu_to_le32(elen
);
1828 lad
->extLocation
= cpu_to_lelb(eloc
);
1829 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1830 adsize
= sizeof(long_ad
);
1837 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1838 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1839 struct allocExtDesc
*aed
=
1840 (struct allocExtDesc
*)epos
->bh
->b_data
;
1841 udf_update_tag(epos
->bh
->b_data
,
1842 le32_to_cpu(aed
->lengthAllocDescs
) +
1843 sizeof(struct allocExtDesc
));
1845 mark_buffer_dirty_inode(epos
->bh
, inode
);
1847 mark_inode_dirty(inode
);
1851 epos
->offset
+= adsize
;
1853 return (elen
>> 30);
1856 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1857 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1861 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1862 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1864 epos
->block
= *eloc
;
1865 epos
->offset
= sizeof(struct allocExtDesc
);
1867 block
= udf_get_lb_pblock(inode
->i_sb
, epos
->block
, 0);
1868 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1870 udf_debug("reading block %d failed!\n", block
);
1878 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1879 kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1886 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1890 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1891 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1892 udf_file_entry_alloc_offset(inode
) +
1894 alen
= udf_file_entry_alloc_offset(inode
) +
1898 epos
->offset
= sizeof(struct allocExtDesc
);
1899 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1900 alen
= sizeof(struct allocExtDesc
) +
1901 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1905 switch (iinfo
->i_alloc_type
) {
1906 case ICBTAG_FLAG_AD_SHORT
:
1907 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1910 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1911 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1912 eloc
->partitionReferenceNum
=
1913 iinfo
->i_location
.partitionReferenceNum
;
1914 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1916 case ICBTAG_FLAG_AD_LONG
:
1917 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
1920 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1921 *eloc
= lelb_to_cpu(lad
->extLocation
);
1922 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1925 udf_debug("alloc_type = %d unsupported\n",
1926 iinfo
->i_alloc_type
);
1933 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
1934 kernel_lb_addr neloc
, uint32_t nelen
)
1936 kernel_lb_addr oeloc
;
1943 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
1944 udf_write_aext(inode
, &epos
, neloc
, nelen
, 1);
1946 nelen
= (etype
<< 30) | oelen
;
1948 udf_add_aext(inode
, &epos
, neloc
, nelen
, 1);
1951 return (nelen
>> 30);
1954 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
1955 kernel_lb_addr eloc
, uint32_t elen
)
1957 struct extent_position oepos
;
1960 struct allocExtDesc
*aed
;
1961 struct udf_inode_info
*iinfo
;
1968 iinfo
= UDF_I(inode
);
1969 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1970 adsize
= sizeof(short_ad
);
1971 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1972 adsize
= sizeof(long_ad
);
1977 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
1980 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
1981 udf_write_aext(inode
, &oepos
, eloc
, (etype
<< 30) | elen
, 1);
1982 if (oepos
.bh
!= epos
.bh
) {
1983 oepos
.block
= epos
.block
;
1987 oepos
.offset
= epos
.offset
- adsize
;
1990 memset(&eloc
, 0x00, sizeof(kernel_lb_addr
));
1993 if (epos
.bh
!= oepos
.bh
) {
1994 udf_free_blocks(inode
->i_sb
, inode
, epos
.block
, 0, 1);
1995 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1996 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
1998 iinfo
->i_lenAlloc
-= (adsize
* 2);
1999 mark_inode_dirty(inode
);
2001 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2002 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2003 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2004 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2005 udf_update_tag(oepos
.bh
->b_data
,
2006 oepos
.offset
- (2 * adsize
));
2008 udf_update_tag(oepos
.bh
->b_data
,
2009 sizeof(struct allocExtDesc
));
2010 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2013 udf_write_aext(inode
, &oepos
, eloc
, elen
, 1);
2015 iinfo
->i_lenAlloc
-= adsize
;
2016 mark_inode_dirty(inode
);
2018 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2019 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2020 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2021 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2022 udf_update_tag(oepos
.bh
->b_data
,
2023 epos
.offset
- adsize
);
2025 udf_update_tag(oepos
.bh
->b_data
,
2026 sizeof(struct allocExtDesc
));
2027 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2034 return (elen
>> 30);
2037 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2038 struct extent_position
*pos
, kernel_lb_addr
*eloc
,
2039 uint32_t *elen
, sector_t
*offset
)
2041 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2042 loff_t lbcount
= 0, bcount
=
2043 (loff_t
) block
<< blocksize_bits
;
2045 struct udf_inode_info
*iinfo
;
2047 iinfo
= UDF_I(inode
);
2049 pos
->block
= iinfo
->i_location
;
2054 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2056 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2057 iinfo
->i_lenExtents
= lbcount
;
2061 } while (lbcount
<= bcount
);
2063 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2068 long udf_block_map(struct inode
*inode
, sector_t block
)
2070 kernel_lb_addr eloc
;
2073 struct extent_position epos
= {};
2078 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2079 (EXT_RECORDED_ALLOCATED
>> 30))
2080 ret
= udf_get_lb_pblock(inode
->i_sb
, eloc
, offset
);
2087 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2088 return udf_fixed_to_variable(ret
);