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/module.h>
35 #include <linux/pagemap.h>
36 #include <linux/buffer_head.h>
37 #include <linux/writeback.h>
38 #include <linux/slab.h>
39 #include <linux/crc-itu-t.h>
40 #include <linux/mpage.h>
45 MODULE_AUTHOR("Ben Fennema");
46 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
47 MODULE_LICENSE("GPL");
49 #define EXTENT_MERGE_SIZE 5
51 static umode_t
udf_convert_permissions(struct fileEntry
*);
52 static int udf_update_inode(struct inode
*, int);
53 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
54 static int udf_sync_inode(struct inode
*inode
);
55 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
56 static sector_t
inode_getblk(struct inode
*, sector_t
, int *, int *);
57 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
58 struct kernel_lb_addr
, uint32_t);
59 static void udf_split_extents(struct inode
*, int *, int, int,
60 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
61 static void udf_prealloc_extents(struct inode
*, int, int,
62 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
63 static void udf_merge_extents(struct inode
*,
64 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
65 static void udf_update_extents(struct inode
*,
66 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int, int,
67 struct extent_position
*);
68 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
71 void udf_evict_inode(struct inode
*inode
)
73 struct udf_inode_info
*iinfo
= UDF_I(inode
);
76 if (!inode
->i_nlink
&& !is_bad_inode(inode
)) {
78 udf_setsize(inode
, 0);
79 udf_update_inode(inode
, IS_SYNC(inode
));
81 truncate_inode_pages(&inode
->i_data
, 0);
82 invalidate_inode_buffers(inode
);
84 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
&&
85 inode
->i_size
!= iinfo
->i_lenExtents
) {
86 udf_warn(inode
->i_sb
, "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
87 inode
->i_ino
, inode
->i_mode
,
88 (unsigned long long)inode
->i_size
,
89 (unsigned long long)iinfo
->i_lenExtents
);
91 kfree(iinfo
->i_ext
.i_data
);
92 iinfo
->i_ext
.i_data
= NULL
;
94 udf_free_inode(inode
);
98 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
100 return block_write_full_page(page
, udf_get_block
, wbc
);
103 static int udf_readpage(struct file
*file
, struct page
*page
)
105 return mpage_readpage(page
, udf_get_block
);
108 static int udf_readpages(struct file
*file
, struct address_space
*mapping
,
109 struct list_head
*pages
, unsigned nr_pages
)
111 return mpage_readpages(mapping
, pages
, nr_pages
, udf_get_block
);
114 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
115 loff_t pos
, unsigned len
, unsigned flags
,
116 struct page
**pagep
, void **fsdata
)
120 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
122 struct inode
*inode
= mapping
->host
;
123 struct udf_inode_info
*iinfo
= UDF_I(inode
);
124 loff_t isize
= inode
->i_size
;
126 if (pos
+ len
> isize
) {
127 truncate_pagecache(inode
, pos
+ len
, isize
);
128 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
129 down_write(&iinfo
->i_data_sem
);
130 udf_truncate_extents(inode
);
131 up_write(&iinfo
->i_data_sem
);
139 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
141 return generic_block_bmap(mapping
, block
, udf_get_block
);
144 const struct address_space_operations udf_aops
= {
145 .readpage
= udf_readpage
,
146 .readpages
= udf_readpages
,
147 .writepage
= udf_writepage
,
148 .write_begin
= udf_write_begin
,
149 .write_end
= generic_write_end
,
154 * Expand file stored in ICB to a normal one-block-file
156 * This function requires i_data_sem for writing and releases it.
157 * This function requires i_mutex held
159 int udf_expand_file_adinicb(struct inode
*inode
)
163 struct udf_inode_info
*iinfo
= UDF_I(inode
);
165 struct writeback_control udf_wbc
= {
166 .sync_mode
= WB_SYNC_NONE
,
170 if (!iinfo
->i_lenAlloc
) {
171 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
172 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
174 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
175 /* from now on we have normal address_space methods */
176 inode
->i_data
.a_ops
= &udf_aops
;
177 up_write(&iinfo
->i_data_sem
);
178 mark_inode_dirty(inode
);
182 * Release i_data_sem so that we can lock a page - page lock ranks
183 * above i_data_sem. i_mutex still protects us against file changes.
185 up_write(&iinfo
->i_data_sem
);
187 page
= find_or_create_page(inode
->i_mapping
, 0, GFP_NOFS
);
191 if (!PageUptodate(page
)) {
193 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
194 PAGE_CACHE_SIZE
- iinfo
->i_lenAlloc
);
195 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
197 flush_dcache_page(page
);
198 SetPageUptodate(page
);
201 down_write(&iinfo
->i_data_sem
);
202 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
204 iinfo
->i_lenAlloc
= 0;
205 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
206 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
208 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
209 /* from now on we have normal address_space methods */
210 inode
->i_data
.a_ops
= &udf_aops
;
211 up_write(&iinfo
->i_data_sem
);
212 err
= inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
214 /* Restore everything back so that we don't lose data... */
217 down_write(&iinfo
->i_data_sem
);
218 memcpy(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, kaddr
,
222 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
223 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
224 up_write(&iinfo
->i_data_sem
);
226 page_cache_release(page
);
227 mark_inode_dirty(inode
);
232 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
236 struct buffer_head
*dbh
= NULL
;
237 struct kernel_lb_addr eloc
;
239 struct extent_position epos
;
241 struct udf_fileident_bh sfibh
, dfibh
;
242 loff_t f_pos
= udf_ext0_offset(inode
);
243 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
244 struct fileIdentDesc cfi
, *sfi
, *dfi
;
245 struct udf_inode_info
*iinfo
= UDF_I(inode
);
247 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
248 alloctype
= ICBTAG_FLAG_AD_SHORT
;
250 alloctype
= ICBTAG_FLAG_AD_LONG
;
252 if (!inode
->i_size
) {
253 iinfo
->i_alloc_type
= alloctype
;
254 mark_inode_dirty(inode
);
258 /* alloc block, and copy data to it */
259 *block
= udf_new_block(inode
->i_sb
, inode
,
260 iinfo
->i_location
.partitionReferenceNum
,
261 iinfo
->i_location
.logicalBlockNum
, err
);
264 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
265 iinfo
->i_location
.partitionReferenceNum
,
269 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
273 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
274 set_buffer_uptodate(dbh
);
276 mark_buffer_dirty_inode(dbh
, inode
);
278 sfibh
.soffset
= sfibh
.eoffset
=
279 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
280 sfibh
.sbh
= sfibh
.ebh
= NULL
;
281 dfibh
.soffset
= dfibh
.eoffset
= 0;
282 dfibh
.sbh
= dfibh
.ebh
= dbh
;
283 while (f_pos
< size
) {
284 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
285 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
291 iinfo
->i_alloc_type
= alloctype
;
292 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
293 dfibh
.soffset
= dfibh
.eoffset
;
294 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
295 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
296 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
298 le16_to_cpu(sfi
->lengthOfImpUse
))) {
299 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
304 mark_buffer_dirty_inode(dbh
, inode
);
306 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
308 iinfo
->i_lenAlloc
= 0;
309 eloc
.logicalBlockNum
= *block
;
310 eloc
.partitionReferenceNum
=
311 iinfo
->i_location
.partitionReferenceNum
;
312 iinfo
->i_lenExtents
= inode
->i_size
;
314 epos
.block
= iinfo
->i_location
;
315 epos
.offset
= udf_file_entry_alloc_offset(inode
);
316 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
320 mark_inode_dirty(inode
);
324 static int udf_get_block(struct inode
*inode
, sector_t block
,
325 struct buffer_head
*bh_result
, int create
)
329 struct udf_inode_info
*iinfo
;
332 phys
= udf_block_map(inode
, block
);
334 map_bh(bh_result
, inode
->i_sb
, phys
);
340 iinfo
= UDF_I(inode
);
342 down_write(&iinfo
->i_data_sem
);
343 if (block
== iinfo
->i_next_alloc_block
+ 1) {
344 iinfo
->i_next_alloc_block
++;
345 iinfo
->i_next_alloc_goal
++;
349 phys
= inode_getblk(inode
, block
, &err
, &new);
354 set_buffer_new(bh_result
);
355 map_bh(bh_result
, inode
->i_sb
, phys
);
358 up_write(&iinfo
->i_data_sem
);
362 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
363 int create
, int *err
)
365 struct buffer_head
*bh
;
366 struct buffer_head dummy
;
369 dummy
.b_blocknr
= -1000;
370 *err
= udf_get_block(inode
, block
, &dummy
, create
);
371 if (!*err
&& buffer_mapped(&dummy
)) {
372 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
373 if (buffer_new(&dummy
)) {
375 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
376 set_buffer_uptodate(bh
);
378 mark_buffer_dirty_inode(bh
, inode
);
386 /* Extend the file by 'blocks' blocks, return the number of extents added */
387 static int udf_do_extend_file(struct inode
*inode
,
388 struct extent_position
*last_pos
,
389 struct kernel_long_ad
*last_ext
,
393 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
394 struct super_block
*sb
= inode
->i_sb
;
395 struct kernel_lb_addr prealloc_loc
= {};
396 int prealloc_len
= 0;
397 struct udf_inode_info
*iinfo
;
400 /* The previous extent is fake and we should not extend by anything
401 * - there's nothing to do... */
405 iinfo
= UDF_I(inode
);
406 /* Round the last extent up to a multiple of block size */
407 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
408 last_ext
->extLength
=
409 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
410 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
411 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
412 iinfo
->i_lenExtents
=
413 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
414 ~(sb
->s_blocksize
- 1);
417 /* Last extent are just preallocated blocks? */
418 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
419 EXT_NOT_RECORDED_ALLOCATED
) {
420 /* Save the extent so that we can reattach it to the end */
421 prealloc_loc
= last_ext
->extLocation
;
422 prealloc_len
= last_ext
->extLength
;
423 /* Mark the extent as a hole */
424 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
425 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
426 last_ext
->extLocation
.logicalBlockNum
= 0;
427 last_ext
->extLocation
.partitionReferenceNum
= 0;
430 /* Can we merge with the previous extent? */
431 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
432 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
433 add
= ((1 << 30) - sb
->s_blocksize
-
434 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
435 sb
->s_blocksize_bits
;
439 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
443 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
444 last_ext
->extLength
, 1);
447 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
448 last_ext
->extLength
, 1);
450 /* Managed to do everything necessary? */
454 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
455 last_ext
->extLocation
.logicalBlockNum
= 0;
456 last_ext
->extLocation
.partitionReferenceNum
= 0;
457 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
458 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
459 (add
<< sb
->s_blocksize_bits
);
461 /* Create enough extents to cover the whole hole */
462 while (blocks
> add
) {
464 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
465 last_ext
->extLength
, 1);
471 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
472 (blocks
<< sb
->s_blocksize_bits
);
473 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
474 last_ext
->extLength
, 1);
481 /* Do we have some preallocated blocks saved? */
483 err
= udf_add_aext(inode
, last_pos
, &prealloc_loc
,
487 last_ext
->extLocation
= prealloc_loc
;
488 last_ext
->extLength
= prealloc_len
;
492 /* last_pos should point to the last written extent... */
493 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
494 last_pos
->offset
-= sizeof(struct short_ad
);
495 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
496 last_pos
->offset
-= sizeof(struct long_ad
);
503 static int udf_extend_file(struct inode
*inode
, loff_t newsize
)
506 struct extent_position epos
;
507 struct kernel_lb_addr eloc
;
510 struct super_block
*sb
= inode
->i_sb
;
511 sector_t first_block
= newsize
>> sb
->s_blocksize_bits
, offset
;
513 struct udf_inode_info
*iinfo
= UDF_I(inode
);
514 struct kernel_long_ad extent
;
517 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
518 adsize
= sizeof(struct short_ad
);
519 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
520 adsize
= sizeof(struct long_ad
);
524 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
526 /* File has extent covering the new size (could happen when extending
527 * inside a block)? */
530 if (newsize
& (sb
->s_blocksize
- 1))
532 /* Extended file just to the boundary of the last file block? */
536 /* Truncate is extending the file by 'offset' blocks */
537 if ((!epos
.bh
&& epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
538 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
539 /* File has no extents at all or has empty last
540 * indirect extent! Create a fake extent... */
541 extent
.extLocation
.logicalBlockNum
= 0;
542 extent
.extLocation
.partitionReferenceNum
= 0;
543 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
545 epos
.offset
-= adsize
;
546 etype
= udf_next_aext(inode
, &epos
, &extent
.extLocation
,
547 &extent
.extLength
, 0);
548 extent
.extLength
|= etype
<< 30;
550 err
= udf_do_extend_file(inode
, &epos
, &extent
, offset
);
554 iinfo
->i_lenExtents
= newsize
;
560 static sector_t
inode_getblk(struct inode
*inode
, sector_t block
,
563 static sector_t last_block
;
564 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
565 struct extent_position prev_epos
, cur_epos
, next_epos
;
566 int count
= 0, startnum
= 0, endnum
= 0;
567 uint32_t elen
= 0, tmpelen
;
568 struct kernel_lb_addr eloc
, tmpeloc
;
570 loff_t lbcount
= 0, b_off
= 0;
571 uint32_t newblocknum
, newblock
;
574 struct udf_inode_info
*iinfo
= UDF_I(inode
);
575 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
580 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
581 prev_epos
.block
= iinfo
->i_location
;
583 cur_epos
= next_epos
= prev_epos
;
584 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
586 /* find the extent which contains the block we are looking for.
587 alternate between laarr[0] and laarr[1] for locations of the
588 current extent, and the previous extent */
590 if (prev_epos
.bh
!= cur_epos
.bh
) {
591 brelse(prev_epos
.bh
);
593 prev_epos
.bh
= cur_epos
.bh
;
595 if (cur_epos
.bh
!= next_epos
.bh
) {
597 get_bh(next_epos
.bh
);
598 cur_epos
.bh
= next_epos
.bh
;
603 prev_epos
.block
= cur_epos
.block
;
604 cur_epos
.block
= next_epos
.block
;
606 prev_epos
.offset
= cur_epos
.offset
;
607 cur_epos
.offset
= next_epos
.offset
;
609 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
615 laarr
[c
].extLength
= (etype
<< 30) | elen
;
616 laarr
[c
].extLocation
= eloc
;
618 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
619 pgoal
= eloc
.logicalBlockNum
+
620 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
621 inode
->i_sb
->s_blocksize_bits
);
624 } while (lbcount
+ elen
<= b_off
);
627 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
629 * Move prev_epos and cur_epos into indirect extent if we are at
632 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
633 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
635 /* if the extent is allocated and recorded, return the block
636 if the extent is not a multiple of the blocksize, round up */
638 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
639 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
640 elen
= EXT_RECORDED_ALLOCATED
|
641 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
642 ~(inode
->i_sb
->s_blocksize
- 1));
643 udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
645 brelse(prev_epos
.bh
);
647 brelse(next_epos
.bh
);
648 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
653 /* Are we beyond EOF? */
662 /* Create a fake extent when there's not one */
663 memset(&laarr
[0].extLocation
, 0x00,
664 sizeof(struct kernel_lb_addr
));
665 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
666 /* Will udf_do_extend_file() create real extent from
668 startnum
= (offset
> 0);
670 /* Create extents for the hole between EOF and offset */
671 ret
= udf_do_extend_file(inode
, &prev_epos
, laarr
, offset
);
673 brelse(prev_epos
.bh
);
675 brelse(next_epos
.bh
);
682 /* We are not covered by a preallocated extent? */
683 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
684 EXT_NOT_RECORDED_ALLOCATED
) {
685 /* Is there any real extent? - otherwise we overwrite
689 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
690 inode
->i_sb
->s_blocksize
;
691 memset(&laarr
[c
].extLocation
, 0x00,
692 sizeof(struct kernel_lb_addr
));
699 endnum
= startnum
= ((count
> 2) ? 2 : count
);
701 /* if the current extent is in position 0,
702 swap it with the previous */
703 if (!c
&& count
!= 1) {
710 /* if the current block is located in an extent,
711 read the next extent */
712 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
714 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
715 laarr
[c
+ 1].extLocation
= eloc
;
723 /* if the current extent is not recorded but allocated, get the
724 * block in the extent corresponding to the requested block */
725 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
726 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
727 else { /* otherwise, allocate a new block */
728 if (iinfo
->i_next_alloc_block
== block
)
729 goal
= iinfo
->i_next_alloc_goal
;
732 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
733 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
736 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
737 iinfo
->i_location
.partitionReferenceNum
,
740 brelse(prev_epos
.bh
);
744 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
747 /* if the extent the requsted block is located in contains multiple
748 * blocks, split the extent into at most three extents. blocks prior
749 * to requested block, requested block, and blocks after requested
751 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
753 #ifdef UDF_PREALLOCATE
754 /* We preallocate blocks only for regular files. It also makes sense
755 * for directories but there's a problem when to drop the
756 * preallocation. We might use some delayed work for that but I feel
757 * it's overengineering for a filesystem like UDF. */
758 if (S_ISREG(inode
->i_mode
))
759 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
762 /* merge any continuous blocks in laarr */
763 udf_merge_extents(inode
, laarr
, &endnum
);
765 /* write back the new extents, inserting new extents if the new number
766 * of extents is greater than the old number, and deleting extents if
767 * the new number of extents is less than the old number */
768 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
770 brelse(prev_epos
.bh
);
772 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
773 iinfo
->i_location
.partitionReferenceNum
, 0);
779 iinfo
->i_next_alloc_block
= block
;
780 iinfo
->i_next_alloc_goal
= newblocknum
;
781 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
784 udf_sync_inode(inode
);
786 mark_inode_dirty(inode
);
791 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
793 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
796 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
797 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
799 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
800 (laarr
[*c
].extLength
>> 30) ==
801 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
803 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
804 blocksize
- 1) >> blocksize_bits
;
805 int8_t etype
= (laarr
[curr
].extLength
>> 30);
809 else if (!offset
|| blen
== offset
+ 1) {
810 laarr
[curr
+ 2] = laarr
[curr
+ 1];
811 laarr
[curr
+ 1] = laarr
[curr
];
813 laarr
[curr
+ 3] = laarr
[curr
+ 1];
814 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
818 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
819 udf_free_blocks(inode
->i_sb
, inode
,
820 &laarr
[curr
].extLocation
,
822 laarr
[curr
].extLength
=
823 EXT_NOT_RECORDED_NOT_ALLOCATED
|
824 (offset
<< blocksize_bits
);
825 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
826 laarr
[curr
].extLocation
.
827 partitionReferenceNum
= 0;
829 laarr
[curr
].extLength
= (etype
<< 30) |
830 (offset
<< blocksize_bits
);
836 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
837 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
838 laarr
[curr
].extLocation
.partitionReferenceNum
=
839 UDF_I(inode
)->i_location
.partitionReferenceNum
;
840 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
844 if (blen
!= offset
+ 1) {
845 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
846 laarr
[curr
].extLocation
.logicalBlockNum
+=
848 laarr
[curr
].extLength
= (etype
<< 30) |
849 ((blen
- (offset
+ 1)) << blocksize_bits
);
856 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
857 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
860 int start
, length
= 0, currlength
= 0, i
;
862 if (*endnum
>= (c
+ 1)) {
868 if ((laarr
[c
+ 1].extLength
>> 30) ==
869 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
871 length
= currlength
=
872 (((laarr
[c
+ 1].extLength
&
873 UDF_EXTENT_LENGTH_MASK
) +
874 inode
->i_sb
->s_blocksize
- 1) >>
875 inode
->i_sb
->s_blocksize_bits
);
880 for (i
= start
+ 1; i
<= *endnum
; i
++) {
883 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
884 } else if ((laarr
[i
].extLength
>> 30) ==
885 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
886 length
+= (((laarr
[i
].extLength
&
887 UDF_EXTENT_LENGTH_MASK
) +
888 inode
->i_sb
->s_blocksize
- 1) >>
889 inode
->i_sb
->s_blocksize_bits
);
895 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
896 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
897 inode
->i_sb
->s_blocksize
- 1) >>
898 inode
->i_sb
->s_blocksize_bits
);
899 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
900 laarr
[start
].extLocation
.partitionReferenceNum
,
901 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
902 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
905 if (start
== (c
+ 1))
906 laarr
[start
].extLength
+=
908 inode
->i_sb
->s_blocksize_bits
);
910 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
911 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
913 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
914 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
915 laarr
[c
].extLocation
.
916 partitionReferenceNum
;
917 laarr
[c
+ 1].extLength
=
918 EXT_NOT_RECORDED_ALLOCATED
|
920 inode
->i_sb
->s_blocksize_bits
);
924 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
925 int elen
= ((laarr
[i
].extLength
&
926 UDF_EXTENT_LENGTH_MASK
) +
927 inode
->i_sb
->s_blocksize
- 1) >>
928 inode
->i_sb
->s_blocksize_bits
;
930 if (elen
> numalloc
) {
931 laarr
[i
].extLength
-=
933 inode
->i_sb
->s_blocksize_bits
);
937 if (*endnum
> (i
+ 1))
940 sizeof(struct long_ad
) *
941 (*endnum
- (i
+ 1)));
946 UDF_I(inode
)->i_lenExtents
+=
947 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
952 static void udf_merge_extents(struct inode
*inode
,
953 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
957 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
958 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
960 for (i
= 0; i
< (*endnum
- 1); i
++) {
961 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
962 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
964 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
965 (((li
->extLength
>> 30) ==
966 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
967 ((lip1
->extLocation
.logicalBlockNum
-
968 li
->extLocation
.logicalBlockNum
) ==
969 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
970 blocksize
- 1) >> blocksize_bits
)))) {
972 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
973 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
974 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
975 lip1
->extLength
= (lip1
->extLength
-
977 UDF_EXTENT_LENGTH_MASK
) +
978 UDF_EXTENT_LENGTH_MASK
) &
980 li
->extLength
= (li
->extLength
&
981 UDF_EXTENT_FLAG_MASK
) +
982 (UDF_EXTENT_LENGTH_MASK
+ 1) -
984 lip1
->extLocation
.logicalBlockNum
=
985 li
->extLocation
.logicalBlockNum
+
987 UDF_EXTENT_LENGTH_MASK
) >>
990 li
->extLength
= lip1
->extLength
+
992 UDF_EXTENT_LENGTH_MASK
) +
993 blocksize
- 1) & ~(blocksize
- 1));
994 if (*endnum
> (i
+ 2))
995 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
996 sizeof(struct long_ad
) *
997 (*endnum
- (i
+ 2)));
1001 } else if (((li
->extLength
>> 30) ==
1002 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
1003 ((lip1
->extLength
>> 30) ==
1004 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
1005 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
1007 UDF_EXTENT_LENGTH_MASK
) +
1008 blocksize
- 1) >> blocksize_bits
);
1009 li
->extLocation
.logicalBlockNum
= 0;
1010 li
->extLocation
.partitionReferenceNum
= 0;
1012 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1013 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1014 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1015 lip1
->extLength
= (lip1
->extLength
-
1017 UDF_EXTENT_LENGTH_MASK
) +
1018 UDF_EXTENT_LENGTH_MASK
) &
1020 li
->extLength
= (li
->extLength
&
1021 UDF_EXTENT_FLAG_MASK
) +
1022 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1025 li
->extLength
= lip1
->extLength
+
1027 UDF_EXTENT_LENGTH_MASK
) +
1028 blocksize
- 1) & ~(blocksize
- 1));
1029 if (*endnum
> (i
+ 2))
1030 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1031 sizeof(struct long_ad
) *
1032 (*endnum
- (i
+ 2)));
1036 } else if ((li
->extLength
>> 30) ==
1037 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
1038 udf_free_blocks(inode
->i_sb
, inode
,
1039 &li
->extLocation
, 0,
1041 UDF_EXTENT_LENGTH_MASK
) +
1042 blocksize
- 1) >> blocksize_bits
);
1043 li
->extLocation
.logicalBlockNum
= 0;
1044 li
->extLocation
.partitionReferenceNum
= 0;
1045 li
->extLength
= (li
->extLength
&
1046 UDF_EXTENT_LENGTH_MASK
) |
1047 EXT_NOT_RECORDED_NOT_ALLOCATED
;
1052 static void udf_update_extents(struct inode
*inode
,
1053 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
1054 int startnum
, int endnum
,
1055 struct extent_position
*epos
)
1058 struct kernel_lb_addr tmploc
;
1061 if (startnum
> endnum
) {
1062 for (i
= 0; i
< (startnum
- endnum
); i
++)
1063 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
1064 laarr
[i
].extLength
);
1065 } else if (startnum
< endnum
) {
1066 for (i
= 0; i
< (endnum
- startnum
); i
++) {
1067 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
1068 laarr
[i
].extLength
);
1069 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
1070 &laarr
[i
].extLength
, 1);
1075 for (i
= start
; i
< endnum
; i
++) {
1076 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
1077 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
1078 laarr
[i
].extLength
, 1);
1082 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
1083 int create
, int *err
)
1085 struct buffer_head
*bh
= NULL
;
1087 bh
= udf_getblk(inode
, block
, create
, err
);
1091 if (buffer_uptodate(bh
))
1094 ll_rw_block(READ
, 1, &bh
);
1097 if (buffer_uptodate(bh
))
1105 int udf_setsize(struct inode
*inode
, loff_t newsize
)
1108 struct udf_inode_info
*iinfo
;
1109 int bsize
= 1 << inode
->i_blkbits
;
1111 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1112 S_ISLNK(inode
->i_mode
)))
1114 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1117 iinfo
= UDF_I(inode
);
1118 if (newsize
> inode
->i_size
) {
1119 down_write(&iinfo
->i_data_sem
);
1120 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1122 (udf_file_entry_alloc_offset(inode
) + newsize
)) {
1123 err
= udf_expand_file_adinicb(inode
);
1126 down_write(&iinfo
->i_data_sem
);
1128 iinfo
->i_lenAlloc
= newsize
;
1130 err
= udf_extend_file(inode
, newsize
);
1132 up_write(&iinfo
->i_data_sem
);
1135 truncate_setsize(inode
, newsize
);
1136 up_write(&iinfo
->i_data_sem
);
1138 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1139 down_write(&iinfo
->i_data_sem
);
1140 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1141 0x00, bsize
- newsize
-
1142 udf_file_entry_alloc_offset(inode
));
1143 iinfo
->i_lenAlloc
= newsize
;
1144 truncate_setsize(inode
, newsize
);
1145 up_write(&iinfo
->i_data_sem
);
1148 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1152 down_write(&iinfo
->i_data_sem
);
1153 truncate_setsize(inode
, newsize
);
1154 udf_truncate_extents(inode
);
1155 up_write(&iinfo
->i_data_sem
);
1158 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1160 udf_sync_inode(inode
);
1162 mark_inode_dirty(inode
);
1166 static void __udf_read_inode(struct inode
*inode
)
1168 struct buffer_head
*bh
= NULL
;
1169 struct fileEntry
*fe
;
1171 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1174 * Set defaults, but the inode is still incomplete!
1175 * Note: get_new_inode() sets the following on a new inode:
1178 * i_flags = sb->s_flags
1180 * clean_inode(): zero fills and sets
1185 bh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 0, &ident
);
1187 udf_err(inode
->i_sb
, "(ino %ld) failed !bh\n", inode
->i_ino
);
1188 make_bad_inode(inode
);
1192 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1193 ident
!= TAG_IDENT_USE
) {
1194 udf_err(inode
->i_sb
, "(ino %ld) failed ident=%d\n",
1195 inode
->i_ino
, ident
);
1197 make_bad_inode(inode
);
1201 fe
= (struct fileEntry
*)bh
->b_data
;
1203 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1204 struct buffer_head
*ibh
;
1206 ibh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 1,
1208 if (ident
== TAG_IDENT_IE
&& ibh
) {
1209 struct buffer_head
*nbh
= NULL
;
1210 struct kernel_lb_addr loc
;
1211 struct indirectEntry
*ie
;
1213 ie
= (struct indirectEntry
*)ibh
->b_data
;
1214 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1216 if (ie
->indirectICB
.extLength
&&
1217 (nbh
= udf_read_ptagged(inode
->i_sb
, &loc
, 0,
1219 if (ident
== TAG_IDENT_FE
||
1220 ident
== TAG_IDENT_EFE
) {
1221 memcpy(&iinfo
->i_location
,
1223 sizeof(struct kernel_lb_addr
));
1227 __udf_read_inode(inode
);
1234 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1235 udf_err(inode
->i_sb
, "unsupported strategy type: %d\n",
1236 le16_to_cpu(fe
->icbTag
.strategyType
));
1238 make_bad_inode(inode
);
1241 udf_fill_inode(inode
, bh
);
1246 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1248 struct fileEntry
*fe
;
1249 struct extendedFileEntry
*efe
;
1250 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1251 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1252 unsigned int link_count
;
1254 fe
= (struct fileEntry
*)bh
->b_data
;
1255 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1257 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1258 iinfo
->i_strat4096
= 0;
1259 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1260 iinfo
->i_strat4096
= 1;
1262 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1263 ICBTAG_FLAG_AD_MASK
;
1264 iinfo
->i_unique
= 0;
1265 iinfo
->i_lenEAttr
= 0;
1266 iinfo
->i_lenExtents
= 0;
1267 iinfo
->i_lenAlloc
= 0;
1268 iinfo
->i_next_alloc_block
= 0;
1269 iinfo
->i_next_alloc_goal
= 0;
1270 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1273 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1274 sizeof(struct extendedFileEntry
))) {
1275 make_bad_inode(inode
);
1278 memcpy(iinfo
->i_ext
.i_data
,
1279 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1280 inode
->i_sb
->s_blocksize
-
1281 sizeof(struct extendedFileEntry
));
1282 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1285 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1286 sizeof(struct fileEntry
))) {
1287 make_bad_inode(inode
);
1290 memcpy(iinfo
->i_ext
.i_data
,
1291 bh
->b_data
+ sizeof(struct fileEntry
),
1292 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1293 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1296 iinfo
->i_lenAlloc
= le32_to_cpu(
1297 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1299 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1300 sizeof(struct unallocSpaceEntry
))) {
1301 make_bad_inode(inode
);
1304 memcpy(iinfo
->i_ext
.i_data
,
1305 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1306 inode
->i_sb
->s_blocksize
-
1307 sizeof(struct unallocSpaceEntry
));
1311 read_lock(&sbi
->s_cred_lock
);
1312 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1313 if (inode
->i_uid
== -1 ||
1314 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1315 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1316 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1318 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1319 if (inode
->i_gid
== -1 ||
1320 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1321 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1322 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1324 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1325 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1326 inode
->i_mode
= sbi
->s_fmode
;
1327 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1328 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1329 inode
->i_mode
= sbi
->s_dmode
;
1331 inode
->i_mode
= udf_convert_permissions(fe
);
1332 inode
->i_mode
&= ~sbi
->s_umask
;
1333 read_unlock(&sbi
->s_cred_lock
);
1335 link_count
= le16_to_cpu(fe
->fileLinkCount
);
1338 set_nlink(inode
, link_count
);
1340 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1341 iinfo
->i_lenExtents
= inode
->i_size
;
1343 if (iinfo
->i_efe
== 0) {
1344 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1345 (inode
->i_sb
->s_blocksize_bits
- 9);
1347 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1348 inode
->i_atime
= sbi
->s_record_time
;
1350 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1351 fe
->modificationTime
))
1352 inode
->i_mtime
= sbi
->s_record_time
;
1354 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1355 inode
->i_ctime
= sbi
->s_record_time
;
1357 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1358 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1359 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1360 iinfo
->i_checkpoint
= le32_to_cpu(fe
->checkpoint
);
1362 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1363 (inode
->i_sb
->s_blocksize_bits
- 9);
1365 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1366 inode
->i_atime
= sbi
->s_record_time
;
1368 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1369 efe
->modificationTime
))
1370 inode
->i_mtime
= sbi
->s_record_time
;
1372 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1373 iinfo
->i_crtime
= sbi
->s_record_time
;
1375 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1376 inode
->i_ctime
= sbi
->s_record_time
;
1378 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1379 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1380 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1381 iinfo
->i_checkpoint
= le32_to_cpu(efe
->checkpoint
);
1384 switch (fe
->icbTag
.fileType
) {
1385 case ICBTAG_FILE_TYPE_DIRECTORY
:
1386 inode
->i_op
= &udf_dir_inode_operations
;
1387 inode
->i_fop
= &udf_dir_operations
;
1388 inode
->i_mode
|= S_IFDIR
;
1391 case ICBTAG_FILE_TYPE_REALTIME
:
1392 case ICBTAG_FILE_TYPE_REGULAR
:
1393 case ICBTAG_FILE_TYPE_UNDEF
:
1394 case ICBTAG_FILE_TYPE_VAT20
:
1395 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1396 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1398 inode
->i_data
.a_ops
= &udf_aops
;
1399 inode
->i_op
= &udf_file_inode_operations
;
1400 inode
->i_fop
= &udf_file_operations
;
1401 inode
->i_mode
|= S_IFREG
;
1403 case ICBTAG_FILE_TYPE_BLOCK
:
1404 inode
->i_mode
|= S_IFBLK
;
1406 case ICBTAG_FILE_TYPE_CHAR
:
1407 inode
->i_mode
|= S_IFCHR
;
1409 case ICBTAG_FILE_TYPE_FIFO
:
1410 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1412 case ICBTAG_FILE_TYPE_SOCKET
:
1413 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1415 case ICBTAG_FILE_TYPE_SYMLINK
:
1416 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1417 inode
->i_op
= &udf_symlink_inode_operations
;
1418 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1420 case ICBTAG_FILE_TYPE_MAIN
:
1421 udf_debug("METADATA FILE-----\n");
1423 case ICBTAG_FILE_TYPE_MIRROR
:
1424 udf_debug("METADATA MIRROR FILE-----\n");
1426 case ICBTAG_FILE_TYPE_BITMAP
:
1427 udf_debug("METADATA BITMAP FILE-----\n");
1430 udf_err(inode
->i_sb
, "(ino %ld) failed unknown file type=%d\n",
1431 inode
->i_ino
, fe
->icbTag
.fileType
);
1432 make_bad_inode(inode
);
1435 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1436 struct deviceSpec
*dsea
=
1437 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1439 init_special_inode(inode
, inode
->i_mode
,
1440 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1441 le32_to_cpu(dsea
->minorDeviceIdent
)));
1442 /* Developer ID ??? */
1444 make_bad_inode(inode
);
1448 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1450 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1451 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1453 if (!iinfo
->i_ext
.i_data
) {
1454 udf_err(inode
->i_sb
, "(ino %ld) no free memory\n",
1462 static umode_t
udf_convert_permissions(struct fileEntry
*fe
)
1465 uint32_t permissions
;
1468 permissions
= le32_to_cpu(fe
->permissions
);
1469 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1471 mode
= ((permissions
) & S_IRWXO
) |
1472 ((permissions
>> 2) & S_IRWXG
) |
1473 ((permissions
>> 4) & S_IRWXU
) |
1474 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1475 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1476 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1481 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1483 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1486 static int udf_sync_inode(struct inode
*inode
)
1488 return udf_update_inode(inode
, 1);
1491 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1493 struct buffer_head
*bh
= NULL
;
1494 struct fileEntry
*fe
;
1495 struct extendedFileEntry
*efe
;
1496 uint64_t lb_recorded
;
1501 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1502 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1503 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1505 bh
= udf_tgetblk(inode
->i_sb
,
1506 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1508 udf_debug("getblk failure\n");
1513 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1514 fe
= (struct fileEntry
*)bh
->b_data
;
1515 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1518 struct unallocSpaceEntry
*use
=
1519 (struct unallocSpaceEntry
*)bh
->b_data
;
1521 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1522 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1523 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1524 sizeof(struct unallocSpaceEntry
));
1525 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1526 use
->descTag
.tagLocation
=
1527 cpu_to_le32(iinfo
->i_location
.logicalBlockNum
);
1528 crclen
= sizeof(struct unallocSpaceEntry
) +
1529 iinfo
->i_lenAlloc
- sizeof(struct tag
);
1530 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1531 use
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)use
+
1534 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1539 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1540 fe
->uid
= cpu_to_le32(-1);
1542 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1544 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1545 fe
->gid
= cpu_to_le32(-1);
1547 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1549 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1550 ((inode
->i_mode
& S_IRWXG
) << 2) |
1551 ((inode
->i_mode
& S_IRWXU
) << 4);
1553 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1554 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1555 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1556 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1557 fe
->permissions
= cpu_to_le32(udfperms
);
1559 if (S_ISDIR(inode
->i_mode
))
1560 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1562 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1564 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1566 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1568 struct deviceSpec
*dsea
=
1569 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1571 dsea
= (struct deviceSpec
*)
1572 udf_add_extendedattr(inode
,
1573 sizeof(struct deviceSpec
) +
1574 sizeof(struct regid
), 12, 0x3);
1575 dsea
->attrType
= cpu_to_le32(12);
1576 dsea
->attrSubtype
= 1;
1577 dsea
->attrLength
= cpu_to_le32(
1578 sizeof(struct deviceSpec
) +
1579 sizeof(struct regid
));
1580 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1582 eid
= (struct regid
*)dsea
->impUse
;
1583 memset(eid
, 0, sizeof(struct regid
));
1584 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1585 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1586 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1587 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1588 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1591 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1592 lb_recorded
= 0; /* No extents => no blocks! */
1595 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1596 (blocksize_bits
- 9);
1598 if (iinfo
->i_efe
== 0) {
1599 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1600 iinfo
->i_ext
.i_data
,
1601 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1602 fe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1604 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1605 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1606 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1607 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1608 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1609 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1610 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1611 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1612 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1613 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1614 fe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1615 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1616 crclen
= sizeof(struct fileEntry
);
1618 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1619 iinfo
->i_ext
.i_data
,
1620 inode
->i_sb
->s_blocksize
-
1621 sizeof(struct extendedFileEntry
));
1622 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1623 efe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1625 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1626 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1627 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1628 iinfo
->i_crtime
= inode
->i_atime
;
1630 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1631 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1632 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1633 iinfo
->i_crtime
= inode
->i_mtime
;
1635 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1636 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1637 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1638 iinfo
->i_crtime
= inode
->i_ctime
;
1640 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1641 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1642 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1643 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1645 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1646 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1647 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1648 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1649 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1650 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1651 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1652 efe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1653 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1654 crclen
= sizeof(struct extendedFileEntry
);
1656 if (iinfo
->i_strat4096
) {
1657 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1658 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1659 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1661 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1662 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1665 if (S_ISDIR(inode
->i_mode
))
1666 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1667 else if (S_ISREG(inode
->i_mode
))
1668 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1669 else if (S_ISLNK(inode
->i_mode
))
1670 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1671 else if (S_ISBLK(inode
->i_mode
))
1672 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1673 else if (S_ISCHR(inode
->i_mode
))
1674 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1675 else if (S_ISFIFO(inode
->i_mode
))
1676 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1677 else if (S_ISSOCK(inode
->i_mode
))
1678 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1680 icbflags
= iinfo
->i_alloc_type
|
1681 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1682 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1683 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1684 (le16_to_cpu(fe
->icbTag
.flags
) &
1685 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1686 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1688 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1689 if (sbi
->s_udfrev
>= 0x0200)
1690 fe
->descTag
.descVersion
= cpu_to_le16(3);
1692 fe
->descTag
.descVersion
= cpu_to_le16(2);
1693 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1694 fe
->descTag
.tagLocation
= cpu_to_le32(
1695 iinfo
->i_location
.logicalBlockNum
);
1696 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1697 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1698 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1700 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1703 set_buffer_uptodate(bh
);
1706 /* write the data blocks */
1707 mark_buffer_dirty(bh
);
1709 sync_dirty_buffer(bh
);
1710 if (buffer_write_io_error(bh
)) {
1711 udf_warn(inode
->i_sb
, "IO error syncing udf inode [%08lx]\n",
1721 struct inode
*udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
)
1723 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1724 struct inode
*inode
= iget_locked(sb
, block
);
1729 if (inode
->i_state
& I_NEW
) {
1730 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1731 __udf_read_inode(inode
);
1732 unlock_new_inode(inode
);
1735 if (is_bad_inode(inode
))
1738 if (ino
->logicalBlockNum
>= UDF_SB(sb
)->
1739 s_partmaps
[ino
->partitionReferenceNum
].s_partition_len
) {
1740 udf_debug("block=%d, partition=%d out of range\n",
1741 ino
->logicalBlockNum
, ino
->partitionReferenceNum
);
1742 make_bad_inode(inode
);
1753 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1754 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1757 struct short_ad
*sad
= NULL
;
1758 struct long_ad
*lad
= NULL
;
1759 struct allocExtDesc
*aed
;
1761 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1764 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1765 udf_file_entry_alloc_offset(inode
) +
1768 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1770 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1771 adsize
= sizeof(struct short_ad
);
1772 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1773 adsize
= sizeof(struct long_ad
);
1777 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1778 unsigned char *sptr
, *dptr
;
1779 struct buffer_head
*nbh
;
1781 struct kernel_lb_addr obloc
= epos
->block
;
1783 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1784 obloc
.partitionReferenceNum
,
1785 obloc
.logicalBlockNum
, &err
);
1786 if (!epos
->block
.logicalBlockNum
)
1788 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1794 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1795 set_buffer_uptodate(nbh
);
1797 mark_buffer_dirty_inode(nbh
, inode
);
1799 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1800 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1801 aed
->previousAllocExtLocation
=
1802 cpu_to_le32(obloc
.logicalBlockNum
);
1803 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1804 loffset
= epos
->offset
;
1805 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1806 sptr
= ptr
- adsize
;
1807 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1808 memcpy(dptr
, sptr
, adsize
);
1809 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1811 loffset
= epos
->offset
+ adsize
;
1812 aed
->lengthAllocDescs
= cpu_to_le32(0);
1814 epos
->offset
= sizeof(struct allocExtDesc
);
1817 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1818 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1820 iinfo
->i_lenAlloc
+= adsize
;
1821 mark_inode_dirty(inode
);
1824 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1825 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1826 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1828 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1829 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1830 switch (iinfo
->i_alloc_type
) {
1831 case ICBTAG_FLAG_AD_SHORT
:
1832 sad
= (struct short_ad
*)sptr
;
1833 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1834 inode
->i_sb
->s_blocksize
);
1836 cpu_to_le32(epos
->block
.logicalBlockNum
);
1838 case ICBTAG_FLAG_AD_LONG
:
1839 lad
= (struct long_ad
*)sptr
;
1840 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1841 inode
->i_sb
->s_blocksize
);
1842 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1843 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1847 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1848 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1849 udf_update_tag(epos
->bh
->b_data
, loffset
);
1851 udf_update_tag(epos
->bh
->b_data
,
1852 sizeof(struct allocExtDesc
));
1853 mark_buffer_dirty_inode(epos
->bh
, inode
);
1856 mark_inode_dirty(inode
);
1861 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1864 iinfo
->i_lenAlloc
+= adsize
;
1865 mark_inode_dirty(inode
);
1867 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1868 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1869 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1870 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1871 udf_update_tag(epos
->bh
->b_data
,
1872 epos
->offset
+ (inc
? 0 : adsize
));
1874 udf_update_tag(epos
->bh
->b_data
,
1875 sizeof(struct allocExtDesc
));
1876 mark_buffer_dirty_inode(epos
->bh
, inode
);
1882 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1883 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1887 struct short_ad
*sad
;
1888 struct long_ad
*lad
;
1889 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1892 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1893 udf_file_entry_alloc_offset(inode
) +
1896 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1898 switch (iinfo
->i_alloc_type
) {
1899 case ICBTAG_FLAG_AD_SHORT
:
1900 sad
= (struct short_ad
*)ptr
;
1901 sad
->extLength
= cpu_to_le32(elen
);
1902 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
1903 adsize
= sizeof(struct short_ad
);
1905 case ICBTAG_FLAG_AD_LONG
:
1906 lad
= (struct long_ad
*)ptr
;
1907 lad
->extLength
= cpu_to_le32(elen
);
1908 lad
->extLocation
= cpu_to_lelb(*eloc
);
1909 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1910 adsize
= sizeof(struct long_ad
);
1917 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1918 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1919 struct allocExtDesc
*aed
=
1920 (struct allocExtDesc
*)epos
->bh
->b_data
;
1921 udf_update_tag(epos
->bh
->b_data
,
1922 le32_to_cpu(aed
->lengthAllocDescs
) +
1923 sizeof(struct allocExtDesc
));
1925 mark_buffer_dirty_inode(epos
->bh
, inode
);
1927 mark_inode_dirty(inode
);
1931 epos
->offset
+= adsize
;
1934 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1935 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1939 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1940 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1942 epos
->block
= *eloc
;
1943 epos
->offset
= sizeof(struct allocExtDesc
);
1945 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
1946 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1948 udf_debug("reading block %d failed!\n", block
);
1956 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1957 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1962 struct short_ad
*sad
;
1963 struct long_ad
*lad
;
1964 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1968 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1969 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1970 udf_file_entry_alloc_offset(inode
) +
1972 alen
= udf_file_entry_alloc_offset(inode
) +
1976 epos
->offset
= sizeof(struct allocExtDesc
);
1977 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1978 alen
= sizeof(struct allocExtDesc
) +
1979 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1983 switch (iinfo
->i_alloc_type
) {
1984 case ICBTAG_FLAG_AD_SHORT
:
1985 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1988 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1989 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1990 eloc
->partitionReferenceNum
=
1991 iinfo
->i_location
.partitionReferenceNum
;
1992 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1994 case ICBTAG_FLAG_AD_LONG
:
1995 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
1998 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1999 *eloc
= lelb_to_cpu(lad
->extLocation
);
2000 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2003 udf_debug("alloc_type = %d unsupported\n", iinfo
->i_alloc_type
);
2010 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
2011 struct kernel_lb_addr neloc
, uint32_t nelen
)
2013 struct kernel_lb_addr oeloc
;
2020 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2021 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2023 nelen
= (etype
<< 30) | oelen
;
2025 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2028 return (nelen
>> 30);
2031 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
2032 struct kernel_lb_addr eloc
, uint32_t elen
)
2034 struct extent_position oepos
;
2037 struct allocExtDesc
*aed
;
2038 struct udf_inode_info
*iinfo
;
2045 iinfo
= UDF_I(inode
);
2046 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2047 adsize
= sizeof(struct short_ad
);
2048 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2049 adsize
= sizeof(struct long_ad
);
2054 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2057 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2058 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2059 if (oepos
.bh
!= epos
.bh
) {
2060 oepos
.block
= epos
.block
;
2064 oepos
.offset
= epos
.offset
- adsize
;
2067 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2070 if (epos
.bh
!= oepos
.bh
) {
2071 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2072 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2073 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2075 iinfo
->i_lenAlloc
-= (adsize
* 2);
2076 mark_inode_dirty(inode
);
2078 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2079 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2080 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2081 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2082 udf_update_tag(oepos
.bh
->b_data
,
2083 oepos
.offset
- (2 * adsize
));
2085 udf_update_tag(oepos
.bh
->b_data
,
2086 sizeof(struct allocExtDesc
));
2087 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2090 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2092 iinfo
->i_lenAlloc
-= adsize
;
2093 mark_inode_dirty(inode
);
2095 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2096 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2097 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2098 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2099 udf_update_tag(oepos
.bh
->b_data
,
2100 epos
.offset
- adsize
);
2102 udf_update_tag(oepos
.bh
->b_data
,
2103 sizeof(struct allocExtDesc
));
2104 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2111 return (elen
>> 30);
2114 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2115 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2116 uint32_t *elen
, sector_t
*offset
)
2118 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2119 loff_t lbcount
= 0, bcount
=
2120 (loff_t
) block
<< blocksize_bits
;
2122 struct udf_inode_info
*iinfo
;
2124 iinfo
= UDF_I(inode
);
2126 pos
->block
= iinfo
->i_location
;
2131 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2133 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2134 iinfo
->i_lenExtents
= lbcount
;
2138 } while (lbcount
<= bcount
);
2140 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2145 long udf_block_map(struct inode
*inode
, sector_t block
)
2147 struct kernel_lb_addr eloc
;
2150 struct extent_position epos
= {};
2153 down_read(&UDF_I(inode
)->i_data_sem
);
2155 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2156 (EXT_RECORDED_ALLOCATED
>> 30))
2157 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2161 up_read(&UDF_I(inode
)->i_data_sem
);
2164 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2165 return udf_fixed_to_variable(ret
);