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>
44 MODULE_AUTHOR("Ben Fennema");
45 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
46 MODULE_LICENSE("GPL");
48 #define EXTENT_MERGE_SIZE 5
50 static mode_t
udf_convert_permissions(struct fileEntry
*);
51 static int udf_update_inode(struct inode
*, int);
52 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
53 static int udf_sync_inode(struct inode
*inode
);
54 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
55 static struct buffer_head
*inode_getblk(struct inode
*, sector_t
, 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 printk(KERN_WARNING
"UDF-fs (%s): Inode %lu (mode %o) has "
87 "inode size %llu different from extent length %llu. "
88 "Filesystem need not be standards compliant.\n",
89 inode
->i_sb
->s_id
, inode
->i_ino
, inode
->i_mode
,
90 (unsigned long long)inode
->i_size
,
91 (unsigned long long)iinfo
->i_lenExtents
);
93 kfree(iinfo
->i_ext
.i_data
);
94 iinfo
->i_ext
.i_data
= NULL
;
96 udf_free_inode(inode
);
100 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
102 return block_write_full_page(page
, udf_get_block
, wbc
);
105 static int udf_readpage(struct file
*file
, struct page
*page
)
107 return block_read_full_page(page
, udf_get_block
);
110 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
111 loff_t pos
, unsigned len
, unsigned flags
,
112 struct page
**pagep
, void **fsdata
)
116 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
118 struct inode
*inode
= mapping
->host
;
119 struct udf_inode_info
*iinfo
= UDF_I(inode
);
120 loff_t isize
= inode
->i_size
;
122 if (pos
+ len
> isize
) {
123 truncate_pagecache(inode
, pos
+ len
, isize
);
124 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
125 down_write(&iinfo
->i_data_sem
);
126 udf_truncate_extents(inode
);
127 up_write(&iinfo
->i_data_sem
);
135 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
137 return generic_block_bmap(mapping
, block
, udf_get_block
);
140 const struct address_space_operations udf_aops
= {
141 .readpage
= udf_readpage
,
142 .writepage
= udf_writepage
,
143 .sync_page
= block_sync_page
,
144 .write_begin
= udf_write_begin
,
145 .write_end
= generic_write_end
,
149 int udf_expand_file_adinicb(struct inode
*inode
)
153 struct udf_inode_info
*iinfo
= UDF_I(inode
);
155 struct writeback_control udf_wbc
= {
156 .sync_mode
= WB_SYNC_NONE
,
160 if (!iinfo
->i_lenAlloc
) {
161 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
162 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
164 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
165 /* from now on we have normal address_space methods */
166 inode
->i_data
.a_ops
= &udf_aops
;
167 mark_inode_dirty(inode
);
171 page
= find_or_create_page(inode
->i_mapping
, 0, GFP_NOFS
);
175 if (!PageUptodate(page
)) {
177 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
178 PAGE_CACHE_SIZE
- iinfo
->i_lenAlloc
);
179 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
181 flush_dcache_page(page
);
182 SetPageUptodate(page
);
185 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
187 iinfo
->i_lenAlloc
= 0;
188 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
189 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
191 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
192 /* from now on we have normal address_space methods */
193 inode
->i_data
.a_ops
= &udf_aops
;
194 err
= inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
196 /* Restore everything back so that we don't lose data... */
199 memcpy(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, kaddr
,
203 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
204 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
206 page_cache_release(page
);
207 mark_inode_dirty(inode
);
212 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
216 struct buffer_head
*dbh
= NULL
;
217 struct kernel_lb_addr eloc
;
219 struct extent_position epos
;
221 struct udf_fileident_bh sfibh
, dfibh
;
222 loff_t f_pos
= udf_ext0_offset(inode
);
223 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
224 struct fileIdentDesc cfi
, *sfi
, *dfi
;
225 struct udf_inode_info
*iinfo
= UDF_I(inode
);
227 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
228 alloctype
= ICBTAG_FLAG_AD_SHORT
;
230 alloctype
= ICBTAG_FLAG_AD_LONG
;
232 if (!inode
->i_size
) {
233 iinfo
->i_alloc_type
= alloctype
;
234 mark_inode_dirty(inode
);
238 /* alloc block, and copy data to it */
239 *block
= udf_new_block(inode
->i_sb
, inode
,
240 iinfo
->i_location
.partitionReferenceNum
,
241 iinfo
->i_location
.logicalBlockNum
, err
);
244 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
245 iinfo
->i_location
.partitionReferenceNum
,
249 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
253 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
254 set_buffer_uptodate(dbh
);
256 mark_buffer_dirty_inode(dbh
, inode
);
258 sfibh
.soffset
= sfibh
.eoffset
=
259 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
260 sfibh
.sbh
= sfibh
.ebh
= NULL
;
261 dfibh
.soffset
= dfibh
.eoffset
= 0;
262 dfibh
.sbh
= dfibh
.ebh
= dbh
;
263 while (f_pos
< size
) {
264 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
265 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
271 iinfo
->i_alloc_type
= alloctype
;
272 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
273 dfibh
.soffset
= dfibh
.eoffset
;
274 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
275 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
276 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
278 le16_to_cpu(sfi
->lengthOfImpUse
))) {
279 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
284 mark_buffer_dirty_inode(dbh
, inode
);
286 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
288 iinfo
->i_lenAlloc
= 0;
289 eloc
.logicalBlockNum
= *block
;
290 eloc
.partitionReferenceNum
=
291 iinfo
->i_location
.partitionReferenceNum
;
292 iinfo
->i_lenExtents
= inode
->i_size
;
294 epos
.block
= iinfo
->i_location
;
295 epos
.offset
= udf_file_entry_alloc_offset(inode
);
296 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
300 mark_inode_dirty(inode
);
304 static int udf_get_block(struct inode
*inode
, sector_t block
,
305 struct buffer_head
*bh_result
, int create
)
308 struct buffer_head
*bh
;
310 struct udf_inode_info
*iinfo
;
313 phys
= udf_block_map(inode
, block
);
315 map_bh(bh_result
, inode
->i_sb
, phys
);
322 iinfo
= UDF_I(inode
);
324 down_write(&iinfo
->i_data_sem
);
325 if (block
== iinfo
->i_next_alloc_block
+ 1) {
326 iinfo
->i_next_alloc_block
++;
327 iinfo
->i_next_alloc_goal
++;
332 bh
= inode_getblk(inode
, block
, &err
, &phys
, &new);
339 set_buffer_new(bh_result
);
340 map_bh(bh_result
, inode
->i_sb
, phys
);
343 up_write(&iinfo
->i_data_sem
);
347 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
348 int create
, int *err
)
350 struct buffer_head
*bh
;
351 struct buffer_head dummy
;
354 dummy
.b_blocknr
= -1000;
355 *err
= udf_get_block(inode
, block
, &dummy
, create
);
356 if (!*err
&& buffer_mapped(&dummy
)) {
357 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
358 if (buffer_new(&dummy
)) {
360 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
361 set_buffer_uptodate(bh
);
363 mark_buffer_dirty_inode(bh
, inode
);
371 /* Extend the file by 'blocks' blocks, return the number of extents added */
372 static int udf_do_extend_file(struct inode
*inode
,
373 struct extent_position
*last_pos
,
374 struct kernel_long_ad
*last_ext
,
378 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
379 struct super_block
*sb
= inode
->i_sb
;
380 struct kernel_lb_addr prealloc_loc
= {};
381 int prealloc_len
= 0;
382 struct udf_inode_info
*iinfo
;
385 /* The previous extent is fake and we should not extend by anything
386 * - there's nothing to do... */
390 iinfo
= UDF_I(inode
);
391 /* Round the last extent up to a multiple of block size */
392 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
393 last_ext
->extLength
=
394 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
395 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
396 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
397 iinfo
->i_lenExtents
=
398 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
399 ~(sb
->s_blocksize
- 1);
402 /* Last extent are just preallocated blocks? */
403 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
404 EXT_NOT_RECORDED_ALLOCATED
) {
405 /* Save the extent so that we can reattach it to the end */
406 prealloc_loc
= last_ext
->extLocation
;
407 prealloc_len
= last_ext
->extLength
;
408 /* Mark the extent as a hole */
409 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
410 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
411 last_ext
->extLocation
.logicalBlockNum
= 0;
412 last_ext
->extLocation
.partitionReferenceNum
= 0;
415 /* Can we merge with the previous extent? */
416 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
417 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
418 add
= ((1 << 30) - sb
->s_blocksize
-
419 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
420 sb
->s_blocksize_bits
;
424 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
428 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
429 last_ext
->extLength
, 1);
432 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
433 last_ext
->extLength
, 1);
435 /* Managed to do everything necessary? */
439 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
440 last_ext
->extLocation
.logicalBlockNum
= 0;
441 last_ext
->extLocation
.partitionReferenceNum
= 0;
442 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
443 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
444 (add
<< sb
->s_blocksize_bits
);
446 /* Create enough extents to cover the whole hole */
447 while (blocks
> add
) {
449 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
450 last_ext
->extLength
, 1);
456 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
457 (blocks
<< sb
->s_blocksize_bits
);
458 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
459 last_ext
->extLength
, 1);
466 /* Do we have some preallocated blocks saved? */
468 err
= udf_add_aext(inode
, last_pos
, &prealloc_loc
,
472 last_ext
->extLocation
= prealloc_loc
;
473 last_ext
->extLength
= prealloc_len
;
477 /* last_pos should point to the last written extent... */
478 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
479 last_pos
->offset
-= sizeof(struct short_ad
);
480 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
481 last_pos
->offset
-= sizeof(struct long_ad
);
488 static int udf_extend_file(struct inode
*inode
, loff_t newsize
)
491 struct extent_position epos
;
492 struct kernel_lb_addr eloc
;
495 struct super_block
*sb
= inode
->i_sb
;
496 sector_t first_block
= newsize
>> sb
->s_blocksize_bits
, offset
;
498 struct udf_inode_info
*iinfo
= UDF_I(inode
);
499 struct kernel_long_ad extent
;
502 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
503 adsize
= sizeof(struct short_ad
);
504 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
505 adsize
= sizeof(struct long_ad
);
509 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
511 /* File has extent covering the new size (could happen when extending
512 * inside a block)? */
515 if (newsize
& (sb
->s_blocksize
- 1))
517 /* Extended file just to the boundary of the last file block? */
521 /* Truncate is extending the file by 'offset' blocks */
522 if ((!epos
.bh
&& epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
523 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
524 /* File has no extents at all or has empty last
525 * indirect extent! Create a fake extent... */
526 extent
.extLocation
.logicalBlockNum
= 0;
527 extent
.extLocation
.partitionReferenceNum
= 0;
528 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
530 epos
.offset
-= adsize
;
531 etype
= udf_next_aext(inode
, &epos
, &extent
.extLocation
,
532 &extent
.extLength
, 0);
533 extent
.extLength
|= etype
<< 30;
535 err
= udf_do_extend_file(inode
, &epos
, &extent
, offset
);
539 iinfo
->i_lenExtents
= newsize
;
545 static struct buffer_head
*inode_getblk(struct inode
*inode
, sector_t block
,
546 int *err
, sector_t
*phys
, int *new)
548 static sector_t last_block
;
549 struct buffer_head
*result
= NULL
;
550 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
551 struct extent_position prev_epos
, cur_epos
, next_epos
;
552 int count
= 0, startnum
= 0, endnum
= 0;
553 uint32_t elen
= 0, tmpelen
;
554 struct kernel_lb_addr eloc
, tmpeloc
;
556 loff_t lbcount
= 0, b_off
= 0;
557 uint32_t newblocknum
, newblock
;
560 struct udf_inode_info
*iinfo
= UDF_I(inode
);
561 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
564 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
565 prev_epos
.block
= iinfo
->i_location
;
567 cur_epos
= next_epos
= prev_epos
;
568 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
570 /* find the extent which contains the block we are looking for.
571 alternate between laarr[0] and laarr[1] for locations of the
572 current extent, and the previous extent */
574 if (prev_epos
.bh
!= cur_epos
.bh
) {
575 brelse(prev_epos
.bh
);
577 prev_epos
.bh
= cur_epos
.bh
;
579 if (cur_epos
.bh
!= next_epos
.bh
) {
581 get_bh(next_epos
.bh
);
582 cur_epos
.bh
= next_epos
.bh
;
587 prev_epos
.block
= cur_epos
.block
;
588 cur_epos
.block
= next_epos
.block
;
590 prev_epos
.offset
= cur_epos
.offset
;
591 cur_epos
.offset
= next_epos
.offset
;
593 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
599 laarr
[c
].extLength
= (etype
<< 30) | elen
;
600 laarr
[c
].extLocation
= eloc
;
602 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
603 pgoal
= eloc
.logicalBlockNum
+
604 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
605 inode
->i_sb
->s_blocksize_bits
);
608 } while (lbcount
+ elen
<= b_off
);
611 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
613 * Move prev_epos and cur_epos into indirect extent if we are at
616 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
617 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
619 /* if the extent is allocated and recorded, return the block
620 if the extent is not a multiple of the blocksize, round up */
622 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
623 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
624 elen
= EXT_RECORDED_ALLOCATED
|
625 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
626 ~(inode
->i_sb
->s_blocksize
- 1));
627 udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
629 brelse(prev_epos
.bh
);
631 brelse(next_epos
.bh
);
632 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
638 /* Are we beyond EOF? */
647 /* Create a fake extent when there's not one */
648 memset(&laarr
[0].extLocation
, 0x00,
649 sizeof(struct kernel_lb_addr
));
650 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
651 /* Will udf_do_extend_file() create real extent from
653 startnum
= (offset
> 0);
655 /* Create extents for the hole between EOF and offset */
656 ret
= udf_do_extend_file(inode
, &prev_epos
, laarr
, offset
);
658 brelse(prev_epos
.bh
);
660 brelse(next_epos
.bh
);
667 /* We are not covered by a preallocated extent? */
668 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
669 EXT_NOT_RECORDED_ALLOCATED
) {
670 /* Is there any real extent? - otherwise we overwrite
674 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
675 inode
->i_sb
->s_blocksize
;
676 memset(&laarr
[c
].extLocation
, 0x00,
677 sizeof(struct kernel_lb_addr
));
684 endnum
= startnum
= ((count
> 2) ? 2 : count
);
686 /* if the current extent is in position 0,
687 swap it with the previous */
688 if (!c
&& count
!= 1) {
695 /* if the current block is located in an extent,
696 read the next extent */
697 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
699 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
700 laarr
[c
+ 1].extLocation
= eloc
;
708 /* if the current extent is not recorded but allocated, get the
709 * block in the extent corresponding to the requested block */
710 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
711 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
712 else { /* otherwise, allocate a new block */
713 if (iinfo
->i_next_alloc_block
== block
)
714 goal
= iinfo
->i_next_alloc_goal
;
717 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
718 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
721 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
722 iinfo
->i_location
.partitionReferenceNum
,
725 brelse(prev_epos
.bh
);
729 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
732 /* if the extent the requsted block is located in contains multiple
733 * blocks, split the extent into at most three extents. blocks prior
734 * to requested block, requested block, and blocks after requested
736 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
738 #ifdef UDF_PREALLOCATE
739 /* We preallocate blocks only for regular files. It also makes sense
740 * for directories but there's a problem when to drop the
741 * preallocation. We might use some delayed work for that but I feel
742 * it's overengineering for a filesystem like UDF. */
743 if (S_ISREG(inode
->i_mode
))
744 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
747 /* merge any continuous blocks in laarr */
748 udf_merge_extents(inode
, laarr
, &endnum
);
750 /* write back the new extents, inserting new extents if the new number
751 * of extents is greater than the old number, and deleting extents if
752 * the new number of extents is less than the old number */
753 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
755 brelse(prev_epos
.bh
);
757 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
758 iinfo
->i_location
.partitionReferenceNum
, 0);
764 iinfo
->i_next_alloc_block
= block
;
765 iinfo
->i_next_alloc_goal
= newblocknum
;
766 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
769 udf_sync_inode(inode
);
771 mark_inode_dirty(inode
);
776 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
778 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
781 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
782 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
784 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
785 (laarr
[*c
].extLength
>> 30) ==
786 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
788 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
789 blocksize
- 1) >> blocksize_bits
;
790 int8_t etype
= (laarr
[curr
].extLength
>> 30);
794 else if (!offset
|| blen
== offset
+ 1) {
795 laarr
[curr
+ 2] = laarr
[curr
+ 1];
796 laarr
[curr
+ 1] = laarr
[curr
];
798 laarr
[curr
+ 3] = laarr
[curr
+ 1];
799 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
803 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
804 udf_free_blocks(inode
->i_sb
, inode
,
805 &laarr
[curr
].extLocation
,
807 laarr
[curr
].extLength
=
808 EXT_NOT_RECORDED_NOT_ALLOCATED
|
809 (offset
<< blocksize_bits
);
810 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
811 laarr
[curr
].extLocation
.
812 partitionReferenceNum
= 0;
814 laarr
[curr
].extLength
= (etype
<< 30) |
815 (offset
<< blocksize_bits
);
821 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
822 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
823 laarr
[curr
].extLocation
.partitionReferenceNum
=
824 UDF_I(inode
)->i_location
.partitionReferenceNum
;
825 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
829 if (blen
!= offset
+ 1) {
830 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
831 laarr
[curr
].extLocation
.logicalBlockNum
+=
833 laarr
[curr
].extLength
= (etype
<< 30) |
834 ((blen
- (offset
+ 1)) << blocksize_bits
);
841 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
842 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
845 int start
, length
= 0, currlength
= 0, i
;
847 if (*endnum
>= (c
+ 1)) {
853 if ((laarr
[c
+ 1].extLength
>> 30) ==
854 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
856 length
= currlength
=
857 (((laarr
[c
+ 1].extLength
&
858 UDF_EXTENT_LENGTH_MASK
) +
859 inode
->i_sb
->s_blocksize
- 1) >>
860 inode
->i_sb
->s_blocksize_bits
);
865 for (i
= start
+ 1; i
<= *endnum
; i
++) {
868 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
869 } else if ((laarr
[i
].extLength
>> 30) ==
870 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
871 length
+= (((laarr
[i
].extLength
&
872 UDF_EXTENT_LENGTH_MASK
) +
873 inode
->i_sb
->s_blocksize
- 1) >>
874 inode
->i_sb
->s_blocksize_bits
);
880 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
881 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
882 inode
->i_sb
->s_blocksize
- 1) >>
883 inode
->i_sb
->s_blocksize_bits
);
884 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
885 laarr
[start
].extLocation
.partitionReferenceNum
,
886 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
887 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
890 if (start
== (c
+ 1))
891 laarr
[start
].extLength
+=
893 inode
->i_sb
->s_blocksize_bits
);
895 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
896 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
898 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
899 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
900 laarr
[c
].extLocation
.
901 partitionReferenceNum
;
902 laarr
[c
+ 1].extLength
=
903 EXT_NOT_RECORDED_ALLOCATED
|
905 inode
->i_sb
->s_blocksize_bits
);
909 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
910 int elen
= ((laarr
[i
].extLength
&
911 UDF_EXTENT_LENGTH_MASK
) +
912 inode
->i_sb
->s_blocksize
- 1) >>
913 inode
->i_sb
->s_blocksize_bits
;
915 if (elen
> numalloc
) {
916 laarr
[i
].extLength
-=
918 inode
->i_sb
->s_blocksize_bits
);
922 if (*endnum
> (i
+ 1))
925 sizeof(struct long_ad
) *
926 (*endnum
- (i
+ 1)));
931 UDF_I(inode
)->i_lenExtents
+=
932 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
937 static void udf_merge_extents(struct inode
*inode
,
938 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
942 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
943 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
945 for (i
= 0; i
< (*endnum
- 1); i
++) {
946 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
947 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
949 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
950 (((li
->extLength
>> 30) ==
951 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
952 ((lip1
->extLocation
.logicalBlockNum
-
953 li
->extLocation
.logicalBlockNum
) ==
954 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
955 blocksize
- 1) >> blocksize_bits
)))) {
957 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
958 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
959 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
960 lip1
->extLength
= (lip1
->extLength
-
962 UDF_EXTENT_LENGTH_MASK
) +
963 UDF_EXTENT_LENGTH_MASK
) &
965 li
->extLength
= (li
->extLength
&
966 UDF_EXTENT_FLAG_MASK
) +
967 (UDF_EXTENT_LENGTH_MASK
+ 1) -
969 lip1
->extLocation
.logicalBlockNum
=
970 li
->extLocation
.logicalBlockNum
+
972 UDF_EXTENT_LENGTH_MASK
) >>
975 li
->extLength
= lip1
->extLength
+
977 UDF_EXTENT_LENGTH_MASK
) +
978 blocksize
- 1) & ~(blocksize
- 1));
979 if (*endnum
> (i
+ 2))
980 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
981 sizeof(struct long_ad
) *
982 (*endnum
- (i
+ 2)));
986 } else if (((li
->extLength
>> 30) ==
987 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
988 ((lip1
->extLength
>> 30) ==
989 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
990 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
992 UDF_EXTENT_LENGTH_MASK
) +
993 blocksize
- 1) >> blocksize_bits
);
994 li
->extLocation
.logicalBlockNum
= 0;
995 li
->extLocation
.partitionReferenceNum
= 0;
997 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
998 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
999 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1000 lip1
->extLength
= (lip1
->extLength
-
1002 UDF_EXTENT_LENGTH_MASK
) +
1003 UDF_EXTENT_LENGTH_MASK
) &
1005 li
->extLength
= (li
->extLength
&
1006 UDF_EXTENT_FLAG_MASK
) +
1007 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1010 li
->extLength
= lip1
->extLength
+
1012 UDF_EXTENT_LENGTH_MASK
) +
1013 blocksize
- 1) & ~(blocksize
- 1));
1014 if (*endnum
> (i
+ 2))
1015 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1016 sizeof(struct long_ad
) *
1017 (*endnum
- (i
+ 2)));
1021 } else if ((li
->extLength
>> 30) ==
1022 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
1023 udf_free_blocks(inode
->i_sb
, inode
,
1024 &li
->extLocation
, 0,
1026 UDF_EXTENT_LENGTH_MASK
) +
1027 blocksize
- 1) >> blocksize_bits
);
1028 li
->extLocation
.logicalBlockNum
= 0;
1029 li
->extLocation
.partitionReferenceNum
= 0;
1030 li
->extLength
= (li
->extLength
&
1031 UDF_EXTENT_LENGTH_MASK
) |
1032 EXT_NOT_RECORDED_NOT_ALLOCATED
;
1037 static void udf_update_extents(struct inode
*inode
,
1038 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
1039 int startnum
, int endnum
,
1040 struct extent_position
*epos
)
1043 struct kernel_lb_addr tmploc
;
1046 if (startnum
> endnum
) {
1047 for (i
= 0; i
< (startnum
- endnum
); i
++)
1048 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
1049 laarr
[i
].extLength
);
1050 } else if (startnum
< endnum
) {
1051 for (i
= 0; i
< (endnum
- startnum
); i
++) {
1052 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
1053 laarr
[i
].extLength
);
1054 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
1055 &laarr
[i
].extLength
, 1);
1060 for (i
= start
; i
< endnum
; i
++) {
1061 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
1062 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
1063 laarr
[i
].extLength
, 1);
1067 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
1068 int create
, int *err
)
1070 struct buffer_head
*bh
= NULL
;
1072 bh
= udf_getblk(inode
, block
, create
, err
);
1076 if (buffer_uptodate(bh
))
1079 ll_rw_block(READ
, 1, &bh
);
1082 if (buffer_uptodate(bh
))
1090 int udf_setsize(struct inode
*inode
, loff_t newsize
)
1093 struct udf_inode_info
*iinfo
;
1094 int bsize
= 1 << inode
->i_blkbits
;
1096 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1097 S_ISLNK(inode
->i_mode
)))
1099 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1102 iinfo
= UDF_I(inode
);
1103 if (newsize
> inode
->i_size
) {
1104 down_write(&iinfo
->i_data_sem
);
1105 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1107 (udf_file_entry_alloc_offset(inode
) + newsize
)) {
1108 err
= udf_expand_file_adinicb(inode
);
1110 up_write(&iinfo
->i_data_sem
);
1114 iinfo
->i_lenAlloc
= newsize
;
1116 err
= udf_extend_file(inode
, newsize
);
1118 up_write(&iinfo
->i_data_sem
);
1121 truncate_setsize(inode
, newsize
);
1122 up_write(&iinfo
->i_data_sem
);
1124 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1125 down_write(&iinfo
->i_data_sem
);
1126 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1127 0x00, bsize
- newsize
-
1128 udf_file_entry_alloc_offset(inode
));
1129 iinfo
->i_lenAlloc
= newsize
;
1130 truncate_setsize(inode
, newsize
);
1131 up_write(&iinfo
->i_data_sem
);
1134 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1138 down_write(&iinfo
->i_data_sem
);
1139 truncate_setsize(inode
, newsize
);
1140 udf_truncate_extents(inode
);
1141 up_write(&iinfo
->i_data_sem
);
1144 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1146 udf_sync_inode(inode
);
1148 mark_inode_dirty(inode
);
1152 static void __udf_read_inode(struct inode
*inode
)
1154 struct buffer_head
*bh
= NULL
;
1155 struct fileEntry
*fe
;
1157 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1160 * Set defaults, but the inode is still incomplete!
1161 * Note: get_new_inode() sets the following on a new inode:
1164 * i_flags = sb->s_flags
1166 * clean_inode(): zero fills and sets
1171 bh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 0, &ident
);
1173 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) failed !bh\n",
1175 make_bad_inode(inode
);
1179 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1180 ident
!= TAG_IDENT_USE
) {
1181 printk(KERN_ERR
"udf: udf_read_inode(ino %ld) "
1182 "failed ident=%d\n", inode
->i_ino
, ident
);
1184 make_bad_inode(inode
);
1188 fe
= (struct fileEntry
*)bh
->b_data
;
1190 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1191 struct buffer_head
*ibh
;
1193 ibh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 1,
1195 if (ident
== TAG_IDENT_IE
&& ibh
) {
1196 struct buffer_head
*nbh
= NULL
;
1197 struct kernel_lb_addr loc
;
1198 struct indirectEntry
*ie
;
1200 ie
= (struct indirectEntry
*)ibh
->b_data
;
1201 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1203 if (ie
->indirectICB
.extLength
&&
1204 (nbh
= udf_read_ptagged(inode
->i_sb
, &loc
, 0,
1206 if (ident
== TAG_IDENT_FE
||
1207 ident
== TAG_IDENT_EFE
) {
1208 memcpy(&iinfo
->i_location
,
1210 sizeof(struct kernel_lb_addr
));
1214 __udf_read_inode(inode
);
1221 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1222 printk(KERN_ERR
"udf: unsupported strategy type: %d\n",
1223 le16_to_cpu(fe
->icbTag
.strategyType
));
1225 make_bad_inode(inode
);
1228 udf_fill_inode(inode
, bh
);
1233 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1235 struct fileEntry
*fe
;
1236 struct extendedFileEntry
*efe
;
1238 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1239 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1241 fe
= (struct fileEntry
*)bh
->b_data
;
1242 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1244 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1245 iinfo
->i_strat4096
= 0;
1246 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1247 iinfo
->i_strat4096
= 1;
1249 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1250 ICBTAG_FLAG_AD_MASK
;
1251 iinfo
->i_unique
= 0;
1252 iinfo
->i_lenEAttr
= 0;
1253 iinfo
->i_lenExtents
= 0;
1254 iinfo
->i_lenAlloc
= 0;
1255 iinfo
->i_next_alloc_block
= 0;
1256 iinfo
->i_next_alloc_goal
= 0;
1257 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1260 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1261 sizeof(struct extendedFileEntry
))) {
1262 make_bad_inode(inode
);
1265 memcpy(iinfo
->i_ext
.i_data
,
1266 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1267 inode
->i_sb
->s_blocksize
-
1268 sizeof(struct extendedFileEntry
));
1269 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1272 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1273 sizeof(struct fileEntry
))) {
1274 make_bad_inode(inode
);
1277 memcpy(iinfo
->i_ext
.i_data
,
1278 bh
->b_data
+ sizeof(struct fileEntry
),
1279 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1280 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1283 iinfo
->i_lenAlloc
= le32_to_cpu(
1284 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1286 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1287 sizeof(struct unallocSpaceEntry
))) {
1288 make_bad_inode(inode
);
1291 memcpy(iinfo
->i_ext
.i_data
,
1292 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1293 inode
->i_sb
->s_blocksize
-
1294 sizeof(struct unallocSpaceEntry
));
1298 read_lock(&sbi
->s_cred_lock
);
1299 inode
->i_uid
= le32_to_cpu(fe
->uid
);
1300 if (inode
->i_uid
== -1 ||
1301 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1302 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1303 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1305 inode
->i_gid
= le32_to_cpu(fe
->gid
);
1306 if (inode
->i_gid
== -1 ||
1307 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1308 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1309 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1311 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1312 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1313 inode
->i_mode
= sbi
->s_fmode
;
1314 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1315 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1316 inode
->i_mode
= sbi
->s_dmode
;
1318 inode
->i_mode
= udf_convert_permissions(fe
);
1319 inode
->i_mode
&= ~sbi
->s_umask
;
1320 read_unlock(&sbi
->s_cred_lock
);
1322 inode
->i_nlink
= le16_to_cpu(fe
->fileLinkCount
);
1323 if (!inode
->i_nlink
)
1326 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1327 iinfo
->i_lenExtents
= inode
->i_size
;
1329 if (iinfo
->i_efe
== 0) {
1330 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1331 (inode
->i_sb
->s_blocksize_bits
- 9);
1333 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1334 inode
->i_atime
= sbi
->s_record_time
;
1336 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1337 fe
->modificationTime
))
1338 inode
->i_mtime
= sbi
->s_record_time
;
1340 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1341 inode
->i_ctime
= sbi
->s_record_time
;
1343 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1344 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1345 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1346 offset
= sizeof(struct fileEntry
) + iinfo
->i_lenEAttr
;
1348 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1349 (inode
->i_sb
->s_blocksize_bits
- 9);
1351 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1352 inode
->i_atime
= sbi
->s_record_time
;
1354 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1355 efe
->modificationTime
))
1356 inode
->i_mtime
= sbi
->s_record_time
;
1358 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1359 iinfo
->i_crtime
= sbi
->s_record_time
;
1361 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1362 inode
->i_ctime
= sbi
->s_record_time
;
1364 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1365 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1366 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1367 offset
= sizeof(struct extendedFileEntry
) +
1371 switch (fe
->icbTag
.fileType
) {
1372 case ICBTAG_FILE_TYPE_DIRECTORY
:
1373 inode
->i_op
= &udf_dir_inode_operations
;
1374 inode
->i_fop
= &udf_dir_operations
;
1375 inode
->i_mode
|= S_IFDIR
;
1378 case ICBTAG_FILE_TYPE_REALTIME
:
1379 case ICBTAG_FILE_TYPE_REGULAR
:
1380 case ICBTAG_FILE_TYPE_UNDEF
:
1381 case ICBTAG_FILE_TYPE_VAT20
:
1382 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1383 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1385 inode
->i_data
.a_ops
= &udf_aops
;
1386 inode
->i_op
= &udf_file_inode_operations
;
1387 inode
->i_fop
= &udf_file_operations
;
1388 inode
->i_mode
|= S_IFREG
;
1390 case ICBTAG_FILE_TYPE_BLOCK
:
1391 inode
->i_mode
|= S_IFBLK
;
1393 case ICBTAG_FILE_TYPE_CHAR
:
1394 inode
->i_mode
|= S_IFCHR
;
1396 case ICBTAG_FILE_TYPE_FIFO
:
1397 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1399 case ICBTAG_FILE_TYPE_SOCKET
:
1400 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1402 case ICBTAG_FILE_TYPE_SYMLINK
:
1403 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1404 inode
->i_op
= &udf_symlink_inode_operations
;
1405 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1407 case ICBTAG_FILE_TYPE_MAIN
:
1408 udf_debug("METADATA FILE-----\n");
1410 case ICBTAG_FILE_TYPE_MIRROR
:
1411 udf_debug("METADATA MIRROR FILE-----\n");
1413 case ICBTAG_FILE_TYPE_BITMAP
:
1414 udf_debug("METADATA BITMAP FILE-----\n");
1417 printk(KERN_ERR
"udf: udf_fill_inode(ino %ld) failed unknown "
1418 "file type=%d\n", inode
->i_ino
,
1419 fe
->icbTag
.fileType
);
1420 make_bad_inode(inode
);
1423 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1424 struct deviceSpec
*dsea
=
1425 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1427 init_special_inode(inode
, inode
->i_mode
,
1428 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1429 le32_to_cpu(dsea
->minorDeviceIdent
)));
1430 /* Developer ID ??? */
1432 make_bad_inode(inode
);
1436 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1438 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1439 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1441 if (!iinfo
->i_ext
.i_data
) {
1442 printk(KERN_ERR
"udf:udf_alloc_i_data (ino %ld) "
1443 "no free memory\n", inode
->i_ino
);
1450 static mode_t
udf_convert_permissions(struct fileEntry
*fe
)
1453 uint32_t permissions
;
1456 permissions
= le32_to_cpu(fe
->permissions
);
1457 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1459 mode
= ((permissions
) & S_IRWXO
) |
1460 ((permissions
>> 2) & S_IRWXG
) |
1461 ((permissions
>> 4) & S_IRWXU
) |
1462 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1463 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1464 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1469 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1471 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1474 static int udf_sync_inode(struct inode
*inode
)
1476 return udf_update_inode(inode
, 1);
1479 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1481 struct buffer_head
*bh
= NULL
;
1482 struct fileEntry
*fe
;
1483 struct extendedFileEntry
*efe
;
1488 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1489 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1490 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1492 bh
= udf_tgetblk(inode
->i_sb
,
1493 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1495 udf_debug("getblk failure\n");
1500 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1501 fe
= (struct fileEntry
*)bh
->b_data
;
1502 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1505 struct unallocSpaceEntry
*use
=
1506 (struct unallocSpaceEntry
*)bh
->b_data
;
1508 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1509 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1510 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1511 sizeof(struct unallocSpaceEntry
));
1512 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1513 use
->descTag
.tagLocation
=
1514 cpu_to_le32(iinfo
->i_location
.logicalBlockNum
);
1515 crclen
= sizeof(struct unallocSpaceEntry
) +
1516 iinfo
->i_lenAlloc
- sizeof(struct tag
);
1517 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1518 use
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)use
+
1521 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1526 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1527 fe
->uid
= cpu_to_le32(-1);
1529 fe
->uid
= cpu_to_le32(inode
->i_uid
);
1531 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1532 fe
->gid
= cpu_to_le32(-1);
1534 fe
->gid
= cpu_to_le32(inode
->i_gid
);
1536 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1537 ((inode
->i_mode
& S_IRWXG
) << 2) |
1538 ((inode
->i_mode
& S_IRWXU
) << 4);
1540 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1541 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1542 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1543 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1544 fe
->permissions
= cpu_to_le32(udfperms
);
1546 if (S_ISDIR(inode
->i_mode
))
1547 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1549 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1551 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1553 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1555 struct deviceSpec
*dsea
=
1556 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1558 dsea
= (struct deviceSpec
*)
1559 udf_add_extendedattr(inode
,
1560 sizeof(struct deviceSpec
) +
1561 sizeof(struct regid
), 12, 0x3);
1562 dsea
->attrType
= cpu_to_le32(12);
1563 dsea
->attrSubtype
= 1;
1564 dsea
->attrLength
= cpu_to_le32(
1565 sizeof(struct deviceSpec
) +
1566 sizeof(struct regid
));
1567 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1569 eid
= (struct regid
*)dsea
->impUse
;
1570 memset(eid
, 0, sizeof(struct regid
));
1571 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1572 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1573 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1574 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1575 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1578 if (iinfo
->i_efe
== 0) {
1579 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1580 iinfo
->i_ext
.i_data
,
1581 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1582 fe
->logicalBlocksRecorded
= cpu_to_le64(
1583 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1584 (blocksize_bits
- 9));
1586 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1587 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1588 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1589 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1590 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1591 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1592 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1593 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1594 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1595 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1596 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1597 crclen
= sizeof(struct fileEntry
);
1599 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1600 iinfo
->i_ext
.i_data
,
1601 inode
->i_sb
->s_blocksize
-
1602 sizeof(struct extendedFileEntry
));
1603 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1604 efe
->logicalBlocksRecorded
= cpu_to_le64(
1605 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1606 (blocksize_bits
- 9));
1608 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1609 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1610 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1611 iinfo
->i_crtime
= inode
->i_atime
;
1613 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1614 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1615 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1616 iinfo
->i_crtime
= inode
->i_mtime
;
1618 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1619 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1620 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1621 iinfo
->i_crtime
= inode
->i_ctime
;
1623 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1624 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1625 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1626 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1628 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1629 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1630 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1631 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1632 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1633 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1634 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1635 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1636 crclen
= sizeof(struct extendedFileEntry
);
1638 if (iinfo
->i_strat4096
) {
1639 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1640 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1641 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1643 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1644 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1647 if (S_ISDIR(inode
->i_mode
))
1648 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1649 else if (S_ISREG(inode
->i_mode
))
1650 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1651 else if (S_ISLNK(inode
->i_mode
))
1652 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1653 else if (S_ISBLK(inode
->i_mode
))
1654 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1655 else if (S_ISCHR(inode
->i_mode
))
1656 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1657 else if (S_ISFIFO(inode
->i_mode
))
1658 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1659 else if (S_ISSOCK(inode
->i_mode
))
1660 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1662 icbflags
= iinfo
->i_alloc_type
|
1663 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1664 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1665 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1666 (le16_to_cpu(fe
->icbTag
.flags
) &
1667 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1668 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1670 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1671 if (sbi
->s_udfrev
>= 0x0200)
1672 fe
->descTag
.descVersion
= cpu_to_le16(3);
1674 fe
->descTag
.descVersion
= cpu_to_le16(2);
1675 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1676 fe
->descTag
.tagLocation
= cpu_to_le32(
1677 iinfo
->i_location
.logicalBlockNum
);
1678 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1679 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1680 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1682 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1685 set_buffer_uptodate(bh
);
1688 /* write the data blocks */
1689 mark_buffer_dirty(bh
);
1691 sync_dirty_buffer(bh
);
1692 if (buffer_write_io_error(bh
)) {
1693 printk(KERN_WARNING
"IO error syncing udf inode "
1694 "[%s:%08lx]\n", inode
->i_sb
->s_id
,
1704 struct inode
*udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
)
1706 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1707 struct inode
*inode
= iget_locked(sb
, block
);
1712 if (inode
->i_state
& I_NEW
) {
1713 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1714 __udf_read_inode(inode
);
1715 unlock_new_inode(inode
);
1718 if (is_bad_inode(inode
))
1721 if (ino
->logicalBlockNum
>= UDF_SB(sb
)->
1722 s_partmaps
[ino
->partitionReferenceNum
].s_partition_len
) {
1723 udf_debug("block=%d, partition=%d out of range\n",
1724 ino
->logicalBlockNum
, ino
->partitionReferenceNum
);
1725 make_bad_inode(inode
);
1736 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1737 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1740 struct short_ad
*sad
= NULL
;
1741 struct long_ad
*lad
= NULL
;
1742 struct allocExtDesc
*aed
;
1744 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1747 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1748 udf_file_entry_alloc_offset(inode
) +
1751 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1753 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1754 adsize
= sizeof(struct short_ad
);
1755 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1756 adsize
= sizeof(struct long_ad
);
1760 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1761 unsigned char *sptr
, *dptr
;
1762 struct buffer_head
*nbh
;
1764 struct kernel_lb_addr obloc
= epos
->block
;
1766 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1767 obloc
.partitionReferenceNum
,
1768 obloc
.logicalBlockNum
, &err
);
1769 if (!epos
->block
.logicalBlockNum
)
1771 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1777 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1778 set_buffer_uptodate(nbh
);
1780 mark_buffer_dirty_inode(nbh
, inode
);
1782 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1783 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1784 aed
->previousAllocExtLocation
=
1785 cpu_to_le32(obloc
.logicalBlockNum
);
1786 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1787 loffset
= epos
->offset
;
1788 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1789 sptr
= ptr
- adsize
;
1790 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1791 memcpy(dptr
, sptr
, adsize
);
1792 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1794 loffset
= epos
->offset
+ adsize
;
1795 aed
->lengthAllocDescs
= cpu_to_le32(0);
1797 epos
->offset
= sizeof(struct allocExtDesc
);
1800 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1801 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1803 iinfo
->i_lenAlloc
+= adsize
;
1804 mark_inode_dirty(inode
);
1807 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1808 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1809 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1811 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1812 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1813 switch (iinfo
->i_alloc_type
) {
1814 case ICBTAG_FLAG_AD_SHORT
:
1815 sad
= (struct short_ad
*)sptr
;
1816 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1817 inode
->i_sb
->s_blocksize
);
1819 cpu_to_le32(epos
->block
.logicalBlockNum
);
1821 case ICBTAG_FLAG_AD_LONG
:
1822 lad
= (struct long_ad
*)sptr
;
1823 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1824 inode
->i_sb
->s_blocksize
);
1825 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1826 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1830 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1831 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1832 udf_update_tag(epos
->bh
->b_data
, loffset
);
1834 udf_update_tag(epos
->bh
->b_data
,
1835 sizeof(struct allocExtDesc
));
1836 mark_buffer_dirty_inode(epos
->bh
, inode
);
1839 mark_inode_dirty(inode
);
1844 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1847 iinfo
->i_lenAlloc
+= adsize
;
1848 mark_inode_dirty(inode
);
1850 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1851 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1852 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1853 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1854 udf_update_tag(epos
->bh
->b_data
,
1855 epos
->offset
+ (inc
? 0 : adsize
));
1857 udf_update_tag(epos
->bh
->b_data
,
1858 sizeof(struct allocExtDesc
));
1859 mark_buffer_dirty_inode(epos
->bh
, inode
);
1865 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1866 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1870 struct short_ad
*sad
;
1871 struct long_ad
*lad
;
1872 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1875 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1876 udf_file_entry_alloc_offset(inode
) +
1879 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1881 switch (iinfo
->i_alloc_type
) {
1882 case ICBTAG_FLAG_AD_SHORT
:
1883 sad
= (struct short_ad
*)ptr
;
1884 sad
->extLength
= cpu_to_le32(elen
);
1885 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
1886 adsize
= sizeof(struct short_ad
);
1888 case ICBTAG_FLAG_AD_LONG
:
1889 lad
= (struct long_ad
*)ptr
;
1890 lad
->extLength
= cpu_to_le32(elen
);
1891 lad
->extLocation
= cpu_to_lelb(*eloc
);
1892 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1893 adsize
= sizeof(struct long_ad
);
1900 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1901 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
1902 struct allocExtDesc
*aed
=
1903 (struct allocExtDesc
*)epos
->bh
->b_data
;
1904 udf_update_tag(epos
->bh
->b_data
,
1905 le32_to_cpu(aed
->lengthAllocDescs
) +
1906 sizeof(struct allocExtDesc
));
1908 mark_buffer_dirty_inode(epos
->bh
, inode
);
1910 mark_inode_dirty(inode
);
1914 epos
->offset
+= adsize
;
1917 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
1918 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1922 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
1923 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
1925 epos
->block
= *eloc
;
1926 epos
->offset
= sizeof(struct allocExtDesc
);
1928 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
1929 epos
->bh
= udf_tread(inode
->i_sb
, block
);
1931 udf_debug("reading block %d failed!\n", block
);
1939 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
1940 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
1945 struct short_ad
*sad
;
1946 struct long_ad
*lad
;
1947 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1951 epos
->offset
= udf_file_entry_alloc_offset(inode
);
1952 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1953 udf_file_entry_alloc_offset(inode
) +
1955 alen
= udf_file_entry_alloc_offset(inode
) +
1959 epos
->offset
= sizeof(struct allocExtDesc
);
1960 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1961 alen
= sizeof(struct allocExtDesc
) +
1962 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
1966 switch (iinfo
->i_alloc_type
) {
1967 case ICBTAG_FLAG_AD_SHORT
:
1968 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
1971 etype
= le32_to_cpu(sad
->extLength
) >> 30;
1972 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
1973 eloc
->partitionReferenceNum
=
1974 iinfo
->i_location
.partitionReferenceNum
;
1975 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1977 case ICBTAG_FLAG_AD_LONG
:
1978 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
1981 etype
= le32_to_cpu(lad
->extLength
) >> 30;
1982 *eloc
= lelb_to_cpu(lad
->extLocation
);
1983 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
1986 udf_debug("alloc_type = %d unsupported\n",
1987 iinfo
->i_alloc_type
);
1994 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
1995 struct kernel_lb_addr neloc
, uint32_t nelen
)
1997 struct kernel_lb_addr oeloc
;
2004 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2005 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2007 nelen
= (etype
<< 30) | oelen
;
2009 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2012 return (nelen
>> 30);
2015 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
2016 struct kernel_lb_addr eloc
, uint32_t elen
)
2018 struct extent_position oepos
;
2021 struct allocExtDesc
*aed
;
2022 struct udf_inode_info
*iinfo
;
2029 iinfo
= UDF_I(inode
);
2030 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2031 adsize
= sizeof(struct short_ad
);
2032 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2033 adsize
= sizeof(struct long_ad
);
2038 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2041 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2042 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2043 if (oepos
.bh
!= epos
.bh
) {
2044 oepos
.block
= epos
.block
;
2048 oepos
.offset
= epos
.offset
- adsize
;
2051 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2054 if (epos
.bh
!= oepos
.bh
) {
2055 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2056 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2057 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2059 iinfo
->i_lenAlloc
-= (adsize
* 2);
2060 mark_inode_dirty(inode
);
2062 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2063 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2064 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2065 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2066 udf_update_tag(oepos
.bh
->b_data
,
2067 oepos
.offset
- (2 * adsize
));
2069 udf_update_tag(oepos
.bh
->b_data
,
2070 sizeof(struct allocExtDesc
));
2071 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2074 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2076 iinfo
->i_lenAlloc
-= adsize
;
2077 mark_inode_dirty(inode
);
2079 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2080 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2081 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2082 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2083 udf_update_tag(oepos
.bh
->b_data
,
2084 epos
.offset
- adsize
);
2086 udf_update_tag(oepos
.bh
->b_data
,
2087 sizeof(struct allocExtDesc
));
2088 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2095 return (elen
>> 30);
2098 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2099 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2100 uint32_t *elen
, sector_t
*offset
)
2102 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2103 loff_t lbcount
= 0, bcount
=
2104 (loff_t
) block
<< blocksize_bits
;
2106 struct udf_inode_info
*iinfo
;
2108 iinfo
= UDF_I(inode
);
2110 pos
->block
= iinfo
->i_location
;
2115 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2117 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2118 iinfo
->i_lenExtents
= lbcount
;
2122 } while (lbcount
<= bcount
);
2124 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2129 long udf_block_map(struct inode
*inode
, sector_t block
)
2131 struct kernel_lb_addr eloc
;
2134 struct extent_position epos
= {};
2137 down_read(&UDF_I(inode
)->i_data_sem
);
2139 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2140 (EXT_RECORDED_ALLOCATED
>> 30))
2141 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2145 up_read(&UDF_I(inode
)->i_data_sem
);
2148 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2149 return udf_fixed_to_variable(ret
);