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/writeback.h>
37 #include <linux/slab.h>
38 #include <linux/crc-itu-t.h>
39 #include <linux/mpage.h>
40 #include <linux/uio.h>
41 #include <linux/bio.h>
46 #define EXTENT_MERGE_SIZE 5
48 #define FE_MAPPED_PERMS (FE_PERM_U_READ | FE_PERM_U_WRITE | FE_PERM_U_EXEC | \
49 FE_PERM_G_READ | FE_PERM_G_WRITE | FE_PERM_G_EXEC | \
50 FE_PERM_O_READ | FE_PERM_O_WRITE | FE_PERM_O_EXEC)
52 #define FE_DELETE_PERMS (FE_PERM_U_DELETE | FE_PERM_G_DELETE | \
55 static umode_t
udf_convert_permissions(struct fileEntry
*);
56 static int udf_update_inode(struct inode
*, int);
57 static int udf_sync_inode(struct inode
*inode
);
58 static int udf_alloc_i_data(struct inode
*inode
, size_t size
);
59 static sector_t
inode_getblk(struct inode
*, sector_t
, int *, int *);
60 static int8_t udf_insert_aext(struct inode
*, struct extent_position
,
61 struct kernel_lb_addr
, uint32_t);
62 static void udf_split_extents(struct inode
*, int *, int, udf_pblk_t
,
63 struct kernel_long_ad
*, int *);
64 static void udf_prealloc_extents(struct inode
*, int, int,
65 struct kernel_long_ad
*, int *);
66 static void udf_merge_extents(struct inode
*, struct kernel_long_ad
*, int *);
67 static void udf_update_extents(struct inode
*, struct kernel_long_ad
*, int,
68 int, 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
)
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
, sizeof(*pos
));
125 iinfo
->cached_extent
.lstart
= estart
;
126 switch (iinfo
->i_alloc_type
) {
127 case ICBTAG_FLAG_AD_SHORT
:
128 iinfo
->cached_extent
.epos
.offset
-= sizeof(struct short_ad
);
130 case ICBTAG_FLAG_AD_LONG
:
131 iinfo
->cached_extent
.epos
.offset
-= sizeof(struct long_ad
);
134 spin_unlock(&iinfo
->i_extent_cache_lock
);
137 void udf_evict_inode(struct inode
*inode
)
139 struct udf_inode_info
*iinfo
= UDF_I(inode
);
142 if (!is_bad_inode(inode
)) {
143 if (!inode
->i_nlink
) {
145 udf_setsize(inode
, 0);
146 udf_update_inode(inode
, IS_SYNC(inode
));
148 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
&&
149 inode
->i_size
!= iinfo
->i_lenExtents
) {
150 udf_warn(inode
->i_sb
,
151 "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
152 inode
->i_ino
, inode
->i_mode
,
153 (unsigned long long)inode
->i_size
,
154 (unsigned long long)iinfo
->i_lenExtents
);
157 truncate_inode_pages_final(&inode
->i_data
);
158 invalidate_inode_buffers(inode
);
160 kfree(iinfo
->i_data
);
161 iinfo
->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 void udf_readahead(struct readahead_control
*rac
)
203 mpage_readahead(rac
, udf_get_block
);
206 static int udf_write_begin(struct file
*file
, struct address_space
*mapping
,
207 loff_t pos
, unsigned len
, unsigned flags
,
208 struct page
**pagep
, void **fsdata
)
212 ret
= block_write_begin(mapping
, pos
, len
, flags
, pagep
, udf_get_block
);
214 udf_write_failed(mapping
, pos
+ len
);
218 static ssize_t
udf_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
220 struct file
*file
= iocb
->ki_filp
;
221 struct address_space
*mapping
= file
->f_mapping
;
222 struct inode
*inode
= mapping
->host
;
223 size_t count
= iov_iter_count(iter
);
226 ret
= blockdev_direct_IO(iocb
, inode
, iter
, udf_get_block
);
227 if (unlikely(ret
< 0 && iov_iter_rw(iter
) == WRITE
))
228 udf_write_failed(mapping
, iocb
->ki_pos
+ count
);
232 static sector_t
udf_bmap(struct address_space
*mapping
, sector_t block
)
234 return generic_block_bmap(mapping
, block
, udf_get_block
);
237 const struct address_space_operations udf_aops
= {
238 .set_page_dirty
= __set_page_dirty_buffers
,
239 .readpage
= udf_readpage
,
240 .readahead
= udf_readahead
,
241 .writepage
= udf_writepage
,
242 .writepages
= udf_writepages
,
243 .write_begin
= udf_write_begin
,
244 .write_end
= generic_write_end
,
245 .direct_IO
= udf_direct_IO
,
250 * Expand file stored in ICB to a normal one-block-file
252 * This function requires i_data_sem for writing and releases it.
253 * This function requires i_mutex held
255 int udf_expand_file_adinicb(struct inode
*inode
)
259 struct udf_inode_info
*iinfo
= UDF_I(inode
);
261 struct writeback_control udf_wbc
= {
262 .sync_mode
= WB_SYNC_NONE
,
266 WARN_ON_ONCE(!inode_is_locked(inode
));
267 if (!iinfo
->i_lenAlloc
) {
268 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
269 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
271 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
272 /* from now on we have normal address_space methods */
273 inode
->i_data
.a_ops
= &udf_aops
;
274 up_write(&iinfo
->i_data_sem
);
275 mark_inode_dirty(inode
);
279 * Release i_data_sem so that we can lock a page - page lock ranks
280 * above i_data_sem. i_mutex still protects us against file changes.
282 up_write(&iinfo
->i_data_sem
);
284 page
= find_or_create_page(inode
->i_mapping
, 0, GFP_NOFS
);
288 if (!PageUptodate(page
)) {
289 kaddr
= kmap_atomic(page
);
290 memset(kaddr
+ iinfo
->i_lenAlloc
, 0x00,
291 PAGE_SIZE
- iinfo
->i_lenAlloc
);
292 memcpy(kaddr
, iinfo
->i_data
+ iinfo
->i_lenEAttr
,
294 flush_dcache_page(page
);
295 SetPageUptodate(page
);
296 kunmap_atomic(kaddr
);
298 down_write(&iinfo
->i_data_sem
);
299 memset(iinfo
->i_data
+ iinfo
->i_lenEAttr
, 0x00,
301 iinfo
->i_lenAlloc
= 0;
302 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
303 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_SHORT
;
305 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_LONG
;
306 /* from now on we have normal address_space methods */
307 inode
->i_data
.a_ops
= &udf_aops
;
308 up_write(&iinfo
->i_data_sem
);
309 err
= inode
->i_data
.a_ops
->writepage(page
, &udf_wbc
);
311 /* Restore everything back so that we don't lose data... */
313 down_write(&iinfo
->i_data_sem
);
314 kaddr
= kmap_atomic(page
);
315 memcpy(iinfo
->i_data
+ iinfo
->i_lenEAttr
, kaddr
, inode
->i_size
);
316 kunmap_atomic(kaddr
);
318 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
319 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
320 up_write(&iinfo
->i_data_sem
);
323 mark_inode_dirty(inode
);
328 struct buffer_head
*udf_expand_dir_adinicb(struct inode
*inode
,
329 udf_pblk_t
*block
, int *err
)
332 struct buffer_head
*dbh
= NULL
;
333 struct kernel_lb_addr eloc
;
335 struct extent_position epos
;
337 struct udf_fileident_bh sfibh
, dfibh
;
338 loff_t f_pos
= udf_ext0_offset(inode
);
339 int size
= udf_ext0_offset(inode
) + inode
->i_size
;
340 struct fileIdentDesc cfi
, *sfi
, *dfi
;
341 struct udf_inode_info
*iinfo
= UDF_I(inode
);
343 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_USE_SHORT_AD
))
344 alloctype
= ICBTAG_FLAG_AD_SHORT
;
346 alloctype
= ICBTAG_FLAG_AD_LONG
;
348 if (!inode
->i_size
) {
349 iinfo
->i_alloc_type
= alloctype
;
350 mark_inode_dirty(inode
);
354 /* alloc block, and copy data to it */
355 *block
= udf_new_block(inode
->i_sb
, inode
,
356 iinfo
->i_location
.partitionReferenceNum
,
357 iinfo
->i_location
.logicalBlockNum
, err
);
360 newblock
= udf_get_pblock(inode
->i_sb
, *block
,
361 iinfo
->i_location
.partitionReferenceNum
,
365 dbh
= udf_tgetblk(inode
->i_sb
, newblock
);
369 memset(dbh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
370 set_buffer_uptodate(dbh
);
372 mark_buffer_dirty_inode(dbh
, inode
);
374 sfibh
.soffset
= sfibh
.eoffset
=
375 f_pos
& (inode
->i_sb
->s_blocksize
- 1);
376 sfibh
.sbh
= sfibh
.ebh
= NULL
;
377 dfibh
.soffset
= dfibh
.eoffset
= 0;
378 dfibh
.sbh
= dfibh
.ebh
= dbh
;
379 while (f_pos
< size
) {
380 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
381 sfi
= udf_fileident_read(inode
, &f_pos
, &sfibh
, &cfi
, NULL
,
387 iinfo
->i_alloc_type
= alloctype
;
388 sfi
->descTag
.tagLocation
= cpu_to_le32(*block
);
389 dfibh
.soffset
= dfibh
.eoffset
;
390 dfibh
.eoffset
+= (sfibh
.eoffset
- sfibh
.soffset
);
391 dfi
= (struct fileIdentDesc
*)(dbh
->b_data
+ dfibh
.soffset
);
392 if (udf_write_fi(inode
, sfi
, dfi
, &dfibh
, sfi
->impUse
,
393 udf_get_fi_ident(sfi
))) {
394 iinfo
->i_alloc_type
= ICBTAG_FLAG_AD_IN_ICB
;
399 mark_buffer_dirty_inode(dbh
, inode
);
401 memset(iinfo
->i_data
+ iinfo
->i_lenEAttr
, 0, iinfo
->i_lenAlloc
);
402 iinfo
->i_lenAlloc
= 0;
403 eloc
.logicalBlockNum
= *block
;
404 eloc
.partitionReferenceNum
=
405 iinfo
->i_location
.partitionReferenceNum
;
406 iinfo
->i_lenExtents
= inode
->i_size
;
408 epos
.block
= iinfo
->i_location
;
409 epos
.offset
= udf_file_entry_alloc_offset(inode
);
410 udf_add_aext(inode
, &epos
, &eloc
, inode
->i_size
, 0);
414 mark_inode_dirty(inode
);
418 static int udf_get_block(struct inode
*inode
, sector_t block
,
419 struct buffer_head
*bh_result
, int create
)
423 struct udf_inode_info
*iinfo
;
426 phys
= udf_block_map(inode
, block
);
428 map_bh(bh_result
, inode
->i_sb
, phys
);
434 iinfo
= UDF_I(inode
);
436 down_write(&iinfo
->i_data_sem
);
437 if (block
== iinfo
->i_next_alloc_block
+ 1) {
438 iinfo
->i_next_alloc_block
++;
439 iinfo
->i_next_alloc_goal
++;
442 udf_clear_extent_cache(inode
);
443 phys
= inode_getblk(inode
, block
, &err
, &new);
448 set_buffer_new(bh_result
);
449 map_bh(bh_result
, inode
->i_sb
, phys
);
452 up_write(&iinfo
->i_data_sem
);
456 static struct buffer_head
*udf_getblk(struct inode
*inode
, udf_pblk_t block
,
457 int create
, int *err
)
459 struct buffer_head
*bh
;
460 struct buffer_head dummy
;
463 dummy
.b_blocknr
= -1000;
464 *err
= udf_get_block(inode
, block
, &dummy
, create
);
465 if (!*err
&& buffer_mapped(&dummy
)) {
466 bh
= sb_getblk(inode
->i_sb
, dummy
.b_blocknr
);
467 if (buffer_new(&dummy
)) {
469 memset(bh
->b_data
, 0x00, inode
->i_sb
->s_blocksize
);
470 set_buffer_uptodate(bh
);
472 mark_buffer_dirty_inode(bh
, inode
);
480 /* Extend the file with new blocks totaling 'new_block_bytes',
481 * return the number of extents added
483 static int udf_do_extend_file(struct inode
*inode
,
484 struct extent_position
*last_pos
,
485 struct kernel_long_ad
*last_ext
,
486 loff_t new_block_bytes
)
489 int count
= 0, fake
= !(last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
490 struct super_block
*sb
= inode
->i_sb
;
491 struct kernel_lb_addr prealloc_loc
= {};
492 uint32_t prealloc_len
= 0;
493 struct udf_inode_info
*iinfo
;
496 /* The previous extent is fake and we should not extend by anything
497 * - there's nothing to do... */
498 if (!new_block_bytes
&& fake
)
501 iinfo
= UDF_I(inode
);
502 /* Round the last extent up to a multiple of block size */
503 if (last_ext
->extLength
& (sb
->s_blocksize
- 1)) {
504 last_ext
->extLength
=
505 (last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) |
506 (((last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
507 sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1));
508 iinfo
->i_lenExtents
=
509 (iinfo
->i_lenExtents
+ sb
->s_blocksize
- 1) &
510 ~(sb
->s_blocksize
- 1);
513 /* Last extent are just preallocated blocks? */
514 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
515 EXT_NOT_RECORDED_ALLOCATED
) {
516 /* Save the extent so that we can reattach it to the end */
517 prealloc_loc
= last_ext
->extLocation
;
518 prealloc_len
= last_ext
->extLength
;
519 /* Mark the extent as a hole */
520 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
521 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
522 last_ext
->extLocation
.logicalBlockNum
= 0;
523 last_ext
->extLocation
.partitionReferenceNum
= 0;
526 /* Can we merge with the previous extent? */
527 if ((last_ext
->extLength
& UDF_EXTENT_FLAG_MASK
) ==
528 EXT_NOT_RECORDED_NOT_ALLOCATED
) {
529 add
= (1 << 30) - sb
->s_blocksize
-
530 (last_ext
->extLength
& UDF_EXTENT_LENGTH_MASK
);
531 if (add
> new_block_bytes
)
532 add
= new_block_bytes
;
533 new_block_bytes
-= add
;
534 last_ext
->extLength
+= add
;
538 udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
539 last_ext
->extLength
, 1);
542 struct kernel_lb_addr tmploc
;
545 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
546 last_ext
->extLength
, 1);
549 * We've rewritten the last extent. If we are going to add
550 * more extents, we may need to enter possible following
551 * empty indirect extent.
553 if (new_block_bytes
|| prealloc_len
)
554 udf_next_aext(inode
, last_pos
, &tmploc
, &tmplen
, 0);
557 /* Managed to do everything necessary? */
558 if (!new_block_bytes
)
561 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
562 last_ext
->extLocation
.logicalBlockNum
= 0;
563 last_ext
->extLocation
.partitionReferenceNum
= 0;
564 add
= (1 << 30) - sb
->s_blocksize
;
565 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
| add
;
567 /* Create enough extents to cover the whole hole */
568 while (new_block_bytes
> add
) {
569 new_block_bytes
-= add
;
570 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
571 last_ext
->extLength
, 1);
576 if (new_block_bytes
) {
577 last_ext
->extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
579 err
= udf_add_aext(inode
, last_pos
, &last_ext
->extLocation
,
580 last_ext
->extLength
, 1);
587 /* Do we have some preallocated blocks saved? */
589 err
= udf_add_aext(inode
, last_pos
, &prealloc_loc
,
593 last_ext
->extLocation
= prealloc_loc
;
594 last_ext
->extLength
= prealloc_len
;
598 /* last_pos should point to the last written extent... */
599 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
600 last_pos
->offset
-= sizeof(struct short_ad
);
601 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
602 last_pos
->offset
-= sizeof(struct long_ad
);
609 /* Extend the final block of the file to final_block_len bytes */
610 static void udf_do_extend_final_block(struct inode
*inode
,
611 struct extent_position
*last_pos
,
612 struct kernel_long_ad
*last_ext
,
613 uint32_t final_block_len
)
615 struct super_block
*sb
= inode
->i_sb
;
616 uint32_t added_bytes
;
618 added_bytes
= final_block_len
-
619 (last_ext
->extLength
& (sb
->s_blocksize
- 1));
620 last_ext
->extLength
+= added_bytes
;
621 UDF_I(inode
)->i_lenExtents
+= added_bytes
;
623 udf_write_aext(inode
, last_pos
, &last_ext
->extLocation
,
624 last_ext
->extLength
, 1);
627 static int udf_extend_file(struct inode
*inode
, loff_t newsize
)
630 struct extent_position epos
;
631 struct kernel_lb_addr eloc
;
634 struct super_block
*sb
= inode
->i_sb
;
635 sector_t first_block
= newsize
>> sb
->s_blocksize_bits
, offset
;
636 unsigned long partial_final_block
;
638 struct udf_inode_info
*iinfo
= UDF_I(inode
);
639 struct kernel_long_ad extent
;
641 int within_final_block
;
643 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
644 adsize
= sizeof(struct short_ad
);
645 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
646 adsize
= sizeof(struct long_ad
);
650 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
651 within_final_block
= (etype
!= -1);
653 if ((!epos
.bh
&& epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
654 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
655 /* File has no extents at all or has empty last
656 * indirect extent! Create a fake extent... */
657 extent
.extLocation
.logicalBlockNum
= 0;
658 extent
.extLocation
.partitionReferenceNum
= 0;
659 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
661 epos
.offset
-= adsize
;
662 etype
= udf_next_aext(inode
, &epos
, &extent
.extLocation
,
663 &extent
.extLength
, 0);
664 extent
.extLength
|= etype
<< 30;
667 partial_final_block
= newsize
& (sb
->s_blocksize
- 1);
669 /* File has extent covering the new size (could happen when extending
672 if (within_final_block
) {
673 /* Extending file within the last file block */
674 udf_do_extend_final_block(inode
, &epos
, &extent
,
675 partial_final_block
);
677 loff_t add
= ((loff_t
)offset
<< sb
->s_blocksize_bits
) |
679 err
= udf_do_extend_file(inode
, &epos
, &extent
, add
);
685 iinfo
->i_lenExtents
= newsize
;
691 static sector_t
inode_getblk(struct inode
*inode
, sector_t block
,
694 struct kernel_long_ad laarr
[EXTENT_MERGE_SIZE
];
695 struct extent_position prev_epos
, cur_epos
, next_epos
;
696 int count
= 0, startnum
= 0, endnum
= 0;
697 uint32_t elen
= 0, tmpelen
;
698 struct kernel_lb_addr eloc
, tmpeloc
;
700 loff_t lbcount
= 0, b_off
= 0;
701 udf_pblk_t newblocknum
, newblock
;
704 struct udf_inode_info
*iinfo
= UDF_I(inode
);
705 udf_pblk_t goal
= 0, pgoal
= iinfo
->i_location
.logicalBlockNum
;
711 prev_epos
.offset
= udf_file_entry_alloc_offset(inode
);
712 prev_epos
.block
= iinfo
->i_location
;
714 cur_epos
= next_epos
= prev_epos
;
715 b_off
= (loff_t
)block
<< inode
->i_sb
->s_blocksize_bits
;
717 /* find the extent which contains the block we are looking for.
718 alternate between laarr[0] and laarr[1] for locations of the
719 current extent, and the previous extent */
721 if (prev_epos
.bh
!= cur_epos
.bh
) {
722 brelse(prev_epos
.bh
);
724 prev_epos
.bh
= cur_epos
.bh
;
726 if (cur_epos
.bh
!= next_epos
.bh
) {
728 get_bh(next_epos
.bh
);
729 cur_epos
.bh
= next_epos
.bh
;
734 prev_epos
.block
= cur_epos
.block
;
735 cur_epos
.block
= next_epos
.block
;
737 prev_epos
.offset
= cur_epos
.offset
;
738 cur_epos
.offset
= next_epos
.offset
;
740 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 1);
746 laarr
[c
].extLength
= (etype
<< 30) | elen
;
747 laarr
[c
].extLocation
= eloc
;
749 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
750 pgoal
= eloc
.logicalBlockNum
+
751 ((elen
+ inode
->i_sb
->s_blocksize
- 1) >>
752 inode
->i_sb
->s_blocksize_bits
);
755 } while (lbcount
+ elen
<= b_off
);
758 offset
= b_off
>> inode
->i_sb
->s_blocksize_bits
;
760 * Move prev_epos and cur_epos into indirect extent if we are at
763 udf_next_aext(inode
, &prev_epos
, &tmpeloc
, &tmpelen
, 0);
764 udf_next_aext(inode
, &cur_epos
, &tmpeloc
, &tmpelen
, 0);
766 /* if the extent is allocated and recorded, return the block
767 if the extent is not a multiple of the blocksize, round up */
769 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30)) {
770 if (elen
& (inode
->i_sb
->s_blocksize
- 1)) {
771 elen
= EXT_RECORDED_ALLOCATED
|
772 ((elen
+ inode
->i_sb
->s_blocksize
- 1) &
773 ~(inode
->i_sb
->s_blocksize
- 1));
774 udf_write_aext(inode
, &cur_epos
, &eloc
, elen
, 1);
776 newblock
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
780 /* Are we beyond EOF? */
790 /* Create a fake extent when there's not one */
791 memset(&laarr
[0].extLocation
, 0x00,
792 sizeof(struct kernel_lb_addr
));
793 laarr
[0].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
794 /* Will udf_do_extend_file() create real extent from
796 startnum
= (offset
> 0);
798 /* Create extents for the hole between EOF and offset */
799 hole_len
= (loff_t
)offset
<< inode
->i_blkbits
;
800 ret
= udf_do_extend_file(inode
, &prev_epos
, laarr
, hole_len
);
809 /* We are not covered by a preallocated extent? */
810 if ((laarr
[0].extLength
& UDF_EXTENT_FLAG_MASK
) !=
811 EXT_NOT_RECORDED_ALLOCATED
) {
812 /* Is there any real extent? - otherwise we overwrite
816 laarr
[c
].extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
|
817 inode
->i_sb
->s_blocksize
;
818 memset(&laarr
[c
].extLocation
, 0x00,
819 sizeof(struct kernel_lb_addr
));
826 endnum
= startnum
= ((count
> 2) ? 2 : count
);
828 /* if the current extent is in position 0,
829 swap it with the previous */
830 if (!c
&& count
!= 1) {
837 /* if the current block is located in an extent,
838 read the next extent */
839 etype
= udf_next_aext(inode
, &next_epos
, &eloc
, &elen
, 0);
841 laarr
[c
+ 1].extLength
= (etype
<< 30) | elen
;
842 laarr
[c
+ 1].extLocation
= eloc
;
850 /* if the current extent is not recorded but allocated, get the
851 * block in the extent corresponding to the requested block */
852 if ((laarr
[c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30))
853 newblocknum
= laarr
[c
].extLocation
.logicalBlockNum
+ offset
;
854 else { /* otherwise, allocate a new block */
855 if (iinfo
->i_next_alloc_block
== block
)
856 goal
= iinfo
->i_next_alloc_goal
;
859 if (!(goal
= pgoal
)) /* XXX: what was intended here? */
860 goal
= iinfo
->i_location
.logicalBlockNum
+ 1;
863 newblocknum
= udf_new_block(inode
->i_sb
, inode
,
864 iinfo
->i_location
.partitionReferenceNum
,
872 iinfo
->i_lenExtents
+= inode
->i_sb
->s_blocksize
;
875 /* if the extent the requsted block is located in contains multiple
876 * blocks, split the extent into at most three extents. blocks prior
877 * to requested block, requested block, and blocks after requested
879 udf_split_extents(inode
, &c
, offset
, newblocknum
, laarr
, &endnum
);
881 /* We preallocate blocks only for regular files. It also makes sense
882 * for directories but there's a problem when to drop the
883 * preallocation. We might use some delayed work for that but I feel
884 * it's overengineering for a filesystem like UDF. */
885 if (S_ISREG(inode
->i_mode
))
886 udf_prealloc_extents(inode
, c
, lastblock
, laarr
, &endnum
);
888 /* merge any continuous blocks in laarr */
889 udf_merge_extents(inode
, laarr
, &endnum
);
891 /* write back the new extents, inserting new extents if the new number
892 * of extents is greater than the old number, and deleting extents if
893 * the new number of extents is less than the old number */
894 udf_update_extents(inode
, laarr
, startnum
, endnum
, &prev_epos
);
896 newblock
= udf_get_pblock(inode
->i_sb
, newblocknum
,
897 iinfo
->i_location
.partitionReferenceNum
, 0);
903 iinfo
->i_next_alloc_block
= block
;
904 iinfo
->i_next_alloc_goal
= newblocknum
;
905 inode
->i_ctime
= current_time(inode
);
908 udf_sync_inode(inode
);
910 mark_inode_dirty(inode
);
912 brelse(prev_epos
.bh
);
914 brelse(next_epos
.bh
);
918 static void udf_split_extents(struct inode
*inode
, int *c
, int offset
,
919 udf_pblk_t newblocknum
,
920 struct kernel_long_ad
*laarr
, int *endnum
)
922 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
923 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
925 if ((laarr
[*c
].extLength
>> 30) == (EXT_NOT_RECORDED_ALLOCATED
>> 30) ||
926 (laarr
[*c
].extLength
>> 30) ==
927 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
929 int blen
= ((laarr
[curr
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
930 blocksize
- 1) >> blocksize_bits
;
931 int8_t etype
= (laarr
[curr
].extLength
>> 30);
935 else if (!offset
|| blen
== offset
+ 1) {
936 laarr
[curr
+ 2] = laarr
[curr
+ 1];
937 laarr
[curr
+ 1] = laarr
[curr
];
939 laarr
[curr
+ 3] = laarr
[curr
+ 1];
940 laarr
[curr
+ 2] = laarr
[curr
+ 1] = laarr
[curr
];
944 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
945 udf_free_blocks(inode
->i_sb
, inode
,
946 &laarr
[curr
].extLocation
,
948 laarr
[curr
].extLength
=
949 EXT_NOT_RECORDED_NOT_ALLOCATED
|
950 (offset
<< blocksize_bits
);
951 laarr
[curr
].extLocation
.logicalBlockNum
= 0;
952 laarr
[curr
].extLocation
.
953 partitionReferenceNum
= 0;
955 laarr
[curr
].extLength
= (etype
<< 30) |
956 (offset
<< blocksize_bits
);
962 laarr
[curr
].extLocation
.logicalBlockNum
= newblocknum
;
963 if (etype
== (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
964 laarr
[curr
].extLocation
.partitionReferenceNum
=
965 UDF_I(inode
)->i_location
.partitionReferenceNum
;
966 laarr
[curr
].extLength
= EXT_RECORDED_ALLOCATED
|
970 if (blen
!= offset
+ 1) {
971 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30))
972 laarr
[curr
].extLocation
.logicalBlockNum
+=
974 laarr
[curr
].extLength
= (etype
<< 30) |
975 ((blen
- (offset
+ 1)) << blocksize_bits
);
982 static void udf_prealloc_extents(struct inode
*inode
, int c
, int lastblock
,
983 struct kernel_long_ad
*laarr
,
986 int start
, length
= 0, currlength
= 0, i
;
988 if (*endnum
>= (c
+ 1)) {
994 if ((laarr
[c
+ 1].extLength
>> 30) ==
995 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
997 length
= currlength
=
998 (((laarr
[c
+ 1].extLength
&
999 UDF_EXTENT_LENGTH_MASK
) +
1000 inode
->i_sb
->s_blocksize
- 1) >>
1001 inode
->i_sb
->s_blocksize_bits
);
1006 for (i
= start
+ 1; i
<= *endnum
; i
++) {
1009 length
+= UDF_DEFAULT_PREALLOC_BLOCKS
;
1010 } else if ((laarr
[i
].extLength
>> 30) ==
1011 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) {
1012 length
+= (((laarr
[i
].extLength
&
1013 UDF_EXTENT_LENGTH_MASK
) +
1014 inode
->i_sb
->s_blocksize
- 1) >>
1015 inode
->i_sb
->s_blocksize_bits
);
1021 int next
= laarr
[start
].extLocation
.logicalBlockNum
+
1022 (((laarr
[start
].extLength
& UDF_EXTENT_LENGTH_MASK
) +
1023 inode
->i_sb
->s_blocksize
- 1) >>
1024 inode
->i_sb
->s_blocksize_bits
);
1025 int numalloc
= udf_prealloc_blocks(inode
->i_sb
, inode
,
1026 laarr
[start
].extLocation
.partitionReferenceNum
,
1027 next
, (UDF_DEFAULT_PREALLOC_BLOCKS
> length
?
1028 length
: UDF_DEFAULT_PREALLOC_BLOCKS
) -
1031 if (start
== (c
+ 1))
1032 laarr
[start
].extLength
+=
1034 inode
->i_sb
->s_blocksize_bits
);
1036 memmove(&laarr
[c
+ 2], &laarr
[c
+ 1],
1037 sizeof(struct long_ad
) * (*endnum
- (c
+ 1)));
1039 laarr
[c
+ 1].extLocation
.logicalBlockNum
= next
;
1040 laarr
[c
+ 1].extLocation
.partitionReferenceNum
=
1041 laarr
[c
].extLocation
.
1042 partitionReferenceNum
;
1043 laarr
[c
+ 1].extLength
=
1044 EXT_NOT_RECORDED_ALLOCATED
|
1046 inode
->i_sb
->s_blocksize_bits
);
1050 for (i
= start
+ 1; numalloc
&& i
< *endnum
; i
++) {
1051 int elen
= ((laarr
[i
].extLength
&
1052 UDF_EXTENT_LENGTH_MASK
) +
1053 inode
->i_sb
->s_blocksize
- 1) >>
1054 inode
->i_sb
->s_blocksize_bits
;
1056 if (elen
> numalloc
) {
1057 laarr
[i
].extLength
-=
1059 inode
->i_sb
->s_blocksize_bits
);
1063 if (*endnum
> (i
+ 1))
1066 sizeof(struct long_ad
) *
1067 (*endnum
- (i
+ 1)));
1072 UDF_I(inode
)->i_lenExtents
+=
1073 numalloc
<< inode
->i_sb
->s_blocksize_bits
;
1078 static void udf_merge_extents(struct inode
*inode
, struct kernel_long_ad
*laarr
,
1082 unsigned long blocksize
= inode
->i_sb
->s_blocksize
;
1083 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1085 for (i
= 0; i
< (*endnum
- 1); i
++) {
1086 struct kernel_long_ad
*li
/*l[i]*/ = &laarr
[i
];
1087 struct kernel_long_ad
*lip1
/*l[i plus 1]*/ = &laarr
[i
+ 1];
1089 if (((li
->extLength
>> 30) == (lip1
->extLength
>> 30)) &&
1090 (((li
->extLength
>> 30) ==
1091 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30)) ||
1092 ((lip1
->extLocation
.logicalBlockNum
-
1093 li
->extLocation
.logicalBlockNum
) ==
1094 (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1095 blocksize
- 1) >> blocksize_bits
)))) {
1097 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1098 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1099 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1100 lip1
->extLength
= (lip1
->extLength
-
1102 UDF_EXTENT_LENGTH_MASK
) +
1103 UDF_EXTENT_LENGTH_MASK
) &
1105 li
->extLength
= (li
->extLength
&
1106 UDF_EXTENT_FLAG_MASK
) +
1107 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1109 lip1
->extLocation
.logicalBlockNum
=
1110 li
->extLocation
.logicalBlockNum
+
1112 UDF_EXTENT_LENGTH_MASK
) >>
1115 li
->extLength
= lip1
->extLength
+
1117 UDF_EXTENT_LENGTH_MASK
) +
1118 blocksize
- 1) & ~(blocksize
- 1));
1119 if (*endnum
> (i
+ 2))
1120 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1121 sizeof(struct long_ad
) *
1122 (*endnum
- (i
+ 2)));
1126 } else if (((li
->extLength
>> 30) ==
1127 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) &&
1128 ((lip1
->extLength
>> 30) ==
1129 (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))) {
1130 udf_free_blocks(inode
->i_sb
, inode
, &li
->extLocation
, 0,
1132 UDF_EXTENT_LENGTH_MASK
) +
1133 blocksize
- 1) >> blocksize_bits
);
1134 li
->extLocation
.logicalBlockNum
= 0;
1135 li
->extLocation
.partitionReferenceNum
= 0;
1137 if (((li
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1138 (lip1
->extLength
& UDF_EXTENT_LENGTH_MASK
) +
1139 blocksize
- 1) & ~UDF_EXTENT_LENGTH_MASK
) {
1140 lip1
->extLength
= (lip1
->extLength
-
1142 UDF_EXTENT_LENGTH_MASK
) +
1143 UDF_EXTENT_LENGTH_MASK
) &
1145 li
->extLength
= (li
->extLength
&
1146 UDF_EXTENT_FLAG_MASK
) +
1147 (UDF_EXTENT_LENGTH_MASK
+ 1) -
1150 li
->extLength
= lip1
->extLength
+
1152 UDF_EXTENT_LENGTH_MASK
) +
1153 blocksize
- 1) & ~(blocksize
- 1));
1154 if (*endnum
> (i
+ 2))
1155 memmove(&laarr
[i
+ 1], &laarr
[i
+ 2],
1156 sizeof(struct long_ad
) *
1157 (*endnum
- (i
+ 2)));
1161 } else if ((li
->extLength
>> 30) ==
1162 (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
1163 udf_free_blocks(inode
->i_sb
, inode
,
1164 &li
->extLocation
, 0,
1166 UDF_EXTENT_LENGTH_MASK
) +
1167 blocksize
- 1) >> blocksize_bits
);
1168 li
->extLocation
.logicalBlockNum
= 0;
1169 li
->extLocation
.partitionReferenceNum
= 0;
1170 li
->extLength
= (li
->extLength
&
1171 UDF_EXTENT_LENGTH_MASK
) |
1172 EXT_NOT_RECORDED_NOT_ALLOCATED
;
1177 static void udf_update_extents(struct inode
*inode
, struct kernel_long_ad
*laarr
,
1178 int startnum
, int endnum
,
1179 struct extent_position
*epos
)
1182 struct kernel_lb_addr tmploc
;
1185 if (startnum
> endnum
) {
1186 for (i
= 0; i
< (startnum
- endnum
); i
++)
1187 udf_delete_aext(inode
, *epos
);
1188 } else if (startnum
< endnum
) {
1189 for (i
= 0; i
< (endnum
- startnum
); i
++) {
1190 udf_insert_aext(inode
, *epos
, laarr
[i
].extLocation
,
1191 laarr
[i
].extLength
);
1192 udf_next_aext(inode
, epos
, &laarr
[i
].extLocation
,
1193 &laarr
[i
].extLength
, 1);
1198 for (i
= start
; i
< endnum
; i
++) {
1199 udf_next_aext(inode
, epos
, &tmploc
, &tmplen
, 0);
1200 udf_write_aext(inode
, epos
, &laarr
[i
].extLocation
,
1201 laarr
[i
].extLength
, 1);
1205 struct buffer_head
*udf_bread(struct inode
*inode
, udf_pblk_t block
,
1206 int create
, int *err
)
1208 struct buffer_head
*bh
= NULL
;
1210 bh
= udf_getblk(inode
, block
, create
, err
);
1214 if (buffer_uptodate(bh
))
1217 ll_rw_block(REQ_OP_READ
, 0, 1, &bh
);
1220 if (buffer_uptodate(bh
))
1228 int udf_setsize(struct inode
*inode
, loff_t newsize
)
1231 struct udf_inode_info
*iinfo
;
1232 unsigned int bsize
= i_blocksize(inode
);
1234 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
) ||
1235 S_ISLNK(inode
->i_mode
)))
1237 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1240 iinfo
= UDF_I(inode
);
1241 if (newsize
> inode
->i_size
) {
1242 down_write(&iinfo
->i_data_sem
);
1243 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1245 (udf_file_entry_alloc_offset(inode
) + newsize
)) {
1246 err
= udf_expand_file_adinicb(inode
);
1249 down_write(&iinfo
->i_data_sem
);
1251 iinfo
->i_lenAlloc
= newsize
;
1255 err
= udf_extend_file(inode
, newsize
);
1257 up_write(&iinfo
->i_data_sem
);
1261 up_write(&iinfo
->i_data_sem
);
1262 truncate_setsize(inode
, newsize
);
1264 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1265 down_write(&iinfo
->i_data_sem
);
1266 udf_clear_extent_cache(inode
);
1267 memset(iinfo
->i_data
+ iinfo
->i_lenEAttr
+ newsize
,
1268 0x00, bsize
- newsize
-
1269 udf_file_entry_alloc_offset(inode
));
1270 iinfo
->i_lenAlloc
= newsize
;
1271 truncate_setsize(inode
, newsize
);
1272 up_write(&iinfo
->i_data_sem
);
1275 err
= block_truncate_page(inode
->i_mapping
, newsize
,
1279 truncate_setsize(inode
, newsize
);
1280 down_write(&iinfo
->i_data_sem
);
1281 udf_clear_extent_cache(inode
);
1282 err
= udf_truncate_extents(inode
);
1283 up_write(&iinfo
->i_data_sem
);
1288 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1290 udf_sync_inode(inode
);
1292 mark_inode_dirty(inode
);
1297 * Maximum length of linked list formed by ICB hierarchy. The chosen number is
1298 * arbitrary - just that we hopefully don't limit any real use of rewritten
1299 * inode on write-once media but avoid looping for too long on corrupted media.
1301 #define UDF_MAX_ICB_NESTING 1024
1303 static int udf_read_inode(struct inode
*inode
, bool hidden_inode
)
1305 struct buffer_head
*bh
= NULL
;
1306 struct fileEntry
*fe
;
1307 struct extendedFileEntry
*efe
;
1309 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1310 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1311 struct kernel_lb_addr
*iloc
= &iinfo
->i_location
;
1312 unsigned int link_count
;
1313 unsigned int indirections
= 0;
1314 int bs
= inode
->i_sb
->s_blocksize
;
1319 if (iloc
->partitionReferenceNum
>= sbi
->s_partitions
) {
1320 udf_debug("partition reference: %u > logical volume partitions: %u\n",
1321 iloc
->partitionReferenceNum
, sbi
->s_partitions
);
1325 if (iloc
->logicalBlockNum
>=
1326 sbi
->s_partmaps
[iloc
->partitionReferenceNum
].s_partition_len
) {
1327 udf_debug("block=%u, partition=%u out of range\n",
1328 iloc
->logicalBlockNum
, iloc
->partitionReferenceNum
);
1333 * Set defaults, but the inode is still incomplete!
1334 * Note: get_new_inode() sets the following on a new inode:
1337 * i_flags = sb->s_flags
1339 * clean_inode(): zero fills and sets
1344 bh
= udf_read_ptagged(inode
->i_sb
, iloc
, 0, &ident
);
1346 udf_err(inode
->i_sb
, "(ino %lu) failed !bh\n", inode
->i_ino
);
1350 if (ident
!= TAG_IDENT_FE
&& ident
!= TAG_IDENT_EFE
&&
1351 ident
!= TAG_IDENT_USE
) {
1352 udf_err(inode
->i_sb
, "(ino %lu) failed ident=%u\n",
1353 inode
->i_ino
, ident
);
1357 fe
= (struct fileEntry
*)bh
->b_data
;
1358 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1360 if (fe
->icbTag
.strategyType
== cpu_to_le16(4096)) {
1361 struct buffer_head
*ibh
;
1363 ibh
= udf_read_ptagged(inode
->i_sb
, iloc
, 1, &ident
);
1364 if (ident
== TAG_IDENT_IE
&& ibh
) {
1365 struct kernel_lb_addr loc
;
1366 struct indirectEntry
*ie
;
1368 ie
= (struct indirectEntry
*)ibh
->b_data
;
1369 loc
= lelb_to_cpu(ie
->indirectICB
.extLocation
);
1371 if (ie
->indirectICB
.extLength
) {
1373 memcpy(&iinfo
->i_location
, &loc
,
1374 sizeof(struct kernel_lb_addr
));
1375 if (++indirections
> UDF_MAX_ICB_NESTING
) {
1376 udf_err(inode
->i_sb
,
1377 "too many ICBs in ICB hierarchy"
1378 " (max %d supported)\n",
1379 UDF_MAX_ICB_NESTING
);
1387 } else if (fe
->icbTag
.strategyType
!= cpu_to_le16(4)) {
1388 udf_err(inode
->i_sb
, "unsupported strategy type: %u\n",
1389 le16_to_cpu(fe
->icbTag
.strategyType
));
1392 if (fe
->icbTag
.strategyType
== cpu_to_le16(4))
1393 iinfo
->i_strat4096
= 0;
1394 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1395 iinfo
->i_strat4096
= 1;
1397 iinfo
->i_alloc_type
= le16_to_cpu(fe
->icbTag
.flags
) &
1398 ICBTAG_FLAG_AD_MASK
;
1399 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_SHORT
&&
1400 iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_LONG
&&
1401 iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
1405 iinfo
->i_unique
= 0;
1406 iinfo
->i_lenEAttr
= 0;
1407 iinfo
->i_lenExtents
= 0;
1408 iinfo
->i_lenAlloc
= 0;
1409 iinfo
->i_next_alloc_block
= 0;
1410 iinfo
->i_next_alloc_goal
= 0;
1411 if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_EFE
)) {
1414 ret
= udf_alloc_i_data(inode
, bs
-
1415 sizeof(struct extendedFileEntry
));
1418 memcpy(iinfo
->i_data
,
1419 bh
->b_data
+ sizeof(struct extendedFileEntry
),
1420 bs
- sizeof(struct extendedFileEntry
));
1421 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_FE
)) {
1424 ret
= udf_alloc_i_data(inode
, bs
- sizeof(struct fileEntry
));
1427 memcpy(iinfo
->i_data
,
1428 bh
->b_data
+ sizeof(struct fileEntry
),
1429 bs
- sizeof(struct fileEntry
));
1430 } else if (fe
->descTag
.tagIdent
== cpu_to_le16(TAG_IDENT_USE
)) {
1433 iinfo
->i_lenAlloc
= le32_to_cpu(
1434 ((struct unallocSpaceEntry
*)bh
->b_data
)->
1436 ret
= udf_alloc_i_data(inode
, bs
-
1437 sizeof(struct unallocSpaceEntry
));
1440 memcpy(iinfo
->i_data
,
1441 bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1442 bs
- sizeof(struct unallocSpaceEntry
));
1447 read_lock(&sbi
->s_cred_lock
);
1448 uid
= le32_to_cpu(fe
->uid
);
1449 if (uid
== UDF_INVALID_ID
||
1450 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_SET
))
1451 inode
->i_uid
= sbi
->s_uid
;
1453 i_uid_write(inode
, uid
);
1455 gid
= le32_to_cpu(fe
->gid
);
1456 if (gid
== UDF_INVALID_ID
||
1457 UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_SET
))
1458 inode
->i_gid
= sbi
->s_gid
;
1460 i_gid_write(inode
, gid
);
1462 if (fe
->icbTag
.fileType
!= ICBTAG_FILE_TYPE_DIRECTORY
&&
1463 sbi
->s_fmode
!= UDF_INVALID_MODE
)
1464 inode
->i_mode
= sbi
->s_fmode
;
1465 else if (fe
->icbTag
.fileType
== ICBTAG_FILE_TYPE_DIRECTORY
&&
1466 sbi
->s_dmode
!= UDF_INVALID_MODE
)
1467 inode
->i_mode
= sbi
->s_dmode
;
1469 inode
->i_mode
= udf_convert_permissions(fe
);
1470 inode
->i_mode
&= ~sbi
->s_umask
;
1471 iinfo
->i_extraPerms
= le32_to_cpu(fe
->permissions
) & ~FE_MAPPED_PERMS
;
1473 read_unlock(&sbi
->s_cred_lock
);
1475 link_count
= le16_to_cpu(fe
->fileLinkCount
);
1477 if (!hidden_inode
) {
1483 set_nlink(inode
, link_count
);
1485 inode
->i_size
= le64_to_cpu(fe
->informationLength
);
1486 iinfo
->i_lenExtents
= inode
->i_size
;
1488 if (iinfo
->i_efe
== 0) {
1489 inode
->i_blocks
= le64_to_cpu(fe
->logicalBlocksRecorded
) <<
1490 (inode
->i_sb
->s_blocksize_bits
- 9);
1492 udf_disk_stamp_to_time(&inode
->i_atime
, fe
->accessTime
);
1493 udf_disk_stamp_to_time(&inode
->i_mtime
, fe
->modificationTime
);
1494 udf_disk_stamp_to_time(&inode
->i_ctime
, fe
->attrTime
);
1496 iinfo
->i_unique
= le64_to_cpu(fe
->uniqueID
);
1497 iinfo
->i_lenEAttr
= le32_to_cpu(fe
->lengthExtendedAttr
);
1498 iinfo
->i_lenAlloc
= le32_to_cpu(fe
->lengthAllocDescs
);
1499 iinfo
->i_checkpoint
= le32_to_cpu(fe
->checkpoint
);
1500 iinfo
->i_streamdir
= 0;
1501 iinfo
->i_lenStreams
= 0;
1503 inode
->i_blocks
= le64_to_cpu(efe
->logicalBlocksRecorded
) <<
1504 (inode
->i_sb
->s_blocksize_bits
- 9);
1506 udf_disk_stamp_to_time(&inode
->i_atime
, efe
->accessTime
);
1507 udf_disk_stamp_to_time(&inode
->i_mtime
, efe
->modificationTime
);
1508 udf_disk_stamp_to_time(&iinfo
->i_crtime
, efe
->createTime
);
1509 udf_disk_stamp_to_time(&inode
->i_ctime
, efe
->attrTime
);
1511 iinfo
->i_unique
= le64_to_cpu(efe
->uniqueID
);
1512 iinfo
->i_lenEAttr
= le32_to_cpu(efe
->lengthExtendedAttr
);
1513 iinfo
->i_lenAlloc
= le32_to_cpu(efe
->lengthAllocDescs
);
1514 iinfo
->i_checkpoint
= le32_to_cpu(efe
->checkpoint
);
1517 iinfo
->i_streamdir
= (efe
->streamDirectoryICB
.extLength
!= 0);
1518 iinfo
->i_locStreamdir
=
1519 lelb_to_cpu(efe
->streamDirectoryICB
.extLocation
);
1520 iinfo
->i_lenStreams
= le64_to_cpu(efe
->objectSize
);
1521 if (iinfo
->i_lenStreams
>= inode
->i_size
)
1522 iinfo
->i_lenStreams
-= inode
->i_size
;
1524 iinfo
->i_lenStreams
= 0;
1526 inode
->i_generation
= iinfo
->i_unique
;
1529 * Sanity check length of allocation descriptors and extended attrs to
1530 * avoid integer overflows
1532 if (iinfo
->i_lenEAttr
> bs
|| iinfo
->i_lenAlloc
> bs
)
1534 /* Now do exact checks */
1535 if (udf_file_entry_alloc_offset(inode
) + iinfo
->i_lenAlloc
> bs
)
1537 /* Sanity checks for files in ICB so that we don't get confused later */
1538 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1540 * For file in ICB data is stored in allocation descriptor
1541 * so sizes should match
1543 if (iinfo
->i_lenAlloc
!= inode
->i_size
)
1545 /* File in ICB has to fit in there... */
1546 if (inode
->i_size
> bs
- udf_file_entry_alloc_offset(inode
))
1550 switch (fe
->icbTag
.fileType
) {
1551 case ICBTAG_FILE_TYPE_DIRECTORY
:
1552 inode
->i_op
= &udf_dir_inode_operations
;
1553 inode
->i_fop
= &udf_dir_operations
;
1554 inode
->i_mode
|= S_IFDIR
;
1557 case ICBTAG_FILE_TYPE_REALTIME
:
1558 case ICBTAG_FILE_TYPE_REGULAR
:
1559 case ICBTAG_FILE_TYPE_UNDEF
:
1560 case ICBTAG_FILE_TYPE_VAT20
:
1561 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1562 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
1564 inode
->i_data
.a_ops
= &udf_aops
;
1565 inode
->i_op
= &udf_file_inode_operations
;
1566 inode
->i_fop
= &udf_file_operations
;
1567 inode
->i_mode
|= S_IFREG
;
1569 case ICBTAG_FILE_TYPE_BLOCK
:
1570 inode
->i_mode
|= S_IFBLK
;
1572 case ICBTAG_FILE_TYPE_CHAR
:
1573 inode
->i_mode
|= S_IFCHR
;
1575 case ICBTAG_FILE_TYPE_FIFO
:
1576 init_special_inode(inode
, inode
->i_mode
| S_IFIFO
, 0);
1578 case ICBTAG_FILE_TYPE_SOCKET
:
1579 init_special_inode(inode
, inode
->i_mode
| S_IFSOCK
, 0);
1581 case ICBTAG_FILE_TYPE_SYMLINK
:
1582 inode
->i_data
.a_ops
= &udf_symlink_aops
;
1583 inode
->i_op
= &udf_symlink_inode_operations
;
1584 inode_nohighmem(inode
);
1585 inode
->i_mode
= S_IFLNK
| 0777;
1587 case ICBTAG_FILE_TYPE_MAIN
:
1588 udf_debug("METADATA FILE-----\n");
1590 case ICBTAG_FILE_TYPE_MIRROR
:
1591 udf_debug("METADATA MIRROR FILE-----\n");
1593 case ICBTAG_FILE_TYPE_BITMAP
:
1594 udf_debug("METADATA BITMAP FILE-----\n");
1597 udf_err(inode
->i_sb
, "(ino %lu) failed unknown file type=%u\n",
1598 inode
->i_ino
, fe
->icbTag
.fileType
);
1601 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1602 struct deviceSpec
*dsea
=
1603 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1605 init_special_inode(inode
, inode
->i_mode
,
1606 MKDEV(le32_to_cpu(dsea
->majorDeviceIdent
),
1607 le32_to_cpu(dsea
->minorDeviceIdent
)));
1608 /* Developer ID ??? */
1618 static int udf_alloc_i_data(struct inode
*inode
, size_t size
)
1620 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1621 iinfo
->i_data
= kmalloc(size
, GFP_KERNEL
);
1627 static umode_t
udf_convert_permissions(struct fileEntry
*fe
)
1630 uint32_t permissions
;
1633 permissions
= le32_to_cpu(fe
->permissions
);
1634 flags
= le16_to_cpu(fe
->icbTag
.flags
);
1636 mode
= ((permissions
) & 0007) |
1637 ((permissions
>> 2) & 0070) |
1638 ((permissions
>> 4) & 0700) |
1639 ((flags
& ICBTAG_FLAG_SETUID
) ? S_ISUID
: 0) |
1640 ((flags
& ICBTAG_FLAG_SETGID
) ? S_ISGID
: 0) |
1641 ((flags
& ICBTAG_FLAG_STICKY
) ? S_ISVTX
: 0);
1646 void udf_update_extra_perms(struct inode
*inode
, umode_t mode
)
1648 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1651 * UDF 2.01 sec. 3.3.3.3 Note 2:
1652 * In Unix, delete permission tracks write
1654 iinfo
->i_extraPerms
&= ~FE_DELETE_PERMS
;
1656 iinfo
->i_extraPerms
|= FE_PERM_U_DELETE
;
1658 iinfo
->i_extraPerms
|= FE_PERM_G_DELETE
;
1660 iinfo
->i_extraPerms
|= FE_PERM_O_DELETE
;
1663 int udf_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1665 return udf_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1668 static int udf_sync_inode(struct inode
*inode
)
1670 return udf_update_inode(inode
, 1);
1673 static void udf_adjust_time(struct udf_inode_info
*iinfo
, struct timespec64 time
)
1675 if (iinfo
->i_crtime
.tv_sec
> time
.tv_sec
||
1676 (iinfo
->i_crtime
.tv_sec
== time
.tv_sec
&&
1677 iinfo
->i_crtime
.tv_nsec
> time
.tv_nsec
))
1678 iinfo
->i_crtime
= time
;
1681 static int udf_update_inode(struct inode
*inode
, int do_sync
)
1683 struct buffer_head
*bh
= NULL
;
1684 struct fileEntry
*fe
;
1685 struct extendedFileEntry
*efe
;
1686 uint64_t lb_recorded
;
1691 struct udf_sb_info
*sbi
= UDF_SB(inode
->i_sb
);
1692 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
1693 struct udf_inode_info
*iinfo
= UDF_I(inode
);
1695 bh
= udf_tgetblk(inode
->i_sb
,
1696 udf_get_lb_pblock(inode
->i_sb
, &iinfo
->i_location
, 0));
1698 udf_debug("getblk failure\n");
1703 memset(bh
->b_data
, 0, inode
->i_sb
->s_blocksize
);
1704 fe
= (struct fileEntry
*)bh
->b_data
;
1705 efe
= (struct extendedFileEntry
*)bh
->b_data
;
1708 struct unallocSpaceEntry
*use
=
1709 (struct unallocSpaceEntry
*)bh
->b_data
;
1711 use
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1712 memcpy(bh
->b_data
+ sizeof(struct unallocSpaceEntry
),
1713 iinfo
->i_data
, inode
->i_sb
->s_blocksize
-
1714 sizeof(struct unallocSpaceEntry
));
1715 use
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_USE
);
1716 crclen
= sizeof(struct unallocSpaceEntry
);
1721 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_UID_FORGET
))
1722 fe
->uid
= cpu_to_le32(UDF_INVALID_ID
);
1724 fe
->uid
= cpu_to_le32(i_uid_read(inode
));
1726 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_GID_FORGET
))
1727 fe
->gid
= cpu_to_le32(UDF_INVALID_ID
);
1729 fe
->gid
= cpu_to_le32(i_gid_read(inode
));
1731 udfperms
= ((inode
->i_mode
& 0007)) |
1732 ((inode
->i_mode
& 0070) << 2) |
1733 ((inode
->i_mode
& 0700) << 4);
1735 udfperms
|= iinfo
->i_extraPerms
;
1736 fe
->permissions
= cpu_to_le32(udfperms
);
1738 if (S_ISDIR(inode
->i_mode
) && inode
->i_nlink
> 0)
1739 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
- 1);
1741 fe
->fileLinkCount
= cpu_to_le16(inode
->i_nlink
);
1743 fe
->informationLength
= cpu_to_le64(inode
->i_size
);
1745 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1747 struct deviceSpec
*dsea
=
1748 (struct deviceSpec
*)udf_get_extendedattr(inode
, 12, 1);
1750 dsea
= (struct deviceSpec
*)
1751 udf_add_extendedattr(inode
,
1752 sizeof(struct deviceSpec
) +
1753 sizeof(struct regid
), 12, 0x3);
1754 dsea
->attrType
= cpu_to_le32(12);
1755 dsea
->attrSubtype
= 1;
1756 dsea
->attrLength
= cpu_to_le32(
1757 sizeof(struct deviceSpec
) +
1758 sizeof(struct regid
));
1759 dsea
->impUseLength
= cpu_to_le32(sizeof(struct regid
));
1761 eid
= (struct regid
*)dsea
->impUse
;
1762 memset(eid
, 0, sizeof(*eid
));
1763 strcpy(eid
->ident
, UDF_ID_DEVELOPER
);
1764 eid
->identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1765 eid
->identSuffix
[1] = UDF_OS_ID_LINUX
;
1766 dsea
->majorDeviceIdent
= cpu_to_le32(imajor(inode
));
1767 dsea
->minorDeviceIdent
= cpu_to_le32(iminor(inode
));
1770 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1771 lb_recorded
= 0; /* No extents => no blocks! */
1774 (inode
->i_blocks
+ (1 << (blocksize_bits
- 9)) - 1) >>
1775 (blocksize_bits
- 9);
1777 if (iinfo
->i_efe
== 0) {
1778 memcpy(bh
->b_data
+ sizeof(struct fileEntry
),
1780 inode
->i_sb
->s_blocksize
- sizeof(struct fileEntry
));
1781 fe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1783 udf_time_to_disk_stamp(&fe
->accessTime
, inode
->i_atime
);
1784 udf_time_to_disk_stamp(&fe
->modificationTime
, inode
->i_mtime
);
1785 udf_time_to_disk_stamp(&fe
->attrTime
, inode
->i_ctime
);
1786 memset(&(fe
->impIdent
), 0, sizeof(struct regid
));
1787 strcpy(fe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1788 fe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1789 fe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1790 fe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1791 fe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1792 fe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1793 fe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1794 fe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_FE
);
1795 crclen
= sizeof(struct fileEntry
);
1797 memcpy(bh
->b_data
+ sizeof(struct extendedFileEntry
),
1799 inode
->i_sb
->s_blocksize
-
1800 sizeof(struct extendedFileEntry
));
1802 cpu_to_le64(inode
->i_size
+ iinfo
->i_lenStreams
);
1803 efe
->logicalBlocksRecorded
= cpu_to_le64(lb_recorded
);
1805 if (iinfo
->i_streamdir
) {
1806 struct long_ad
*icb_lad
= &efe
->streamDirectoryICB
;
1808 icb_lad
->extLocation
=
1809 cpu_to_lelb(iinfo
->i_locStreamdir
);
1810 icb_lad
->extLength
=
1811 cpu_to_le32(inode
->i_sb
->s_blocksize
);
1814 udf_adjust_time(iinfo
, inode
->i_atime
);
1815 udf_adjust_time(iinfo
, inode
->i_mtime
);
1816 udf_adjust_time(iinfo
, inode
->i_ctime
);
1818 udf_time_to_disk_stamp(&efe
->accessTime
, inode
->i_atime
);
1819 udf_time_to_disk_stamp(&efe
->modificationTime
, inode
->i_mtime
);
1820 udf_time_to_disk_stamp(&efe
->createTime
, iinfo
->i_crtime
);
1821 udf_time_to_disk_stamp(&efe
->attrTime
, inode
->i_ctime
);
1823 memset(&(efe
->impIdent
), 0, sizeof(efe
->impIdent
));
1824 strcpy(efe
->impIdent
.ident
, UDF_ID_DEVELOPER
);
1825 efe
->impIdent
.identSuffix
[0] = UDF_OS_CLASS_UNIX
;
1826 efe
->impIdent
.identSuffix
[1] = UDF_OS_ID_LINUX
;
1827 efe
->uniqueID
= cpu_to_le64(iinfo
->i_unique
);
1828 efe
->lengthExtendedAttr
= cpu_to_le32(iinfo
->i_lenEAttr
);
1829 efe
->lengthAllocDescs
= cpu_to_le32(iinfo
->i_lenAlloc
);
1830 efe
->checkpoint
= cpu_to_le32(iinfo
->i_checkpoint
);
1831 efe
->descTag
.tagIdent
= cpu_to_le16(TAG_IDENT_EFE
);
1832 crclen
= sizeof(struct extendedFileEntry
);
1836 if (iinfo
->i_strat4096
) {
1837 fe
->icbTag
.strategyType
= cpu_to_le16(4096);
1838 fe
->icbTag
.strategyParameter
= cpu_to_le16(1);
1839 fe
->icbTag
.numEntries
= cpu_to_le16(2);
1841 fe
->icbTag
.strategyType
= cpu_to_le16(4);
1842 fe
->icbTag
.numEntries
= cpu_to_le16(1);
1846 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_USE
;
1847 else if (S_ISDIR(inode
->i_mode
))
1848 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_DIRECTORY
;
1849 else if (S_ISREG(inode
->i_mode
))
1850 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_REGULAR
;
1851 else if (S_ISLNK(inode
->i_mode
))
1852 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SYMLINK
;
1853 else if (S_ISBLK(inode
->i_mode
))
1854 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_BLOCK
;
1855 else if (S_ISCHR(inode
->i_mode
))
1856 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_CHAR
;
1857 else if (S_ISFIFO(inode
->i_mode
))
1858 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_FIFO
;
1859 else if (S_ISSOCK(inode
->i_mode
))
1860 fe
->icbTag
.fileType
= ICBTAG_FILE_TYPE_SOCKET
;
1862 icbflags
= iinfo
->i_alloc_type
|
1863 ((inode
->i_mode
& S_ISUID
) ? ICBTAG_FLAG_SETUID
: 0) |
1864 ((inode
->i_mode
& S_ISGID
) ? ICBTAG_FLAG_SETGID
: 0) |
1865 ((inode
->i_mode
& S_ISVTX
) ? ICBTAG_FLAG_STICKY
: 0) |
1866 (le16_to_cpu(fe
->icbTag
.flags
) &
1867 ~(ICBTAG_FLAG_AD_MASK
| ICBTAG_FLAG_SETUID
|
1868 ICBTAG_FLAG_SETGID
| ICBTAG_FLAG_STICKY
));
1870 fe
->icbTag
.flags
= cpu_to_le16(icbflags
);
1871 if (sbi
->s_udfrev
>= 0x0200)
1872 fe
->descTag
.descVersion
= cpu_to_le16(3);
1874 fe
->descTag
.descVersion
= cpu_to_le16(2);
1875 fe
->descTag
.tagSerialNum
= cpu_to_le16(sbi
->s_serial_number
);
1876 fe
->descTag
.tagLocation
= cpu_to_le32(
1877 iinfo
->i_location
.logicalBlockNum
);
1878 crclen
+= iinfo
->i_lenEAttr
+ iinfo
->i_lenAlloc
- sizeof(struct tag
);
1879 fe
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
1880 fe
->descTag
.descCRC
= cpu_to_le16(crc_itu_t(0, (char *)fe
+ sizeof(struct tag
),
1882 fe
->descTag
.tagChecksum
= udf_tag_checksum(&fe
->descTag
);
1884 set_buffer_uptodate(bh
);
1887 /* write the data blocks */
1888 mark_buffer_dirty(bh
);
1890 sync_dirty_buffer(bh
);
1891 if (buffer_write_io_error(bh
)) {
1892 udf_warn(inode
->i_sb
, "IO error syncing udf inode [%08lx]\n",
1902 struct inode
*__udf_iget(struct super_block
*sb
, struct kernel_lb_addr
*ino
,
1905 unsigned long block
= udf_get_lb_pblock(sb
, ino
, 0);
1906 struct inode
*inode
= iget_locked(sb
, block
);
1910 return ERR_PTR(-ENOMEM
);
1912 if (!(inode
->i_state
& I_NEW
))
1915 memcpy(&UDF_I(inode
)->i_location
, ino
, sizeof(struct kernel_lb_addr
));
1916 err
= udf_read_inode(inode
, hidden_inode
);
1919 return ERR_PTR(err
);
1921 unlock_new_inode(inode
);
1926 int udf_setup_indirect_aext(struct inode
*inode
, udf_pblk_t block
,
1927 struct extent_position
*epos
)
1929 struct super_block
*sb
= inode
->i_sb
;
1930 struct buffer_head
*bh
;
1931 struct allocExtDesc
*aed
;
1932 struct extent_position nepos
;
1933 struct kernel_lb_addr neloc
;
1936 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
1937 adsize
= sizeof(struct short_ad
);
1938 else if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
1939 adsize
= sizeof(struct long_ad
);
1943 neloc
.logicalBlockNum
= block
;
1944 neloc
.partitionReferenceNum
= epos
->block
.partitionReferenceNum
;
1946 bh
= udf_tgetblk(sb
, udf_get_lb_pblock(sb
, &neloc
, 0));
1950 memset(bh
->b_data
, 0x00, sb
->s_blocksize
);
1951 set_buffer_uptodate(bh
);
1953 mark_buffer_dirty_inode(bh
, inode
);
1955 aed
= (struct allocExtDesc
*)(bh
->b_data
);
1956 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_STRICT
)) {
1957 aed
->previousAllocExtLocation
=
1958 cpu_to_le32(epos
->block
.logicalBlockNum
);
1960 aed
->lengthAllocDescs
= cpu_to_le32(0);
1961 if (UDF_SB(sb
)->s_udfrev
>= 0x0200)
1965 udf_new_tag(bh
->b_data
, TAG_IDENT_AED
, ver
, 1, block
,
1966 sizeof(struct tag
));
1968 nepos
.block
= neloc
;
1969 nepos
.offset
= sizeof(struct allocExtDesc
);
1973 * Do we have to copy current last extent to make space for indirect
1976 if (epos
->offset
+ adsize
> sb
->s_blocksize
) {
1977 struct kernel_lb_addr cp_loc
;
1981 epos
->offset
-= adsize
;
1982 cp_type
= udf_current_aext(inode
, epos
, &cp_loc
, &cp_len
, 0);
1983 cp_len
|= ((uint32_t)cp_type
) << 30;
1985 __udf_add_aext(inode
, &nepos
, &cp_loc
, cp_len
, 1);
1986 udf_write_aext(inode
, epos
, &nepos
.block
,
1987 sb
->s_blocksize
| EXT_NEXT_EXTENT_ALLOCDESCS
, 0);
1989 __udf_add_aext(inode
, epos
, &nepos
.block
,
1990 sb
->s_blocksize
| EXT_NEXT_EXTENT_ALLOCDESCS
, 0);
2000 * Append extent at the given position - should be the first free one in inode
2001 * / indirect extent. This function assumes there is enough space in the inode
2002 * or indirect extent. Use udf_add_aext() if you didn't check for this before.
2004 int __udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
2005 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
2007 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2008 struct allocExtDesc
*aed
;
2011 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2012 adsize
= sizeof(struct short_ad
);
2013 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2014 adsize
= sizeof(struct long_ad
);
2019 WARN_ON(iinfo
->i_lenAlloc
!=
2020 epos
->offset
- udf_file_entry_alloc_offset(inode
));
2022 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
2023 WARN_ON(le32_to_cpu(aed
->lengthAllocDescs
) !=
2024 epos
->offset
- sizeof(struct allocExtDesc
));
2025 WARN_ON(epos
->offset
+ adsize
> inode
->i_sb
->s_blocksize
);
2028 udf_write_aext(inode
, epos
, eloc
, elen
, inc
);
2031 iinfo
->i_lenAlloc
+= adsize
;
2032 mark_inode_dirty(inode
);
2034 aed
= (struct allocExtDesc
*)epos
->bh
->b_data
;
2035 le32_add_cpu(&aed
->lengthAllocDescs
, adsize
);
2036 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2037 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2038 udf_update_tag(epos
->bh
->b_data
,
2039 epos
->offset
+ (inc
? 0 : adsize
));
2041 udf_update_tag(epos
->bh
->b_data
,
2042 sizeof(struct allocExtDesc
));
2043 mark_buffer_dirty_inode(epos
->bh
, inode
);
2050 * Append extent at given position - should be the first free one in inode
2051 * / indirect extent. Takes care of allocating and linking indirect blocks.
2053 int udf_add_aext(struct inode
*inode
, struct extent_position
*epos
,
2054 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
2057 struct super_block
*sb
= inode
->i_sb
;
2059 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2060 adsize
= sizeof(struct short_ad
);
2061 else if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2062 adsize
= sizeof(struct long_ad
);
2066 if (epos
->offset
+ (2 * adsize
) > sb
->s_blocksize
) {
2068 udf_pblk_t new_block
;
2070 new_block
= udf_new_block(sb
, NULL
,
2071 epos
->block
.partitionReferenceNum
,
2072 epos
->block
.logicalBlockNum
, &err
);
2076 err
= udf_setup_indirect_aext(inode
, new_block
, epos
);
2081 return __udf_add_aext(inode
, epos
, eloc
, elen
, inc
);
2084 void udf_write_aext(struct inode
*inode
, struct extent_position
*epos
,
2085 struct kernel_lb_addr
*eloc
, uint32_t elen
, int inc
)
2089 struct short_ad
*sad
;
2090 struct long_ad
*lad
;
2091 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2094 ptr
= iinfo
->i_data
+ epos
->offset
-
2095 udf_file_entry_alloc_offset(inode
) +
2098 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2100 switch (iinfo
->i_alloc_type
) {
2101 case ICBTAG_FLAG_AD_SHORT
:
2102 sad
= (struct short_ad
*)ptr
;
2103 sad
->extLength
= cpu_to_le32(elen
);
2104 sad
->extPosition
= cpu_to_le32(eloc
->logicalBlockNum
);
2105 adsize
= sizeof(struct short_ad
);
2107 case ICBTAG_FLAG_AD_LONG
:
2108 lad
= (struct long_ad
*)ptr
;
2109 lad
->extLength
= cpu_to_le32(elen
);
2110 lad
->extLocation
= cpu_to_lelb(*eloc
);
2111 memset(lad
->impUse
, 0x00, sizeof(lad
->impUse
));
2112 adsize
= sizeof(struct long_ad
);
2119 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2120 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201) {
2121 struct allocExtDesc
*aed
=
2122 (struct allocExtDesc
*)epos
->bh
->b_data
;
2123 udf_update_tag(epos
->bh
->b_data
,
2124 le32_to_cpu(aed
->lengthAllocDescs
) +
2125 sizeof(struct allocExtDesc
));
2127 mark_buffer_dirty_inode(epos
->bh
, inode
);
2129 mark_inode_dirty(inode
);
2133 epos
->offset
+= adsize
;
2137 * Only 1 indirect extent in a row really makes sense but allow upto 16 in case
2138 * someone does some weird stuff.
2140 #define UDF_MAX_INDIR_EXTS 16
2142 int8_t udf_next_aext(struct inode
*inode
, struct extent_position
*epos
,
2143 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2146 unsigned int indirections
= 0;
2148 while ((etype
= udf_current_aext(inode
, epos
, eloc
, elen
, inc
)) ==
2149 (EXT_NEXT_EXTENT_ALLOCDESCS
>> 30)) {
2152 if (++indirections
> UDF_MAX_INDIR_EXTS
) {
2153 udf_err(inode
->i_sb
,
2154 "too many indirect extents in inode %lu\n",
2159 epos
->block
= *eloc
;
2160 epos
->offset
= sizeof(struct allocExtDesc
);
2162 block
= udf_get_lb_pblock(inode
->i_sb
, &epos
->block
, 0);
2163 epos
->bh
= udf_tread(inode
->i_sb
, block
);
2165 udf_debug("reading block %u failed!\n", block
);
2173 int8_t udf_current_aext(struct inode
*inode
, struct extent_position
*epos
,
2174 struct kernel_lb_addr
*eloc
, uint32_t *elen
, int inc
)
2179 struct short_ad
*sad
;
2180 struct long_ad
*lad
;
2181 struct udf_inode_info
*iinfo
= UDF_I(inode
);
2185 epos
->offset
= udf_file_entry_alloc_offset(inode
);
2186 ptr
= iinfo
->i_data
+ epos
->offset
-
2187 udf_file_entry_alloc_offset(inode
) +
2189 alen
= udf_file_entry_alloc_offset(inode
) +
2193 epos
->offset
= sizeof(struct allocExtDesc
);
2194 ptr
= epos
->bh
->b_data
+ epos
->offset
;
2195 alen
= sizeof(struct allocExtDesc
) +
2196 le32_to_cpu(((struct allocExtDesc
*)epos
->bh
->b_data
)->
2200 switch (iinfo
->i_alloc_type
) {
2201 case ICBTAG_FLAG_AD_SHORT
:
2202 sad
= udf_get_fileshortad(ptr
, alen
, &epos
->offset
, inc
);
2205 etype
= le32_to_cpu(sad
->extLength
) >> 30;
2206 eloc
->logicalBlockNum
= le32_to_cpu(sad
->extPosition
);
2207 eloc
->partitionReferenceNum
=
2208 iinfo
->i_location
.partitionReferenceNum
;
2209 *elen
= le32_to_cpu(sad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2211 case ICBTAG_FLAG_AD_LONG
:
2212 lad
= udf_get_filelongad(ptr
, alen
, &epos
->offset
, inc
);
2215 etype
= le32_to_cpu(lad
->extLength
) >> 30;
2216 *eloc
= lelb_to_cpu(lad
->extLocation
);
2217 *elen
= le32_to_cpu(lad
->extLength
) & UDF_EXTENT_LENGTH_MASK
;
2220 udf_debug("alloc_type = %u unsupported\n", iinfo
->i_alloc_type
);
2227 static int8_t udf_insert_aext(struct inode
*inode
, struct extent_position epos
,
2228 struct kernel_lb_addr neloc
, uint32_t nelen
)
2230 struct kernel_lb_addr oeloc
;
2237 while ((etype
= udf_next_aext(inode
, &epos
, &oeloc
, &oelen
, 0)) != -1) {
2238 udf_write_aext(inode
, &epos
, &neloc
, nelen
, 1);
2240 nelen
= (etype
<< 30) | oelen
;
2242 udf_add_aext(inode
, &epos
, &neloc
, nelen
, 1);
2245 return (nelen
>> 30);
2248 int8_t udf_delete_aext(struct inode
*inode
, struct extent_position epos
)
2250 struct extent_position oepos
;
2253 struct allocExtDesc
*aed
;
2254 struct udf_inode_info
*iinfo
;
2255 struct kernel_lb_addr eloc
;
2263 iinfo
= UDF_I(inode
);
2264 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
2265 adsize
= sizeof(struct short_ad
);
2266 else if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
2267 adsize
= sizeof(struct long_ad
);
2272 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) == -1)
2275 while ((etype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
2276 udf_write_aext(inode
, &oepos
, &eloc
, (etype
<< 30) | elen
, 1);
2277 if (oepos
.bh
!= epos
.bh
) {
2278 oepos
.block
= epos
.block
;
2282 oepos
.offset
= epos
.offset
- adsize
;
2285 memset(&eloc
, 0x00, sizeof(struct kernel_lb_addr
));
2288 if (epos
.bh
!= oepos
.bh
) {
2289 udf_free_blocks(inode
->i_sb
, inode
, &epos
.block
, 0, 1);
2290 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2291 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2293 iinfo
->i_lenAlloc
-= (adsize
* 2);
2294 mark_inode_dirty(inode
);
2296 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2297 le32_add_cpu(&aed
->lengthAllocDescs
, -(2 * adsize
));
2298 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2299 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2300 udf_update_tag(oepos
.bh
->b_data
,
2301 oepos
.offset
- (2 * adsize
));
2303 udf_update_tag(oepos
.bh
->b_data
,
2304 sizeof(struct allocExtDesc
));
2305 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2308 udf_write_aext(inode
, &oepos
, &eloc
, elen
, 1);
2310 iinfo
->i_lenAlloc
-= adsize
;
2311 mark_inode_dirty(inode
);
2313 aed
= (struct allocExtDesc
*)oepos
.bh
->b_data
;
2314 le32_add_cpu(&aed
->lengthAllocDescs
, -adsize
);
2315 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
2316 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
2317 udf_update_tag(oepos
.bh
->b_data
,
2318 epos
.offset
- adsize
);
2320 udf_update_tag(oepos
.bh
->b_data
,
2321 sizeof(struct allocExtDesc
));
2322 mark_buffer_dirty_inode(oepos
.bh
, inode
);
2329 return (elen
>> 30);
2332 int8_t inode_bmap(struct inode
*inode
, sector_t block
,
2333 struct extent_position
*pos
, struct kernel_lb_addr
*eloc
,
2334 uint32_t *elen
, sector_t
*offset
)
2336 unsigned char blocksize_bits
= inode
->i_sb
->s_blocksize_bits
;
2337 loff_t lbcount
= 0, bcount
= (loff_t
) block
<< blocksize_bits
;
2339 struct udf_inode_info
*iinfo
;
2341 iinfo
= UDF_I(inode
);
2342 if (!udf_read_extent_cache(inode
, bcount
, &lbcount
, pos
)) {
2344 pos
->block
= iinfo
->i_location
;
2349 etype
= udf_next_aext(inode
, pos
, eloc
, elen
, 1);
2351 *offset
= (bcount
- lbcount
) >> blocksize_bits
;
2352 iinfo
->i_lenExtents
= lbcount
;
2356 } while (lbcount
<= bcount
);
2357 /* update extent cache */
2358 udf_update_extent_cache(inode
, lbcount
- *elen
, pos
);
2359 *offset
= (bcount
+ *elen
- lbcount
) >> blocksize_bits
;
2364 udf_pblk_t
udf_block_map(struct inode
*inode
, sector_t block
)
2366 struct kernel_lb_addr eloc
;
2369 struct extent_position epos
= {};
2372 down_read(&UDF_I(inode
)->i_data_sem
);
2374 if (inode_bmap(inode
, block
, &epos
, &eloc
, &elen
, &offset
) ==
2375 (EXT_RECORDED_ALLOCATED
>> 30))
2376 ret
= udf_get_lb_pblock(inode
->i_sb
, &eloc
, offset
);
2380 up_read(&UDF_I(inode
)->i_data_sem
);
2383 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_VARCONV
))
2384 return udf_fixed_to_variable(ret
);