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
;
1132 err
= udf_extend_file(inode
, newsize
);
1134 up_write(&iinfo
->i_data_sem
);
1138 truncate_setsize(inode
, newsize
);
1139 up_write(&iinfo
->i_data_sem
);
1141 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1142 down_write(&iinfo
->i_data_sem
);
1143 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1144 0x00, bsize
- newsize
-
1145 udf_file_entry_alloc_offset(inode
));
1146 iinfo
->i_lenAlloc
= newsize
;
1147 truncate_setsize(inode
, newsize
);
1148 up_write(&iinfo
->i_data_sem
);
1151 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1155 down_write(&iinfo
->i_data_sem
);
1156 truncate_setsize(inode
, newsize
);
1157 udf_truncate_extents(inode
);
1158 up_write(&iinfo
->i_data_sem
);
1161 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1163 udf_sync_inode(inode
);
1165 mark_inode_dirty(inode
);
1169 static void __udf_read_inode(struct inode
*inode
)
1171 struct buffer_head
*bh
= NULL
;
1172 struct fileEntry
*fe
;
1174 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1177 * Set defaults, but the inode is still incomplete!
1178 * Note: get_new_inode() sets the following on a new inode:
1181 * i_flags = sb->s_flags
1183 * clean_inode(): zero fills and sets
1188 bh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 0, &ident
);
1190 udf_err(inode
->i_sb
, "(ino %ld) failed !bh\n", inode
->i_ino
);
1191 make_bad_inode(inode
);
1195 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1196 ident
!= TAG_IDENT_USE
) {
1197 udf_err(inode
->i_sb
, "(ino %ld) failed ident=%d\n",
1198 inode
->i_ino
, ident
);
1200 make_bad_inode(inode
);
1204 fe
= (struct fileEntry
*)bh
->b_data
;
1206 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1207 struct buffer_head
*ibh
;
1209 ibh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 1,
1211 if (ident
== TAG_IDENT_IE
&& ibh
) {
1212 struct buffer_head
*nbh
= NULL
;
1213 struct kernel_lb_addr loc
;
1214 struct indirectEntry
*ie
;
1216 ie
= (struct indirectEntry
*)ibh
->b_data
;
1217 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1219 if (ie
->indirectICB
.extLength
&&
1220 (nbh
= udf_read_ptagged(inode
->i_sb
, &loc
, 0,
1222 if (ident
== TAG_IDENT_FE
||
1223 ident
== TAG_IDENT_EFE
) {
1224 memcpy(&iinfo
->i_location
,
1226 sizeof(struct kernel_lb_addr
));
1230 __udf_read_inode(inode
);
1237 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1238 udf_err(inode
->i_sb
, "unsupported strategy type: %d\n",
1239 le16_to_cpu(fe
->icbTag
.strategyType
));
1241 make_bad_inode(inode
);
1244 udf_fill_inode(inode
, bh
);
1249 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1251 struct fileEntry
*fe
;
1252 struct extendedFileEntry
*efe
;
1253 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1254 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1255 unsigned int link_count
;
1257 fe
= (struct fileEntry
*)bh
->b_data
;
1258 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1260 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1261 iinfo
->i_strat4096
= 0;
1262 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1263 iinfo
->i_strat4096
= 1;
1265 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1266 ICBTAG_FLAG_AD_MASK
;
1267 iinfo
->i_unique
= 0;
1268 iinfo
->i_lenEAttr
= 0;
1269 iinfo
->i_lenExtents
= 0;
1270 iinfo
->i_lenAlloc
= 0;
1271 iinfo
->i_next_alloc_block
= 0;
1272 iinfo
->i_next_alloc_goal
= 0;
1273 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1276 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1277 sizeof(struct extendedFileEntry
))) {
1278 make_bad_inode(inode
);
1281 memcpy(iinfo
->i_ext
.i_data
,
1282 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1283 inode
->i_sb
->s_blocksize
-
1284 sizeof(struct extendedFileEntry
));
1285 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1288 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1289 sizeof(struct fileEntry
))) {
1290 make_bad_inode(inode
);
1293 memcpy(iinfo
->i_ext
.i_data
,
1294 bh
->b_data
+ sizeof(struct fileEntry
),
1295 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1296 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1299 iinfo
->i_lenAlloc
= le32_to_cpu(
1300 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1302 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1303 sizeof(struct unallocSpaceEntry
))) {
1304 make_bad_inode(inode
);
1307 memcpy(iinfo
->i_ext
.i_data
,
1308 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1309 inode
->i_sb
->s_blocksize
-
1310 sizeof(struct unallocSpaceEntry
));
1314 read_lock(&sbi
->s_cred_lock
);
1315 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1316 if (inode
->i_uid
== -1 ||
1317 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1318 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1319 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1321 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1322 if (inode
->i_gid
== -1 ||
1323 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1324 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1325 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1327 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1328 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1329 inode
->i_mode
= sbi
->s_fmode
;
1330 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1331 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1332 inode
->i_mode
= sbi
->s_dmode
;
1334 inode
->i_mode
= udf_convert_permissions(fe
);
1335 inode
->i_mode
&= ~sbi
->s_umask
;
1336 read_unlock(&sbi
->s_cred_lock
);
1338 link_count
= le16_to_cpu(fe
->fileLinkCount
);
1341 set_nlink(inode
, link_count
);
1343 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1344 iinfo
->i_lenExtents
= inode
->i_size
;
1346 if (iinfo
->i_efe
== 0) {
1347 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1348 (inode
->i_sb
->s_blocksize_bits
- 9);
1350 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1351 inode
->i_atime
= sbi
->s_record_time
;
1353 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1354 fe
->modificationTime
))
1355 inode
->i_mtime
= sbi
->s_record_time
;
1357 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1358 inode
->i_ctime
= sbi
->s_record_time
;
1360 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1361 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1362 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1363 iinfo
->i_checkpoint
= le32_to_cpu(fe
->checkpoint
);
1365 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1366 (inode
->i_sb
->s_blocksize_bits
- 9);
1368 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1369 inode
->i_atime
= sbi
->s_record_time
;
1371 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1372 efe
->modificationTime
))
1373 inode
->i_mtime
= sbi
->s_record_time
;
1375 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1376 iinfo
->i_crtime
= sbi
->s_record_time
;
1378 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1379 inode
->i_ctime
= sbi
->s_record_time
;
1381 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1382 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1383 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1384 iinfo
->i_checkpoint
= le32_to_cpu(efe
->checkpoint
);
1387 switch (fe
->icbTag
.fileType
) {
1388 case ICBTAG_FILE_TYPE_DIRECTORY
:
1389 inode
->i_op
= &udf_dir_inode_operations
;
1390 inode
->i_fop
= &udf_dir_operations
;
1391 inode
->i_mode
|= S_IFDIR
;
1394 case ICBTAG_FILE_TYPE_REALTIME
:
1395 case ICBTAG_FILE_TYPE_REGULAR
:
1396 case ICBTAG_FILE_TYPE_UNDEF
:
1397 case ICBTAG_FILE_TYPE_VAT20
:
1398 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1399 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1401 inode
->i_data
.a_ops
= &udf_aops
;
1402 inode
->i_op
= &udf_file_inode_operations
;
1403 inode
->i_fop
= &udf_file_operations
;
1404 inode
->i_mode
|= S_IFREG
;
1406 case ICBTAG_FILE_TYPE_BLOCK
:
1407 inode
->i_mode
|= S_IFBLK
;
1409 case ICBTAG_FILE_TYPE_CHAR
:
1410 inode
->i_mode
|= S_IFCHR
;
1412 case ICBTAG_FILE_TYPE_FIFO
:
1413 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1415 case ICBTAG_FILE_TYPE_SOCKET
:
1416 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1418 case ICBTAG_FILE_TYPE_SYMLINK
:
1419 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1420 inode
->i_op
= &udf_symlink_inode_operations
;
1421 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1423 case ICBTAG_FILE_TYPE_MAIN
:
1424 udf_debug("METADATA FILE-----\n");
1426 case ICBTAG_FILE_TYPE_MIRROR
:
1427 udf_debug("METADATA MIRROR FILE-----\n");
1429 case ICBTAG_FILE_TYPE_BITMAP
:
1430 udf_debug("METADATA BITMAP FILE-----\n");
1433 udf_err(inode
->i_sb
, "(ino %ld) failed unknown file type=%d\n",
1434 inode
->i_ino
, fe
->icbTag
.fileType
);
1435 make_bad_inode(inode
);
1438 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1439 struct deviceSpec
*dsea
=
1440 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1442 init_special_inode(inode
, inode
->i_mode
,
1443 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1444 le32_to_cpu(dsea
->minorDeviceIdent
)));
1445 /* Developer ID ??? */
1447 make_bad_inode(inode
);
1451 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1453 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1454 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1456 if (!iinfo
->i_ext
.i_data
) {
1457 udf_err(inode
->i_sb
, "(ino %ld) no free memory\n",
1465 static umode_t
udf_convert_permissions(struct fileEntry
*fe
)
1468 uint32_t permissions
;
1471 permissions
= le32_to_cpu(fe
->permissions
);
1472 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1474 mode
= ((permissions
) & S_IRWXO
) |
1475 ((permissions
>> 2) & S_IRWXG
) |
1476 ((permissions
>> 4) & S_IRWXU
) |
1477 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1478 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1479 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1484 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1486 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1489 static int udf_sync_inode(struct inode
*inode
)
1491 return udf_update_inode(inode
, 1);
1494 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1496 struct buffer_head
*bh
= NULL
;
1497 struct fileEntry
*fe
;
1498 struct extendedFileEntry
*efe
;
1499 uint64_t lb_recorded
;
1504 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1505 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1506 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1508 bh
= udf_tgetblk(inode
->i_sb
,
1509 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1511 udf_debug("getblk failure\n");
1516 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1517 fe
= (struct fileEntry
*)bh
->b_data
;
1518 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1521 struct unallocSpaceEntry
*use
=
1522 (struct unallocSpaceEntry
*)bh
->b_data
;
1524 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1525 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1526 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1527 sizeof(struct unallocSpaceEntry
));
1528 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1529 use
->descTag
.tagLocation
=
1530 cpu_to_le32(iinfo
->i_location
.logicalBlockNum
);
1531 crclen
= sizeof(struct unallocSpaceEntry
) +
1532 iinfo
->i_lenAlloc
- sizeof(struct tag
);
1533 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1534 use
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)use
+
1537 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1542 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1543 fe
->uid
= cpu_to_le32(-1);
1545 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1547 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1548 fe
->gid
= cpu_to_le32(-1);
1550 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1552 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1553 ((inode
->i_mode
& S_IRWXG
) << 2) |
1554 ((inode
->i_mode
& S_IRWXU
) << 4);
1556 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1557 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1558 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1559 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1560 fe
->permissions
= cpu_to_le32(udfperms
);
1562 if (S_ISDIR(inode
->i_mode
))
1563 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1565 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1567 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1569 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1571 struct deviceSpec
*dsea
=
1572 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1574 dsea
= (struct deviceSpec
*)
1575 udf_add_extendedattr(inode
,
1576 sizeof(struct deviceSpec
) +
1577 sizeof(struct regid
), 12, 0x3);
1578 dsea
->attrType
= cpu_to_le32(12);
1579 dsea
->attrSubtype
= 1;
1580 dsea
->attrLength
= cpu_to_le32(
1581 sizeof(struct deviceSpec
) +
1582 sizeof(struct regid
));
1583 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1585 eid
= (struct regid
*)dsea
->impUse
;
1586 memset(eid
, 0, sizeof(struct regid
));
1587 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1588 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1589 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1590 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1591 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1594 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1595 lb_recorded
= 0; /* No extents => no blocks! */
1598 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1599 (blocksize_bits
- 9);
1601 if (iinfo
->i_efe
== 0) {
1602 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1603 iinfo
->i_ext
.i_data
,
1604 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1605 fe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1607 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1608 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1609 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1610 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1611 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1612 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1613 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1614 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1615 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1616 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1617 fe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1618 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1619 crclen
= sizeof(struct fileEntry
);
1621 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1622 iinfo
->i_ext
.i_data
,
1623 inode
->i_sb
->s_blocksize
-
1624 sizeof(struct extendedFileEntry
));
1625 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1626 efe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1628 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1629 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1630 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1631 iinfo
->i_crtime
= inode
->i_atime
;
1633 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1634 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1635 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1636 iinfo
->i_crtime
= inode
->i_mtime
;
1638 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1639 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1640 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1641 iinfo
->i_crtime
= inode
->i_ctime
;
1643 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1644 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1645 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1646 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1648 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1649 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1650 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1651 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1652 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1653 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1654 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1655 efe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1656 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1657 crclen
= sizeof(struct extendedFileEntry
);
1659 if (iinfo
->i_strat4096
) {
1660 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1661 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1662 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1664 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1665 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1668 if (S_ISDIR(inode
->i_mode
))
1669 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1670 else if (S_ISREG(inode
->i_mode
))
1671 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1672 else if (S_ISLNK(inode
->i_mode
))
1673 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1674 else if (S_ISBLK(inode
->i_mode
))
1675 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1676 else if (S_ISCHR(inode
->i_mode
))
1677 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1678 else if (S_ISFIFO(inode
->i_mode
))
1679 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1680 else if (S_ISSOCK(inode
->i_mode
))
1681 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1683 icbflags
= iinfo
->i_alloc_type
|
1684 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1685 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1686 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1687 (le16_to_cpu(fe
->icbTag
.flags
) &
1688 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1689 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1691 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1692 if (sbi
->s_udfrev
>= 0x0200)
1693 fe
->descTag
.descVersion
= cpu_to_le16(3);
1695 fe
->descTag
.descVersion
= cpu_to_le16(2);
1696 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1697 fe
->descTag
.tagLocation
= cpu_to_le32(
1698 iinfo
->i_location
.logicalBlockNum
);
1699 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1700 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1701 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1703 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1706 set_buffer_uptodate(bh
);
1709 /* write the data blocks */
1710 mark_buffer_dirty(bh
);
1712 sync_dirty_buffer(bh
);
1713 if (buffer_write_io_error(bh
)) {
1714 udf_warn(inode
->i_sb
, "IO error syncing udf inode [%08lx]\n",
1724 struct inode
*udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
)
1726 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1727 struct inode
*inode
= iget_locked(sb
, block
);
1732 if (inode
->i_state
& I_NEW
) {
1733 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1734 __udf_read_inode(inode
);
1735 unlock_new_inode(inode
);
1738 if (is_bad_inode(inode
))
1741 if (ino
->logicalBlockNum
>= UDF_SB(sb
)->
1742 s_partmaps
[ino
->partitionReferenceNum
].s_partition_len
) {
1743 udf_debug("block=%d, partition=%d out of range\n",
1744 ino
->logicalBlockNum
, ino
->partitionReferenceNum
);
1745 make_bad_inode(inode
);
1756 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1757 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1760 struct short_ad
*sad
= NULL
;
1761 struct long_ad
*lad
= NULL
;
1762 struct allocExtDesc
*aed
;
1764 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1767 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1768 udf_file_entry_alloc_offset(inode
) +
1771 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1773 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1774 adsize
= sizeof(struct short_ad
);
1775 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1776 adsize
= sizeof(struct long_ad
);
1780 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1781 unsigned char *sptr
, *dptr
;
1782 struct buffer_head
*nbh
;
1784 struct kernel_lb_addr obloc
= epos
->block
;
1786 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1787 obloc
.partitionReferenceNum
,
1788 obloc
.logicalBlockNum
, &err
);
1789 if (!epos
->block
.logicalBlockNum
)
1791 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1797 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1798 set_buffer_uptodate(nbh
);
1800 mark_buffer_dirty_inode(nbh
, inode
);
1802 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1803 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1804 aed
->previousAllocExtLocation
=
1805 cpu_to_le32(obloc
.logicalBlockNum
);
1806 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1807 loffset
= epos
->offset
;
1808 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1809 sptr
= ptr
- adsize
;
1810 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1811 memcpy(dptr
, sptr
, adsize
);
1812 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1814 loffset
= epos
->offset
+ adsize
;
1815 aed
->lengthAllocDescs
= cpu_to_le32(0);
1817 epos
->offset
= sizeof(struct allocExtDesc
);
1820 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1821 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1823 iinfo
->i_lenAlloc
+= adsize
;
1824 mark_inode_dirty(inode
);
1827 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1828 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1829 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1831 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1832 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1833 switch (iinfo
->i_alloc_type
) {
1834 case ICBTAG_FLAG_AD_SHORT
:
1835 sad
= (struct short_ad
*)sptr
;
1836 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1837 inode
->i_sb
->s_blocksize
);
1839 cpu_to_le32(epos
->block
.logicalBlockNum
);
1841 case ICBTAG_FLAG_AD_LONG
:
1842 lad
= (struct long_ad
*)sptr
;
1843 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1844 inode
->i_sb
->s_blocksize
);
1845 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1846 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1850 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1851 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1852 udf_update_tag(epos
->bh
->b_data
, loffset
);
1854 udf_update_tag(epos
->bh
->b_data
,
1855 sizeof(struct allocExtDesc
));
1856 mark_buffer_dirty_inode(epos
->bh
, inode
);
1859 mark_inode_dirty(inode
);
1864 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1867 iinfo
->i_lenAlloc
+= adsize
;
1868 mark_inode_dirty(inode
);
1870 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1871 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1872 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1873 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1874 udf_update_tag(epos
->bh
->b_data
,
1875 epos
->offset
+ (inc
? 0 : adsize
));
1877 udf_update_tag(epos
->bh
->b_data
,
1878 sizeof(struct allocExtDesc
));
1879 mark_buffer_dirty_inode(epos
->bh
, inode
);
1885 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1886 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1890 struct short_ad
*sad
;
1891 struct long_ad
*lad
;
1892 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1895 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1896 udf_file_entry_alloc_offset(inode
) +
1899 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1901 switch (iinfo
->i_alloc_type
) {
1902 case ICBTAG_FLAG_AD_SHORT
:
1903 sad
= (struct short_ad
*)ptr
;
1904 sad
->extLength
= cpu_to_le32(elen
);
1905 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
1906 adsize
= sizeof(struct short_ad
);
1908 case ICBTAG_FLAG_AD_LONG
:
1909 lad
= (struct long_ad
*)ptr
;
1910 lad
->extLength
= cpu_to_le32(elen
);
1911 lad
->extLocation
= cpu_to_lelb(*eloc
);
1912 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1913 adsize
= sizeof(struct long_ad
);
1920 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1921 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1922 struct allocExtDesc
*aed
=
1923 (struct allocExtDesc
*)epos
->bh
->b_data
;
1924 udf_update_tag(epos
->bh
->b_data
,
1925 le32_to_cpu(aed
->lengthAllocDescs
) +
1926 sizeof(struct allocExtDesc
));
1928 mark_buffer_dirty_inode(epos
->bh
, inode
);
1930 mark_inode_dirty(inode
);
1934 epos
->offset
+= adsize
;
1937 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1938 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1942 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1943 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1945 epos
->block
= *eloc
;
1946 epos
->offset
= sizeof(struct allocExtDesc
);
1948 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
1949 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1951 udf_debug("reading block %d failed!\n", block
);
1959 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1960 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1965 struct short_ad
*sad
;
1966 struct long_ad
*lad
;
1967 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1971 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1972 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1973 udf_file_entry_alloc_offset(inode
) +
1975 alen
= udf_file_entry_alloc_offset(inode
) +
1979 epos
->offset
= sizeof(struct allocExtDesc
);
1980 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1981 alen
= sizeof(struct allocExtDesc
) +
1982 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1986 switch (iinfo
->i_alloc_type
) {
1987 case ICBTAG_FLAG_AD_SHORT
:
1988 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1991 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1992 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1993 eloc
->partitionReferenceNum
=
1994 iinfo
->i_location
.partitionReferenceNum
;
1995 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1997 case ICBTAG_FLAG_AD_LONG
:
1998 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
2001 etype
= le32_to_cpu(lad
->extLength
) >> 30;
2002 *eloc
= lelb_to_cpu(lad
->extLocation
);
2003 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2006 udf_debug("alloc_type = %d unsupported\n", iinfo
->i_alloc_type
);
2013 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
2014 struct kernel_lb_addr neloc
, uint32_t nelen
)
2016 struct kernel_lb_addr oeloc
;
2023 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2024 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2026 nelen
= (etype
<< 30) | oelen
;
2028 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2031 return (nelen
>> 30);
2034 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
2035 struct kernel_lb_addr eloc
, uint32_t elen
)
2037 struct extent_position oepos
;
2040 struct allocExtDesc
*aed
;
2041 struct udf_inode_info
*iinfo
;
2048 iinfo
= UDF_I(inode
);
2049 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2050 adsize
= sizeof(struct short_ad
);
2051 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2052 adsize
= sizeof(struct long_ad
);
2057 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2060 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2061 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2062 if (oepos
.bh
!= epos
.bh
) {
2063 oepos
.block
= epos
.block
;
2067 oepos
.offset
= epos
.offset
- adsize
;
2070 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2073 if (epos
.bh
!= oepos
.bh
) {
2074 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2075 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2076 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2078 iinfo
->i_lenAlloc
-= (adsize
* 2);
2079 mark_inode_dirty(inode
);
2081 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2082 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2083 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2084 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2085 udf_update_tag(oepos
.bh
->b_data
,
2086 oepos
.offset
- (2 * adsize
));
2088 udf_update_tag(oepos
.bh
->b_data
,
2089 sizeof(struct allocExtDesc
));
2090 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2093 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2095 iinfo
->i_lenAlloc
-= adsize
;
2096 mark_inode_dirty(inode
);
2098 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2099 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2100 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2101 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2102 udf_update_tag(oepos
.bh
->b_data
,
2103 epos
.offset
- adsize
);
2105 udf_update_tag(oepos
.bh
->b_data
,
2106 sizeof(struct allocExtDesc
));
2107 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2114 return (elen
>> 30);
2117 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2118 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2119 uint32_t *elen
, sector_t
*offset
)
2121 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2122 loff_t lbcount
= 0, bcount
=
2123 (loff_t
) block
<< blocksize_bits
;
2125 struct udf_inode_info
*iinfo
;
2127 iinfo
= UDF_I(inode
);
2129 pos
->block
= iinfo
->i_location
;
2134 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2136 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2137 iinfo
->i_lenExtents
= lbcount
;
2141 } while (lbcount
<= bcount
);
2143 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2148 long udf_block_map(struct inode
*inode
, sector_t block
)
2150 struct kernel_lb_addr eloc
;
2153 struct extent_position epos
= {};
2156 down_read(&UDF_I(inode
)->i_data_sem
);
2158 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2159 (EXT_RECORDED_ALLOCATED
>> 30))
2160 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2164 up_read(&UDF_I(inode
)->i_data_sem
);
2167 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2168 return udf_fixed_to_variable(ret
);