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>
41 #include <linux/aio.h>
46 MODULE_AUTHOR("Ben Fennema");
47 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
48 MODULE_LICENSE("GPL");
50 #define EXTENT_MERGE_SIZE 5
52 static umode_t
udf_convert_permissions(struct fileEntry
*);
53 static int udf_update_inode(struct inode
*, int);
54 static void udf_fill_inode(struct inode
*, struct buffer_head
*);
55 static int udf_sync_inode(struct inode
*inode
);
56 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
57 static sector_t
inode_getblk(struct inode
*, sector_t
, int *, int *);
58 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
59 struct kernel_lb_addr
, uint32_t);
60 static void udf_split_extents(struct inode
*, int *, int, int,
61 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
62 static void udf_prealloc_extents(struct inode
*, int, int,
63 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
64 static void udf_merge_extents(struct inode
*,
65 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int *);
66 static void udf_update_extents(struct inode
*,
67 struct kernel_long_ad
[EXTENT_MERGE_SIZE
], int, int,
68 struct extent_position
*);
69 static int udf_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
71 static void __udf_clear_extent_cache(struct inode
*inode
)
73 struct udf_inode_info
*iinfo
= UDF_I(inode
);
75 if (iinfo
->cached_extent
.lstart
!= -1) {
76 brelse(iinfo
->cached_extent
.epos
.bh
);
77 iinfo
->cached_extent
.lstart
= -1;
81 /* Invalidate extent cache */
82 static void udf_clear_extent_cache(struct inode
*inode
)
84 struct udf_inode_info
*iinfo
= UDF_I(inode
);
86 spin_lock(&iinfo
->i_extent_cache_lock
);
87 __udf_clear_extent_cache(inode
);
88 spin_unlock(&iinfo
->i_extent_cache_lock
);
91 /* Return contents of extent cache */
92 static int udf_read_extent_cache(struct inode
*inode
, loff_t bcount
,
93 loff_t
*lbcount
, struct extent_position
*pos
)
95 struct udf_inode_info
*iinfo
= UDF_I(inode
);
98 spin_lock(&iinfo
->i_extent_cache_lock
);
99 if ((iinfo
->cached_extent
.lstart
<= bcount
) &&
100 (iinfo
->cached_extent
.lstart
!= -1)) {
102 *lbcount
= iinfo
->cached_extent
.lstart
;
103 memcpy(pos
, &iinfo
->cached_extent
.epos
,
104 sizeof(struct extent_position
));
109 spin_unlock(&iinfo
->i_extent_cache_lock
);
113 /* Add extent to extent cache */
114 static void udf_update_extent_cache(struct inode
*inode
, loff_t estart
,
115 struct extent_position
*pos
, int next_epos
)
117 struct udf_inode_info
*iinfo
= UDF_I(inode
);
119 spin_lock(&iinfo
->i_extent_cache_lock
);
120 /* Invalidate previously cached extent */
121 __udf_clear_extent_cache(inode
);
124 memcpy(&iinfo
->cached_extent
.epos
, pos
,
125 sizeof(struct extent_position
));
126 iinfo
->cached_extent
.lstart
= estart
;
128 switch (iinfo
->i_alloc_type
) {
129 case ICBTAG_FLAG_AD_SHORT
:
130 iinfo
->cached_extent
.epos
.offset
-=
131 sizeof(struct short_ad
);
133 case ICBTAG_FLAG_AD_LONG
:
134 iinfo
->cached_extent
.epos
.offset
-=
135 sizeof(struct long_ad
);
137 spin_unlock(&iinfo
->i_extent_cache_lock
);
140 void udf_evict_inode(struct inode
*inode
)
142 struct udf_inode_info
*iinfo
= UDF_I(inode
);
145 if (!inode
->i_nlink
&& !is_bad_inode(inode
)) {
147 udf_setsize(inode
, 0);
148 udf_update_inode(inode
, IS_SYNC(inode
));
150 truncate_inode_pages(&inode
->i_data
, 0);
151 invalidate_inode_buffers(inode
);
153 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
&&
154 inode
->i_size
!= iinfo
->i_lenExtents
) {
155 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",
156 inode
->i_ino
, inode
->i_mode
,
157 (unsigned long long)inode
->i_size
,
158 (unsigned long long)iinfo
->i_lenExtents
);
160 kfree(iinfo
->i_ext
.i_data
);
161 iinfo
->i_ext
.i_data
= NULL
;
162 udf_clear_extent_cache(inode
);
164 udf_free_inode(inode
);
168 static void udf_write_failed(struct address_space
*mapping
, loff_t to
)
170 struct inode
*inode
= mapping
->host
;
171 struct udf_inode_info
*iinfo
= UDF_I(inode
);
172 loff_t isize
= inode
->i_size
;
175 truncate_pagecache(inode
, isize
);
176 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
177 down_write(&iinfo
->i_data_sem
);
178 udf_clear_extent_cache(inode
);
179 udf_truncate_extents(inode
);
180 up_write(&iinfo
->i_data_sem
);
185 static int udf_writepage(struct page
*page
, struct writeback_control
*wbc
)
187 return block_write_full_page(page
, udf_get_block
, wbc
);
190 static int udf_writepages(struct address_space
*mapping
,
191 struct writeback_control
*wbc
)
193 return mpage_writepages(mapping
, wbc
, udf_get_block
);
196 static int udf_readpage(struct file
*file
, struct page
*page
)
198 return mpage_readpage(page
, udf_get_block
);
201 static int udf_readpages(struct file
*file
, struct address_space
*mapping
,
202 struct list_head
*pages
, unsigned nr_pages
)
204 return mpage_readpages(mapping
, pages
, nr_pages
, udf_get_block
);
207 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
208 loff_t pos
, unsigned len
, unsigned flags
,
209 struct page
**pagep
, void **fsdata
)
213 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
215 udf_write_failed(mapping
, pos
+ len
);
219 static ssize_t
udf_direct_IO(int rw
, struct kiocb
*iocb
,
220 const struct iovec
*iov
,
221 loff_t offset
, unsigned long nr_segs
)
223 struct file
*file
= iocb
->ki_filp
;
224 struct address_space
*mapping
= file
->f_mapping
;
225 struct inode
*inode
= mapping
->host
;
228 ret
= blockdev_direct_IO(rw
, iocb
, inode
, iov
, offset
, nr_segs
,
230 if (unlikely(ret
< 0 && (rw
& WRITE
)))
231 udf_write_failed(mapping
, offset
+ iov_length(iov
, nr_segs
));
235 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
237 return generic_block_bmap(mapping
, block
, udf_get_block
);
240 const struct address_space_operations udf_aops
= {
241 .readpage
= udf_readpage
,
242 .readpages
= udf_readpages
,
243 .writepage
= udf_writepage
,
244 .writepages
= udf_writepages
,
245 .write_begin
= udf_write_begin
,
246 .write_end
= generic_write_end
,
247 .direct_IO
= udf_direct_IO
,
252 * Expand file stored in ICB to a normal one-block-file
254 * This function requires i_data_sem for writing and releases it.
255 * This function requires i_mutex held
257 int udf_expand_file_adinicb(struct inode
*inode
)
261 struct udf_inode_info
*iinfo
= UDF_I(inode
);
263 struct writeback_control udf_wbc
= {
264 .sync_mode
= WB_SYNC_NONE
,
268 if (!iinfo
->i_lenAlloc
) {
269 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
270 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
272 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
273 /* from now on we have normal address_space methods */
274 inode
->i_data
.a_ops
= &udf_aops
;
275 up_write(&iinfo
->i_data_sem
);
276 mark_inode_dirty(inode
);
280 * Release i_data_sem so that we can lock a page - page lock ranks
281 * above i_data_sem. i_mutex still protects us against file changes.
283 up_write(&iinfo
->i_data_sem
);
285 page
= find_or_create_page(inode
->i_mapping
, 0, GFP_NOFS
);
289 if (!PageUptodate(page
)) {
291 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
292 PAGE_CACHE_SIZE
- iinfo
->i_lenAlloc
);
293 memcpy(kaddr
, iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
,
295 flush_dcache_page(page
);
296 SetPageUptodate(page
);
299 down_write(&iinfo
->i_data_sem
);
300 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0x00,
302 iinfo
->i_lenAlloc
= 0;
303 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
304 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
306 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
307 /* from now on we have normal address_space methods */
308 inode
->i_data
.a_ops
= &udf_aops
;
309 up_write(&iinfo
->i_data_sem
);
310 err
= inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
312 /* Restore everything back so that we don't lose data... */
315 down_write(&iinfo
->i_data_sem
);
316 memcpy(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, kaddr
,
320 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
321 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
322 up_write(&iinfo
->i_data_sem
);
324 page_cache_release(page
);
325 mark_inode_dirty(inode
);
330 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
, int *block
,
334 struct buffer_head
*dbh
= NULL
;
335 struct kernel_lb_addr eloc
;
337 struct extent_position epos
;
339 struct udf_fileident_bh sfibh
, dfibh
;
340 loff_t f_pos
= udf_ext0_offset(inode
);
341 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
342 struct fileIdentDesc cfi
, *sfi
, *dfi
;
343 struct udf_inode_info
*iinfo
= UDF_I(inode
);
345 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
346 alloctype
= ICBTAG_FLAG_AD_SHORT
;
348 alloctype
= ICBTAG_FLAG_AD_LONG
;
350 if (!inode
->i_size
) {
351 iinfo
->i_alloc_type
= alloctype
;
352 mark_inode_dirty(inode
);
356 /* alloc block, and copy data to it */
357 *block
= udf_new_block(inode
->i_sb
, inode
,
358 iinfo
->i_location
.partitionReferenceNum
,
359 iinfo
->i_location
.logicalBlockNum
, err
);
362 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
363 iinfo
->i_location
.partitionReferenceNum
,
367 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
371 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
372 set_buffer_uptodate(dbh
);
374 mark_buffer_dirty_inode(dbh
, inode
);
376 sfibh
.soffset
= sfibh
.eoffset
=
377 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
378 sfibh
.sbh
= sfibh
.ebh
= NULL
;
379 dfibh
.soffset
= dfibh
.eoffset
= 0;
380 dfibh
.sbh
= dfibh
.ebh
= dbh
;
381 while (f_pos
< size
) {
382 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
383 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
389 iinfo
->i_alloc_type
= alloctype
;
390 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
391 dfibh
.soffset
= dfibh
.eoffset
;
392 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
393 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
394 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
396 le16_to_cpu(sfi
->lengthOfImpUse
))) {
397 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
402 mark_buffer_dirty_inode(dbh
, inode
);
404 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
, 0,
406 iinfo
->i_lenAlloc
= 0;
407 eloc
.logicalBlockNum
= *block
;
408 eloc
.partitionReferenceNum
=
409 iinfo
->i_location
.partitionReferenceNum
;
410 iinfo
->i_lenExtents
= inode
->i_size
;
412 epos
.block
= iinfo
->i_location
;
413 epos
.offset
= udf_file_entry_alloc_offset(inode
);
414 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
418 mark_inode_dirty(inode
);
422 static int udf_get_block(struct inode
*inode
, sector_t block
,
423 struct buffer_head
*bh_result
, int create
)
427 struct udf_inode_info
*iinfo
;
430 phys
= udf_block_map(inode
, block
);
432 map_bh(bh_result
, inode
->i_sb
, phys
);
438 iinfo
= UDF_I(inode
);
440 down_write(&iinfo
->i_data_sem
);
441 if (block
== iinfo
->i_next_alloc_block
+ 1) {
442 iinfo
->i_next_alloc_block
++;
443 iinfo
->i_next_alloc_goal
++;
446 udf_clear_extent_cache(inode
);
447 phys
= inode_getblk(inode
, block
, &err
, &new);
452 set_buffer_new(bh_result
);
453 map_bh(bh_result
, inode
->i_sb
, phys
);
456 up_write(&iinfo
->i_data_sem
);
460 static struct buffer_head
*udf_getblk(struct inode
*inode
, long block
,
461 int create
, int *err
)
463 struct buffer_head
*bh
;
464 struct buffer_head dummy
;
467 dummy
.b_blocknr
= -1000;
468 *err
= udf_get_block(inode
, block
, &dummy
, create
);
469 if (!*err
&& buffer_mapped(&dummy
)) {
470 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
471 if (buffer_new(&dummy
)) {
473 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
474 set_buffer_uptodate(bh
);
476 mark_buffer_dirty_inode(bh
, inode
);
484 /* Extend the file by 'blocks' blocks, return the number of extents added */
485 static int udf_do_extend_file(struct inode
*inode
,
486 struct extent_position
*last_pos
,
487 struct kernel_long_ad
*last_ext
,
491 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
492 struct super_block
*sb
= inode
->i_sb
;
493 struct kernel_lb_addr prealloc_loc
= {};
494 int prealloc_len
= 0;
495 struct udf_inode_info
*iinfo
;
498 /* The previous extent is fake and we should not extend by anything
499 * - there's nothing to do... */
503 iinfo
= UDF_I(inode
);
504 /* Round the last extent up to a multiple of block size */
505 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
506 last_ext
->extLength
=
507 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
508 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
509 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
510 iinfo
->i_lenExtents
=
511 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
512 ~(sb
->s_blocksize
- 1);
515 /* Last extent are just preallocated blocks? */
516 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
517 EXT_NOT_RECORDED_ALLOCATED
) {
518 /* Save the extent so that we can reattach it to the end */
519 prealloc_loc
= last_ext
->extLocation
;
520 prealloc_len
= last_ext
->extLength
;
521 /* Mark the extent as a hole */
522 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
523 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
524 last_ext
->extLocation
.logicalBlockNum
= 0;
525 last_ext
->extLocation
.partitionReferenceNum
= 0;
528 /* Can we merge with the previous extent? */
529 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
530 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
531 add
= ((1 << 30) - sb
->s_blocksize
-
532 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
)) >>
533 sb
->s_blocksize_bits
;
537 last_ext
->extLength
+= add
<< sb
->s_blocksize_bits
;
541 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
542 last_ext
->extLength
, 1);
545 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
546 last_ext
->extLength
, 1);
548 /* Managed to do everything necessary? */
552 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
553 last_ext
->extLocation
.logicalBlockNum
= 0;
554 last_ext
->extLocation
.partitionReferenceNum
= 0;
555 add
= (1 << (30-sb
->s_blocksize_bits
)) - 1;
556 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
557 (add
<< sb
->s_blocksize_bits
);
559 /* Create enough extents to cover the whole hole */
560 while (blocks
> add
) {
562 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
563 last_ext
->extLength
, 1);
569 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
570 (blocks
<< sb
->s_blocksize_bits
);
571 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
572 last_ext
->extLength
, 1);
579 /* Do we have some preallocated blocks saved? */
581 err
= udf_add_aext(inode
, last_pos
, &prealloc_loc
,
585 last_ext
->extLocation
= prealloc_loc
;
586 last_ext
->extLength
= prealloc_len
;
590 /* last_pos should point to the last written extent... */
591 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
592 last_pos
->offset
-= sizeof(struct short_ad
);
593 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
594 last_pos
->offset
-= sizeof(struct long_ad
);
601 static int udf_extend_file(struct inode
*inode
, loff_t newsize
)
604 struct extent_position epos
;
605 struct kernel_lb_addr eloc
;
608 struct super_block
*sb
= inode
->i_sb
;
609 sector_t first_block
= newsize
>> sb
->s_blocksize_bits
, offset
;
611 struct udf_inode_info
*iinfo
= UDF_I(inode
);
612 struct kernel_long_ad extent
;
615 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
616 adsize
= sizeof(struct short_ad
);
617 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
618 adsize
= sizeof(struct long_ad
);
622 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
624 /* File has extent covering the new size (could happen when extending
625 * inside a block)? */
628 if (newsize
& (sb
->s_blocksize
- 1))
630 /* Extended file just to the boundary of the last file block? */
634 /* Truncate is extending the file by 'offset' blocks */
635 if ((!epos
.bh
&& epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
636 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
637 /* File has no extents at all or has empty last
638 * indirect extent! Create a fake extent... */
639 extent
.extLocation
.logicalBlockNum
= 0;
640 extent
.extLocation
.partitionReferenceNum
= 0;
641 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
643 epos
.offset
-= adsize
;
644 etype
= udf_next_aext(inode
, &epos
, &extent
.extLocation
,
645 &extent
.extLength
, 0);
646 extent
.extLength
|= etype
<< 30;
648 err
= udf_do_extend_file(inode
, &epos
, &extent
, offset
);
652 iinfo
->i_lenExtents
= newsize
;
658 static sector_t
inode_getblk(struct inode
*inode
, sector_t block
,
661 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
662 struct extent_position prev_epos
, cur_epos
, next_epos
;
663 int count
= 0, startnum
= 0, endnum
= 0;
664 uint32_t elen
= 0, tmpelen
;
665 struct kernel_lb_addr eloc
, tmpeloc
;
667 loff_t lbcount
= 0, b_off
= 0;
668 uint32_t newblocknum
, newblock
;
671 struct udf_inode_info
*iinfo
= UDF_I(inode
);
672 int goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
678 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
679 prev_epos
.block
= iinfo
->i_location
;
681 cur_epos
= next_epos
= prev_epos
;
682 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
684 /* find the extent which contains the block we are looking for.
685 alternate between laarr[0] and laarr[1] for locations of the
686 current extent, and the previous extent */
688 if (prev_epos
.bh
!= cur_epos
.bh
) {
689 brelse(prev_epos
.bh
);
691 prev_epos
.bh
= cur_epos
.bh
;
693 if (cur_epos
.bh
!= next_epos
.bh
) {
695 get_bh(next_epos
.bh
);
696 cur_epos
.bh
= next_epos
.bh
;
701 prev_epos
.block
= cur_epos
.block
;
702 cur_epos
.block
= next_epos
.block
;
704 prev_epos
.offset
= cur_epos
.offset
;
705 cur_epos
.offset
= next_epos
.offset
;
707 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
713 laarr
[c
].extLength
= (etype
<< 30) | elen
;
714 laarr
[c
].extLocation
= eloc
;
716 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
717 pgoal
= eloc
.logicalBlockNum
+
718 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
719 inode
->i_sb
->s_blocksize_bits
);
722 } while (lbcount
+ elen
<= b_off
);
725 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
727 * Move prev_epos and cur_epos into indirect extent if we are at
730 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
731 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
733 /* if the extent is allocated and recorded, return the block
734 if the extent is not a multiple of the blocksize, round up */
736 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
737 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
738 elen
= EXT_RECORDED_ALLOCATED
|
739 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
740 ~(inode
->i_sb
->s_blocksize
- 1));
741 udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
743 brelse(prev_epos
.bh
);
745 brelse(next_epos
.bh
);
746 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
750 /* Are we beyond EOF? */
759 /* Create a fake extent when there's not one */
760 memset(&laarr
[0].extLocation
, 0x00,
761 sizeof(struct kernel_lb_addr
));
762 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
763 /* Will udf_do_extend_file() create real extent from
765 startnum
= (offset
> 0);
767 /* Create extents for the hole between EOF and offset */
768 ret
= udf_do_extend_file(inode
, &prev_epos
, laarr
, offset
);
770 brelse(prev_epos
.bh
);
772 brelse(next_epos
.bh
);
779 /* We are not covered by a preallocated extent? */
780 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
781 EXT_NOT_RECORDED_ALLOCATED
) {
782 /* Is there any real extent? - otherwise we overwrite
786 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
787 inode
->i_sb
->s_blocksize
;
788 memset(&laarr
[c
].extLocation
, 0x00,
789 sizeof(struct kernel_lb_addr
));
796 endnum
= startnum
= ((count
> 2) ? 2 : count
);
798 /* if the current extent is in position 0,
799 swap it with the previous */
800 if (!c
&& count
!= 1) {
807 /* if the current block is located in an extent,
808 read the next extent */
809 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
811 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
812 laarr
[c
+ 1].extLocation
= eloc
;
820 /* if the current extent is not recorded but allocated, get the
821 * block in the extent corresponding to the requested block */
822 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
823 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
824 else { /* otherwise, allocate a new block */
825 if (iinfo
->i_next_alloc_block
== block
)
826 goal
= iinfo
->i_next_alloc_goal
;
829 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
830 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
833 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
834 iinfo
->i_location
.partitionReferenceNum
,
837 brelse(prev_epos
.bh
);
839 brelse(next_epos
.bh
);
844 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
847 /* if the extent the requsted block is located in contains multiple
848 * blocks, split the extent into at most three extents. blocks prior
849 * to requested block, requested block, and blocks after requested
851 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
853 #ifdef UDF_PREALLOCATE
854 /* We preallocate blocks only for regular files. It also makes sense
855 * for directories but there's a problem when to drop the
856 * preallocation. We might use some delayed work for that but I feel
857 * it's overengineering for a filesystem like UDF. */
858 if (S_ISREG(inode
->i_mode
))
859 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
862 /* merge any continuous blocks in laarr */
863 udf_merge_extents(inode
, laarr
, &endnum
);
865 /* write back the new extents, inserting new extents if the new number
866 * of extents is greater than the old number, and deleting extents if
867 * the new number of extents is less than the old number */
868 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
870 brelse(prev_epos
.bh
);
872 brelse(next_epos
.bh
);
874 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
875 iinfo
->i_location
.partitionReferenceNum
, 0);
881 iinfo
->i_next_alloc_block
= block
;
882 iinfo
->i_next_alloc_goal
= newblocknum
;
883 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
886 udf_sync_inode(inode
);
888 mark_inode_dirty(inode
);
893 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
895 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
898 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
899 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
901 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
902 (laarr
[*c
].extLength
>> 30) ==
903 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
905 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
906 blocksize
- 1) >> blocksize_bits
;
907 int8_t etype
= (laarr
[curr
].extLength
>> 30);
911 else if (!offset
|| blen
== offset
+ 1) {
912 laarr
[curr
+ 2] = laarr
[curr
+ 1];
913 laarr
[curr
+ 1] = laarr
[curr
];
915 laarr
[curr
+ 3] = laarr
[curr
+ 1];
916 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
920 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
921 udf_free_blocks(inode
->i_sb
, inode
,
922 &laarr
[curr
].extLocation
,
924 laarr
[curr
].extLength
=
925 EXT_NOT_RECORDED_NOT_ALLOCATED
|
926 (offset
<< blocksize_bits
);
927 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
928 laarr
[curr
].extLocation
.
929 partitionReferenceNum
= 0;
931 laarr
[curr
].extLength
= (etype
<< 30) |
932 (offset
<< blocksize_bits
);
938 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
939 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
940 laarr
[curr
].extLocation
.partitionReferenceNum
=
941 UDF_I(inode
)->i_location
.partitionReferenceNum
;
942 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
946 if (blen
!= offset
+ 1) {
947 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
948 laarr
[curr
].extLocation
.logicalBlockNum
+=
950 laarr
[curr
].extLength
= (etype
<< 30) |
951 ((blen
- (offset
+ 1)) << blocksize_bits
);
958 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
959 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
962 int start
, length
= 0, currlength
= 0, i
;
964 if (*endnum
>= (c
+ 1)) {
970 if ((laarr
[c
+ 1].extLength
>> 30) ==
971 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
973 length
= currlength
=
974 (((laarr
[c
+ 1].extLength
&
975 UDF_EXTENT_LENGTH_MASK
) +
976 inode
->i_sb
->s_blocksize
- 1) >>
977 inode
->i_sb
->s_blocksize_bits
);
982 for (i
= start
+ 1; i
<= *endnum
; i
++) {
985 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
986 } else if ((laarr
[i
].extLength
>> 30) ==
987 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
988 length
+= (((laarr
[i
].extLength
&
989 UDF_EXTENT_LENGTH_MASK
) +
990 inode
->i_sb
->s_blocksize
- 1) >>
991 inode
->i_sb
->s_blocksize_bits
);
997 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
998 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
999 inode
->i_sb
->s_blocksize
- 1) >>
1000 inode
->i_sb
->s_blocksize_bits
);
1001 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
1002 laarr
[start
].extLocation
.partitionReferenceNum
,
1003 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
1004 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
1007 if (start
== (c
+ 1))
1008 laarr
[start
].extLength
+=
1010 inode
->i_sb
->s_blocksize_bits
);
1012 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
1013 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
1015 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
1016 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
1017 laarr
[c
].extLocation
.
1018 partitionReferenceNum
;
1019 laarr
[c
+ 1].extLength
=
1020 EXT_NOT_RECORDED_ALLOCATED
|
1022 inode
->i_sb
->s_blocksize_bits
);
1026 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
1027 int elen
= ((laarr
[i
].extLength
&
1028 UDF_EXTENT_LENGTH_MASK
) +
1029 inode
->i_sb
->s_blocksize
- 1) >>
1030 inode
->i_sb
->s_blocksize_bits
;
1032 if (elen
> numalloc
) {
1033 laarr
[i
].extLength
-=
1035 inode
->i_sb
->s_blocksize_bits
);
1039 if (*endnum
> (i
+ 1))
1042 sizeof(struct long_ad
) *
1043 (*endnum
- (i
+ 1)));
1048 UDF_I(inode
)->i_lenExtents
+=
1049 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
1054 static void udf_merge_extents(struct inode
*inode
,
1055 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
1059 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
1060 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1062 for (i
= 0; i
< (*endnum
- 1); i
++) {
1063 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
1064 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
1066 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
1067 (((li
->extLength
>> 30) ==
1068 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
1069 ((lip1
->extLocation
.logicalBlockNum
-
1070 li
->extLocation
.logicalBlockNum
) ==
1071 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1072 blocksize
- 1) >> blocksize_bits
)))) {
1074 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1075 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1076 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1077 lip1
->extLength
= (lip1
->extLength
-
1079 UDF_EXTENT_LENGTH_MASK
) +
1080 UDF_EXTENT_LENGTH_MASK
) &
1082 li
->extLength
= (li
->extLength
&
1083 UDF_EXTENT_FLAG_MASK
) +
1084 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1086 lip1
->extLocation
.logicalBlockNum
=
1087 li
->extLocation
.logicalBlockNum
+
1089 UDF_EXTENT_LENGTH_MASK
) >>
1092 li
->extLength
= lip1
->extLength
+
1094 UDF_EXTENT_LENGTH_MASK
) +
1095 blocksize
- 1) & ~(blocksize
- 1));
1096 if (*endnum
> (i
+ 2))
1097 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1098 sizeof(struct long_ad
) *
1099 (*endnum
- (i
+ 2)));
1103 } else if (((li
->extLength
>> 30) ==
1104 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
1105 ((lip1
->extLength
>> 30) ==
1106 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
1107 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
1109 UDF_EXTENT_LENGTH_MASK
) +
1110 blocksize
- 1) >> blocksize_bits
);
1111 li
->extLocation
.logicalBlockNum
= 0;
1112 li
->extLocation
.partitionReferenceNum
= 0;
1114 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1115 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1116 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1117 lip1
->extLength
= (lip1
->extLength
-
1119 UDF_EXTENT_LENGTH_MASK
) +
1120 UDF_EXTENT_LENGTH_MASK
) &
1122 li
->extLength
= (li
->extLength
&
1123 UDF_EXTENT_FLAG_MASK
) +
1124 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1127 li
->extLength
= lip1
->extLength
+
1129 UDF_EXTENT_LENGTH_MASK
) +
1130 blocksize
- 1) & ~(blocksize
- 1));
1131 if (*endnum
> (i
+ 2))
1132 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1133 sizeof(struct long_ad
) *
1134 (*endnum
- (i
+ 2)));
1138 } else if ((li
->extLength
>> 30) ==
1139 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
1140 udf_free_blocks(inode
->i_sb
, inode
,
1141 &li
->extLocation
, 0,
1143 UDF_EXTENT_LENGTH_MASK
) +
1144 blocksize
- 1) >> blocksize_bits
);
1145 li
->extLocation
.logicalBlockNum
= 0;
1146 li
->extLocation
.partitionReferenceNum
= 0;
1147 li
->extLength
= (li
->extLength
&
1148 UDF_EXTENT_LENGTH_MASK
) |
1149 EXT_NOT_RECORDED_NOT_ALLOCATED
;
1154 static void udf_update_extents(struct inode
*inode
,
1155 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
],
1156 int startnum
, int endnum
,
1157 struct extent_position
*epos
)
1160 struct kernel_lb_addr tmploc
;
1163 if (startnum
> endnum
) {
1164 for (i
= 0; i
< (startnum
- endnum
); i
++)
1165 udf_delete_aext(inode
, *epos
, laarr
[i
].extLocation
,
1166 laarr
[i
].extLength
);
1167 } else if (startnum
< endnum
) {
1168 for (i
= 0; i
< (endnum
- startnum
); i
++) {
1169 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
1170 laarr
[i
].extLength
);
1171 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
1172 &laarr
[i
].extLength
, 1);
1177 for (i
= start
; i
< endnum
; i
++) {
1178 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
1179 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
1180 laarr
[i
].extLength
, 1);
1184 struct buffer_head
*udf_bread(struct inode
*inode
, int block
,
1185 int create
, int *err
)
1187 struct buffer_head
*bh
= NULL
;
1189 bh
= udf_getblk(inode
, block
, create
, err
);
1193 if (buffer_uptodate(bh
))
1196 ll_rw_block(READ
, 1, &bh
);
1199 if (buffer_uptodate(bh
))
1207 int udf_setsize(struct inode
*inode
, loff_t newsize
)
1210 struct udf_inode_info
*iinfo
;
1211 int bsize
= 1 << inode
->i_blkbits
;
1213 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1214 S_ISLNK(inode
->i_mode
)))
1216 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1219 iinfo
= UDF_I(inode
);
1220 if (newsize
> inode
->i_size
) {
1221 down_write(&iinfo
->i_data_sem
);
1222 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1224 (udf_file_entry_alloc_offset(inode
) + newsize
)) {
1225 err
= udf_expand_file_adinicb(inode
);
1228 down_write(&iinfo
->i_data_sem
);
1230 iinfo
->i_lenAlloc
= newsize
;
1234 err
= udf_extend_file(inode
, newsize
);
1236 up_write(&iinfo
->i_data_sem
);
1240 truncate_setsize(inode
, newsize
);
1241 up_write(&iinfo
->i_data_sem
);
1243 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1244 down_write(&iinfo
->i_data_sem
);
1245 udf_clear_extent_cache(inode
);
1246 memset(iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1247 0x00, bsize
- newsize
-
1248 udf_file_entry_alloc_offset(inode
));
1249 iinfo
->i_lenAlloc
= newsize
;
1250 truncate_setsize(inode
, newsize
);
1251 up_write(&iinfo
->i_data_sem
);
1254 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1258 down_write(&iinfo
->i_data_sem
);
1259 udf_clear_extent_cache(inode
);
1260 truncate_setsize(inode
, newsize
);
1261 udf_truncate_extents(inode
);
1262 up_write(&iinfo
->i_data_sem
);
1265 inode
->i_mtime
= inode
->i_ctime
= current_fs_time(inode
->i_sb
);
1267 udf_sync_inode(inode
);
1269 mark_inode_dirty(inode
);
1273 static void __udf_read_inode(struct inode
*inode
)
1275 struct buffer_head
*bh
= NULL
;
1276 struct fileEntry
*fe
;
1278 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1281 * Set defaults, but the inode is still incomplete!
1282 * Note: get_new_inode() sets the following on a new inode:
1285 * i_flags = sb->s_flags
1287 * clean_inode(): zero fills and sets
1292 bh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 0, &ident
);
1294 udf_err(inode
->i_sb
, "(ino %ld) failed !bh\n", inode
->i_ino
);
1295 make_bad_inode(inode
);
1299 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1300 ident
!= TAG_IDENT_USE
) {
1301 udf_err(inode
->i_sb
, "(ino %ld) failed ident=%d\n",
1302 inode
->i_ino
, ident
);
1304 make_bad_inode(inode
);
1308 fe
= (struct fileEntry
*)bh
->b_data
;
1310 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1311 struct buffer_head
*ibh
;
1313 ibh
= udf_read_ptagged(inode
->i_sb
, &iinfo
->i_location
, 1,
1315 if (ident
== TAG_IDENT_IE
&& ibh
) {
1316 struct buffer_head
*nbh
= NULL
;
1317 struct kernel_lb_addr loc
;
1318 struct indirectEntry
*ie
;
1320 ie
= (struct indirectEntry
*)ibh
->b_data
;
1321 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1323 if (ie
->indirectICB
.extLength
&&
1324 (nbh
= udf_read_ptagged(inode
->i_sb
, &loc
, 0,
1326 if (ident
== TAG_IDENT_FE
||
1327 ident
== TAG_IDENT_EFE
) {
1328 memcpy(&iinfo
->i_location
,
1330 sizeof(struct kernel_lb_addr
));
1334 __udf_read_inode(inode
);
1341 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1342 udf_err(inode
->i_sb
, "unsupported strategy type: %d\n",
1343 le16_to_cpu(fe
->icbTag
.strategyType
));
1345 make_bad_inode(inode
);
1348 udf_fill_inode(inode
, bh
);
1353 static void udf_fill_inode(struct inode
*inode
, struct buffer_head
*bh
)
1355 struct fileEntry
*fe
;
1356 struct extendedFileEntry
*efe
;
1357 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1358 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1359 unsigned int link_count
;
1361 fe
= (struct fileEntry
*)bh
->b_data
;
1362 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1364 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1365 iinfo
->i_strat4096
= 0;
1366 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1367 iinfo
->i_strat4096
= 1;
1369 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1370 ICBTAG_FLAG_AD_MASK
;
1371 iinfo
->i_unique
= 0;
1372 iinfo
->i_lenEAttr
= 0;
1373 iinfo
->i_lenExtents
= 0;
1374 iinfo
->i_lenAlloc
= 0;
1375 iinfo
->i_next_alloc_block
= 0;
1376 iinfo
->i_next_alloc_goal
= 0;
1377 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1380 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1381 sizeof(struct extendedFileEntry
))) {
1382 make_bad_inode(inode
);
1385 memcpy(iinfo
->i_ext
.i_data
,
1386 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1387 inode
->i_sb
->s_blocksize
-
1388 sizeof(struct extendedFileEntry
));
1389 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1392 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1393 sizeof(struct fileEntry
))) {
1394 make_bad_inode(inode
);
1397 memcpy(iinfo
->i_ext
.i_data
,
1398 bh
->b_data
+ sizeof(struct fileEntry
),
1399 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1400 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1403 iinfo
->i_lenAlloc
= le32_to_cpu(
1404 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1406 if (udf_alloc_i_data(inode
, inode
->i_sb
->s_blocksize
-
1407 sizeof(struct unallocSpaceEntry
))) {
1408 make_bad_inode(inode
);
1411 memcpy(iinfo
->i_ext
.i_data
,
1412 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1413 inode
->i_sb
->s_blocksize
-
1414 sizeof(struct unallocSpaceEntry
));
1418 read_lock(&sbi
->s_cred_lock
);
1419 i_uid_write(inode
, le32_to_cpu(fe
->uid
));
1420 if (!uid_valid(inode
->i_uid
) ||
1421 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_IGNORE
) ||
1422 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1423 inode
->i_uid
= UDF_SB(inode
->i_sb
)->s_uid
;
1425 i_gid_write(inode
, le32_to_cpu(fe
->gid
));
1426 if (!gid_valid(inode
->i_gid
) ||
1427 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_IGNORE
) ||
1428 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1429 inode
->i_gid
= UDF_SB(inode
->i_sb
)->s_gid
;
1431 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1432 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1433 inode
->i_mode
= sbi
->s_fmode
;
1434 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1435 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1436 inode
->i_mode
= sbi
->s_dmode
;
1438 inode
->i_mode
= udf_convert_permissions(fe
);
1439 inode
->i_mode
&= ~sbi
->s_umask
;
1440 read_unlock(&sbi
->s_cred_lock
);
1442 link_count
= le16_to_cpu(fe
->fileLinkCount
);
1445 set_nlink(inode
, link_count
);
1447 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1448 iinfo
->i_lenExtents
= inode
->i_size
;
1450 if (iinfo
->i_efe
== 0) {
1451 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1452 (inode
->i_sb
->s_blocksize_bits
- 9);
1454 if (!udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
))
1455 inode
->i_atime
= sbi
->s_record_time
;
1457 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1458 fe
->modificationTime
))
1459 inode
->i_mtime
= sbi
->s_record_time
;
1461 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
))
1462 inode
->i_ctime
= sbi
->s_record_time
;
1464 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1465 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1466 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1467 iinfo
->i_checkpoint
= le32_to_cpu(fe
->checkpoint
);
1469 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1470 (inode
->i_sb
->s_blocksize_bits
- 9);
1472 if (!udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
))
1473 inode
->i_atime
= sbi
->s_record_time
;
1475 if (!udf_disk_stamp_to_time(&inode
->i_mtime
,
1476 efe
->modificationTime
))
1477 inode
->i_mtime
= sbi
->s_record_time
;
1479 if (!udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
))
1480 iinfo
->i_crtime
= sbi
->s_record_time
;
1482 if (!udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
))
1483 inode
->i_ctime
= sbi
->s_record_time
;
1485 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1486 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1487 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1488 iinfo
->i_checkpoint
= le32_to_cpu(efe
->checkpoint
);
1491 switch (fe
->icbTag
.fileType
) {
1492 case ICBTAG_FILE_TYPE_DIRECTORY
:
1493 inode
->i_op
= &udf_dir_inode_operations
;
1494 inode
->i_fop
= &udf_dir_operations
;
1495 inode
->i_mode
|= S_IFDIR
;
1498 case ICBTAG_FILE_TYPE_REALTIME
:
1499 case ICBTAG_FILE_TYPE_REGULAR
:
1500 case ICBTAG_FILE_TYPE_UNDEF
:
1501 case ICBTAG_FILE_TYPE_VAT20
:
1502 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1503 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1505 inode
->i_data
.a_ops
= &udf_aops
;
1506 inode
->i_op
= &udf_file_inode_operations
;
1507 inode
->i_fop
= &udf_file_operations
;
1508 inode
->i_mode
|= S_IFREG
;
1510 case ICBTAG_FILE_TYPE_BLOCK
:
1511 inode
->i_mode
|= S_IFBLK
;
1513 case ICBTAG_FILE_TYPE_CHAR
:
1514 inode
->i_mode
|= S_IFCHR
;
1516 case ICBTAG_FILE_TYPE_FIFO
:
1517 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1519 case ICBTAG_FILE_TYPE_SOCKET
:
1520 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1522 case ICBTAG_FILE_TYPE_SYMLINK
:
1523 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1524 inode
->i_op
= &udf_symlink_inode_operations
;
1525 inode
->i_mode
= S_IFLNK
| S_IRWXUGO
;
1527 case ICBTAG_FILE_TYPE_MAIN
:
1528 udf_debug("METADATA FILE-----\n");
1530 case ICBTAG_FILE_TYPE_MIRROR
:
1531 udf_debug("METADATA MIRROR FILE-----\n");
1533 case ICBTAG_FILE_TYPE_BITMAP
:
1534 udf_debug("METADATA BITMAP FILE-----\n");
1537 udf_err(inode
->i_sb
, "(ino %ld) failed unknown file type=%d\n",
1538 inode
->i_ino
, fe
->icbTag
.fileType
);
1539 make_bad_inode(inode
);
1542 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1543 struct deviceSpec
*dsea
=
1544 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1546 init_special_inode(inode
, inode
->i_mode
,
1547 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1548 le32_to_cpu(dsea
->minorDeviceIdent
)));
1549 /* Developer ID ??? */
1551 make_bad_inode(inode
);
1555 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1557 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1558 iinfo
->i_ext
.i_data
= kmalloc(size
, GFP_KERNEL
);
1560 if (!iinfo
->i_ext
.i_data
) {
1561 udf_err(inode
->i_sb
, "(ino %ld) no free memory\n",
1569 static umode_t
udf_convert_permissions(struct fileEntry
*fe
)
1572 uint32_t permissions
;
1575 permissions
= le32_to_cpu(fe
->permissions
);
1576 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1578 mode
= ((permissions
) & S_IRWXO
) |
1579 ((permissions
>> 2) & S_IRWXG
) |
1580 ((permissions
>> 4) & S_IRWXU
) |
1581 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1582 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1583 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1588 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1590 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1593 static int udf_sync_inode(struct inode
*inode
)
1595 return udf_update_inode(inode
, 1);
1598 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1600 struct buffer_head
*bh
= NULL
;
1601 struct fileEntry
*fe
;
1602 struct extendedFileEntry
*efe
;
1603 uint64_t lb_recorded
;
1608 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1609 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1610 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1612 bh
= udf_tgetblk(inode
->i_sb
,
1613 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1615 udf_debug("getblk failure\n");
1620 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1621 fe
= (struct fileEntry
*)bh
->b_data
;
1622 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1625 struct unallocSpaceEntry
*use
=
1626 (struct unallocSpaceEntry
*)bh
->b_data
;
1628 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1629 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1630 iinfo
->i_ext
.i_data
, inode
->i_sb
->s_blocksize
-
1631 sizeof(struct unallocSpaceEntry
));
1632 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1633 use
->descTag
.tagLocation
=
1634 cpu_to_le32(iinfo
->i_location
.logicalBlockNum
);
1635 crclen
= sizeof(struct unallocSpaceEntry
) +
1636 iinfo
->i_lenAlloc
- sizeof(struct tag
);
1637 use
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1638 use
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)use
+
1641 use
->descTag
.tagChecksum
= udf_tag_checksum(&use
->descTag
);
1646 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1647 fe
->uid
= cpu_to_le32(-1);
1649 fe
->uid
= cpu_to_le32(i_uid_read(inode
));
1651 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1652 fe
->gid
= cpu_to_le32(-1);
1654 fe
->gid
= cpu_to_le32(i_gid_read(inode
));
1656 udfperms
= ((inode
->i_mode
& S_IRWXO
)) |
1657 ((inode
->i_mode
& S_IRWXG
) << 2) |
1658 ((inode
->i_mode
& S_IRWXU
) << 4);
1660 udfperms
|= (le32_to_cpu(fe
->permissions
) &
1661 (FE_PERM_O_DELETE
| FE_PERM_O_CHATTR
|
1662 FE_PERM_G_DELETE
| FE_PERM_G_CHATTR
|
1663 FE_PERM_U_DELETE
| FE_PERM_U_CHATTR
));
1664 fe
->permissions
= cpu_to_le32(udfperms
);
1666 if (S_ISDIR(inode
->i_mode
))
1667 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1669 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1671 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1673 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1675 struct deviceSpec
*dsea
=
1676 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1678 dsea
= (struct deviceSpec
*)
1679 udf_add_extendedattr(inode
,
1680 sizeof(struct deviceSpec
) +
1681 sizeof(struct regid
), 12, 0x3);
1682 dsea
->attrType
= cpu_to_le32(12);
1683 dsea
->attrSubtype
= 1;
1684 dsea
->attrLength
= cpu_to_le32(
1685 sizeof(struct deviceSpec
) +
1686 sizeof(struct regid
));
1687 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1689 eid
= (struct regid
*)dsea
->impUse
;
1690 memset(eid
, 0, sizeof(struct regid
));
1691 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1692 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1693 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1694 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1695 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1698 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1699 lb_recorded
= 0; /* No extents => no blocks! */
1702 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1703 (blocksize_bits
- 9);
1705 if (iinfo
->i_efe
== 0) {
1706 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1707 iinfo
->i_ext
.i_data
,
1708 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1709 fe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1711 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1712 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1713 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1714 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1715 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1716 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1717 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1718 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1719 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1720 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1721 fe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1722 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1723 crclen
= sizeof(struct fileEntry
);
1725 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1726 iinfo
->i_ext
.i_data
,
1727 inode
->i_sb
->s_blocksize
-
1728 sizeof(struct extendedFileEntry
));
1729 efe
->objectSize
= cpu_to_le64(inode
->i_size
);
1730 efe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1732 if (iinfo
->i_crtime
.tv_sec
> inode
->i_atime
.tv_sec
||
1733 (iinfo
->i_crtime
.tv_sec
== inode
->i_atime
.tv_sec
&&
1734 iinfo
->i_crtime
.tv_nsec
> inode
->i_atime
.tv_nsec
))
1735 iinfo
->i_crtime
= inode
->i_atime
;
1737 if (iinfo
->i_crtime
.tv_sec
> inode
->i_mtime
.tv_sec
||
1738 (iinfo
->i_crtime
.tv_sec
== inode
->i_mtime
.tv_sec
&&
1739 iinfo
->i_crtime
.tv_nsec
> inode
->i_mtime
.tv_nsec
))
1740 iinfo
->i_crtime
= inode
->i_mtime
;
1742 if (iinfo
->i_crtime
.tv_sec
> inode
->i_ctime
.tv_sec
||
1743 (iinfo
->i_crtime
.tv_sec
== inode
->i_ctime
.tv_sec
&&
1744 iinfo
->i_crtime
.tv_nsec
> inode
->i_ctime
.tv_nsec
))
1745 iinfo
->i_crtime
= inode
->i_ctime
;
1747 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1748 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1749 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1750 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1752 memset(&(efe
->impIdent
), 0, sizeof(struct regid
));
1753 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1754 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1755 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1756 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1757 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1758 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1759 efe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1760 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1761 crclen
= sizeof(struct extendedFileEntry
);
1763 if (iinfo
->i_strat4096
) {
1764 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1765 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1766 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1768 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1769 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1772 if (S_ISDIR(inode
->i_mode
))
1773 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1774 else if (S_ISREG(inode
->i_mode
))
1775 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1776 else if (S_ISLNK(inode
->i_mode
))
1777 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1778 else if (S_ISBLK(inode
->i_mode
))
1779 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1780 else if (S_ISCHR(inode
->i_mode
))
1781 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1782 else if (S_ISFIFO(inode
->i_mode
))
1783 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1784 else if (S_ISSOCK(inode
->i_mode
))
1785 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1787 icbflags
= iinfo
->i_alloc_type
|
1788 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1789 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1790 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1791 (le16_to_cpu(fe
->icbTag
.flags
) &
1792 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1793 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1795 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1796 if (sbi
->s_udfrev
>= 0x0200)
1797 fe
->descTag
.descVersion
= cpu_to_le16(3);
1799 fe
->descTag
.descVersion
= cpu_to_le16(2);
1800 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1801 fe
->descTag
.tagLocation
= cpu_to_le32(
1802 iinfo
->i_location
.logicalBlockNum
);
1803 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1804 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1805 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1807 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1810 set_buffer_uptodate(bh
);
1813 /* write the data blocks */
1814 mark_buffer_dirty(bh
);
1816 sync_dirty_buffer(bh
);
1817 if (buffer_write_io_error(bh
)) {
1818 udf_warn(inode
->i_sb
, "IO error syncing udf inode [%08lx]\n",
1828 struct inode
*udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
)
1830 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1831 struct inode
*inode
= iget_locked(sb
, block
);
1836 if (inode
->i_state
& I_NEW
) {
1837 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1838 __udf_read_inode(inode
);
1839 unlock_new_inode(inode
);
1842 if (is_bad_inode(inode
))
1845 if (ino
->logicalBlockNum
>= UDF_SB(sb
)->
1846 s_partmaps
[ino
->partitionReferenceNum
].s_partition_len
) {
1847 udf_debug("block=%d, partition=%d out of range\n",
1848 ino
->logicalBlockNum
, ino
->partitionReferenceNum
);
1849 make_bad_inode(inode
);
1860 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
1861 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1864 struct short_ad
*sad
= NULL
;
1865 struct long_ad
*lad
= NULL
;
1866 struct allocExtDesc
*aed
;
1868 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1871 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
1872 udf_file_entry_alloc_offset(inode
) +
1875 ptr
= epos
->bh
->b_data
+ epos
->offset
;
1877 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1878 adsize
= sizeof(struct short_ad
);
1879 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1880 adsize
= sizeof(struct long_ad
);
1884 if (epos
->offset
+ (2 * adsize
) > inode
->i_sb
->s_blocksize
) {
1885 unsigned char *sptr
, *dptr
;
1886 struct buffer_head
*nbh
;
1888 struct kernel_lb_addr obloc
= epos
->block
;
1890 epos
->block
.logicalBlockNum
= udf_new_block(inode
->i_sb
, NULL
,
1891 obloc
.partitionReferenceNum
,
1892 obloc
.logicalBlockNum
, &err
);
1893 if (!epos
->block
.logicalBlockNum
)
1895 nbh
= udf_tgetblk(inode
->i_sb
, udf_get_lb_pblock(inode
->i_sb
,
1901 memset(nbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
1902 set_buffer_uptodate(nbh
);
1904 mark_buffer_dirty_inode(nbh
, inode
);
1906 aed
= (struct allocExtDesc
*)(nbh
->b_data
);
1907 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
1908 aed
->previousAllocExtLocation
=
1909 cpu_to_le32(obloc
.logicalBlockNum
);
1910 if (epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
) {
1911 loffset
= epos
->offset
;
1912 aed
->lengthAllocDescs
= cpu_to_le32(adsize
);
1913 sptr
= ptr
- adsize
;
1914 dptr
= nbh
->b_data
+ sizeof(struct allocExtDesc
);
1915 memcpy(dptr
, sptr
, adsize
);
1916 epos
->offset
= sizeof(struct allocExtDesc
) + adsize
;
1918 loffset
= epos
->offset
+ adsize
;
1919 aed
->lengthAllocDescs
= cpu_to_le32(0);
1921 epos
->offset
= sizeof(struct allocExtDesc
);
1924 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1925 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1927 iinfo
->i_lenAlloc
+= adsize
;
1928 mark_inode_dirty(inode
);
1931 if (UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0200)
1932 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 3, 1,
1933 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1935 udf_new_tag(nbh
->b_data
, TAG_IDENT_AED
, 2, 1,
1936 epos
->block
.logicalBlockNum
, sizeof(struct tag
));
1937 switch (iinfo
->i_alloc_type
) {
1938 case ICBTAG_FLAG_AD_SHORT
:
1939 sad
= (struct short_ad
*)sptr
;
1940 sad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1941 inode
->i_sb
->s_blocksize
);
1943 cpu_to_le32(epos
->block
.logicalBlockNum
);
1945 case ICBTAG_FLAG_AD_LONG
:
1946 lad
= (struct long_ad
*)sptr
;
1947 lad
->extLength
= cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS
|
1948 inode
->i_sb
->s_blocksize
);
1949 lad
->extLocation
= cpu_to_lelb(epos
->block
);
1950 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
1954 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1955 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1956 udf_update_tag(epos
->bh
->b_data
, loffset
);
1958 udf_update_tag(epos
->bh
->b_data
,
1959 sizeof(struct allocExtDesc
));
1960 mark_buffer_dirty_inode(epos
->bh
, inode
);
1963 mark_inode_dirty(inode
);
1968 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
1971 iinfo
->i_lenAlloc
+= adsize
;
1972 mark_inode_dirty(inode
);
1974 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
1975 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
1976 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
1977 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
1978 udf_update_tag(epos
->bh
->b_data
,
1979 epos
->offset
+ (inc
? 0 : adsize
));
1981 udf_update_tag(epos
->bh
->b_data
,
1982 sizeof(struct allocExtDesc
));
1983 mark_buffer_dirty_inode(epos
->bh
, inode
);
1989 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
1990 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
1994 struct short_ad
*sad
;
1995 struct long_ad
*lad
;
1996 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1999 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
2000 udf_file_entry_alloc_offset(inode
) +
2003 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2005 switch (iinfo
->i_alloc_type
) {
2006 case ICBTAG_FLAG_AD_SHORT
:
2007 sad
= (struct short_ad
*)ptr
;
2008 sad
->extLength
= cpu_to_le32(elen
);
2009 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
2010 adsize
= sizeof(struct short_ad
);
2012 case ICBTAG_FLAG_AD_LONG
:
2013 lad
= (struct long_ad
*)ptr
;
2014 lad
->extLength
= cpu_to_le32(elen
);
2015 lad
->extLocation
= cpu_to_lelb(*eloc
);
2016 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
2017 adsize
= sizeof(struct long_ad
);
2024 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2025 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
2026 struct allocExtDesc
*aed
=
2027 (struct allocExtDesc
*)epos
->bh
->b_data
;
2028 udf_update_tag(epos
->bh
->b_data
,
2029 le32_to_cpu(aed
->lengthAllocDescs
) +
2030 sizeof(struct allocExtDesc
));
2032 mark_buffer_dirty_inode(epos
->bh
, inode
);
2034 mark_inode_dirty(inode
);
2038 epos
->offset
+= adsize
;
2041 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
2042 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2046 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
2047 (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
2049 epos
->block
= *eloc
;
2050 epos
->offset
= sizeof(struct allocExtDesc
);
2052 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
2053 epos
->bh
= udf_tread(inode
->i_sb
, block
);
2055 udf_debug("reading block %d failed!\n", block
);
2063 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
2064 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2069 struct short_ad
*sad
;
2070 struct long_ad
*lad
;
2071 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2075 epos
->offset
= udf_file_entry_alloc_offset(inode
);
2076 ptr
= iinfo
->i_ext
.i_data
+ epos
->offset
-
2077 udf_file_entry_alloc_offset(inode
) +
2079 alen
= udf_file_entry_alloc_offset(inode
) +
2083 epos
->offset
= sizeof(struct allocExtDesc
);
2084 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2085 alen
= sizeof(struct allocExtDesc
) +
2086 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
2090 switch (iinfo
->i_alloc_type
) {
2091 case ICBTAG_FLAG_AD_SHORT
:
2092 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
2095 etype
= le32_to_cpu(sad
->extLength
) >> 30;
2096 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
2097 eloc
->partitionReferenceNum
=
2098 iinfo
->i_location
.partitionReferenceNum
;
2099 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2101 case ICBTAG_FLAG_AD_LONG
:
2102 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
2105 etype
= le32_to_cpu(lad
->extLength
) >> 30;
2106 *eloc
= lelb_to_cpu(lad
->extLocation
);
2107 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2110 udf_debug("alloc_type = %d unsupported\n", iinfo
->i_alloc_type
);
2117 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
2118 struct kernel_lb_addr neloc
, uint32_t nelen
)
2120 struct kernel_lb_addr oeloc
;
2127 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2128 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2130 nelen
= (etype
<< 30) | oelen
;
2132 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2135 return (nelen
>> 30);
2138 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
,
2139 struct kernel_lb_addr eloc
, uint32_t elen
)
2141 struct extent_position oepos
;
2144 struct allocExtDesc
*aed
;
2145 struct udf_inode_info
*iinfo
;
2152 iinfo
= UDF_I(inode
);
2153 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2154 adsize
= sizeof(struct short_ad
);
2155 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2156 adsize
= sizeof(struct long_ad
);
2161 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2164 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2165 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2166 if (oepos
.bh
!= epos
.bh
) {
2167 oepos
.block
= epos
.block
;
2171 oepos
.offset
= epos
.offset
- adsize
;
2174 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2177 if (epos
.bh
!= oepos
.bh
) {
2178 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2179 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2180 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2182 iinfo
->i_lenAlloc
-= (adsize
* 2);
2183 mark_inode_dirty(inode
);
2185 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2186 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2187 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2188 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2189 udf_update_tag(oepos
.bh
->b_data
,
2190 oepos
.offset
- (2 * adsize
));
2192 udf_update_tag(oepos
.bh
->b_data
,
2193 sizeof(struct allocExtDesc
));
2194 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2197 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2199 iinfo
->i_lenAlloc
-= adsize
;
2200 mark_inode_dirty(inode
);
2202 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2203 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2204 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2205 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2206 udf_update_tag(oepos
.bh
->b_data
,
2207 epos
.offset
- adsize
);
2209 udf_update_tag(oepos
.bh
->b_data
,
2210 sizeof(struct allocExtDesc
));
2211 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2218 return (elen
>> 30);
2221 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2222 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2223 uint32_t *elen
, sector_t
*offset
)
2225 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2226 loff_t lbcount
= 0, bcount
=
2227 (loff_t
) block
<< blocksize_bits
;
2229 struct udf_inode_info
*iinfo
;
2231 iinfo
= UDF_I(inode
);
2232 if (!udf_read_extent_cache(inode
, bcount
, &lbcount
, pos
)) {
2234 pos
->block
= iinfo
->i_location
;
2239 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2241 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2242 iinfo
->i_lenExtents
= lbcount
;
2246 } while (lbcount
<= bcount
);
2247 /* update extent cache */
2248 udf_update_extent_cache(inode
, lbcount
- *elen
, pos
, 1);
2249 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2254 long udf_block_map(struct inode
*inode
, sector_t block
)
2256 struct kernel_lb_addr eloc
;
2259 struct extent_position epos
= {};
2262 down_read(&UDF_I(inode
)->i_data_sem
);
2264 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2265 (EXT_RECORDED_ALLOCATED
>> 30))
2266 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2270 up_read(&UDF_I(inode
)->i_data_sem
);
2273 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2274 return udf_fixed_to_variable(ret
);