5 * Inode name 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-2004 Ben Fennema
14 * (C) 1999-2000 Stelias Computing Inc
18 * 12/12/98 blf Created. Split out the lookup code from dir.c
19 * 04/19/99 blf link, mknod, symlink support
26 #include <linux/string.h>
27 #include <linux/errno.h>
29 #include <linux/slab.h>
30 #include <linux/sched.h>
31 #include <linux/crc-itu-t.h>
32 #include <linux/exportfs.h>
34 static inline int udf_match(int len1
, const unsigned char *name1
, int len2
,
35 const unsigned char *name2
)
40 return !memcmp(name1
, name2
, len1
);
43 int udf_write_fi(struct inode
*inode
, struct fileIdentDesc
*cfi
,
44 struct fileIdentDesc
*sfi
, struct udf_fileident_bh
*fibh
,
45 uint8_t *impuse
, uint8_t *fileident
)
47 uint16_t crclen
= fibh
->eoffset
- fibh
->soffset
- sizeof(struct tag
);
50 uint16_t liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
51 uint8_t lfi
= cfi
->lengthFileIdent
;
52 int padlen
= fibh
->eoffset
- fibh
->soffset
- liu
- lfi
-
53 sizeof(struct fileIdentDesc
);
56 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
59 offset
= fibh
->soffset
+ sizeof(struct fileIdentDesc
);
62 if (adinicb
|| (offset
+ liu
< 0)) {
63 memcpy((uint8_t *)sfi
->impUse
, impuse
, liu
);
64 } else if (offset
>= 0) {
65 memcpy(fibh
->ebh
->b_data
+ offset
, impuse
, liu
);
67 memcpy((uint8_t *)sfi
->impUse
, impuse
, -offset
);
68 memcpy(fibh
->ebh
->b_data
, impuse
- offset
,
76 if (adinicb
|| (offset
+ lfi
< 0)) {
77 memcpy(udf_get_fi_ident(sfi
), fileident
, lfi
);
78 } else if (offset
>= 0) {
79 memcpy(fibh
->ebh
->b_data
+ offset
, fileident
, lfi
);
81 memcpy(udf_get_fi_ident(sfi
), fileident
, -offset
);
82 memcpy(fibh
->ebh
->b_data
, fileident
- offset
,
89 if (adinicb
|| (offset
+ padlen
< 0)) {
90 memset(udf_get_fi_ident(sfi
) + lfi
, 0x00, padlen
);
91 } else if (offset
>= 0) {
92 memset(fibh
->ebh
->b_data
+ offset
, 0x00, padlen
);
94 memset(udf_get_fi_ident(sfi
) + lfi
, 0x00, -offset
);
95 memset(fibh
->ebh
->b_data
, 0x00, padlen
+ offset
);
98 crc
= crc_itu_t(0, (uint8_t *)cfi
+ sizeof(struct tag
),
99 sizeof(struct fileIdentDesc
) - sizeof(struct tag
));
101 if (fibh
->sbh
== fibh
->ebh
) {
102 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
103 crclen
+ sizeof(struct tag
) -
104 sizeof(struct fileIdentDesc
));
105 } else if (sizeof(struct fileIdentDesc
) >= -fibh
->soffset
) {
106 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
+
107 sizeof(struct fileIdentDesc
) +
109 crclen
+ sizeof(struct tag
) -
110 sizeof(struct fileIdentDesc
));
112 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
113 -fibh
->soffset
- sizeof(struct fileIdentDesc
));
114 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
, fibh
->eoffset
);
117 cfi
->descTag
.descCRC
= cpu_to_le16(crc
);
118 cfi
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
119 cfi
->descTag
.tagChecksum
= udf_tag_checksum(&cfi
->descTag
);
121 if (adinicb
|| (sizeof(struct fileIdentDesc
) <= -fibh
->soffset
)) {
122 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
,
123 sizeof(struct fileIdentDesc
));
125 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
, -fibh
->soffset
);
126 memcpy(fibh
->ebh
->b_data
, (uint8_t *)cfi
- fibh
->soffset
,
127 sizeof(struct fileIdentDesc
) + fibh
->soffset
);
131 mark_inode_dirty(inode
);
133 if (fibh
->sbh
!= fibh
->ebh
)
134 mark_buffer_dirty_inode(fibh
->ebh
, inode
);
135 mark_buffer_dirty_inode(fibh
->sbh
, inode
);
141 * udf_find_entry - find entry in given directory.
143 * @dir: directory inode to search in
144 * @child: qstr of the name
145 * @fibh: buffer head / inode with file identifier descriptor we found
146 * @cfi: found file identifier descriptor with given name
148 * This function searches in the directory @dir for a file name @child. When
149 * found, @fibh points to the buffer head(s) (bh is NULL for in ICB
150 * directories) containing the file identifier descriptor (FID). In that case
151 * the function returns pointer to the FID in the buffer or inode - but note
152 * that FID may be split among two buffers (blocks) so accessing it via that
153 * pointer isn't easily possible. This pointer can be used only as an iterator
154 * for other directory manipulation functions. For inspection of the FID @cfi
155 * can be used - the found FID is copied there.
157 * Returns pointer to FID, NULL when nothing found, or error code.
159 static struct fileIdentDesc
*udf_find_entry(struct inode
*dir
,
160 const struct qstr
*child
,
161 struct udf_fileident_bh
*fibh
,
162 struct fileIdentDesc
*cfi
)
164 struct fileIdentDesc
*fi
= NULL
;
168 unsigned char *fname
= NULL
, *copy_name
= NULL
;
169 unsigned char *nameptr
;
173 struct kernel_lb_addr eloc
;
176 struct extent_position epos
= {};
177 struct udf_inode_info
*dinfo
= UDF_I(dir
);
178 int isdotdot
= child
->len
== 2 &&
179 child
->name
[0] == '.' && child
->name
[1] == '.';
180 struct super_block
*sb
= dir
->i_sb
;
182 size
= udf_ext0_offset(dir
) + dir
->i_size
;
183 f_pos
= udf_ext0_offset(dir
);
185 fibh
->sbh
= fibh
->ebh
= NULL
;
186 fibh
->soffset
= fibh
->eoffset
= f_pos
& (sb
->s_blocksize
- 1);
187 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
188 if (inode_bmap(dir
, f_pos
>> sb
->s_blocksize_bits
, &epos
,
189 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30)) {
194 block
= udf_get_lb_pblock(sb
, &eloc
, offset
);
195 if ((++offset
<< sb
->s_blocksize_bits
) < elen
) {
196 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
197 epos
.offset
-= sizeof(struct short_ad
);
198 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
199 epos
.offset
-= sizeof(struct long_ad
);
203 fibh
->sbh
= fibh
->ebh
= udf_tread(sb
, block
);
210 fname
= kmalloc(UDF_NAME_LEN
, GFP_NOFS
);
212 fi
= ERR_PTR(-ENOMEM
);
216 while (f_pos
< size
) {
217 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
224 liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
225 lfi
= cfi
->lengthFileIdent
;
227 if (fibh
->sbh
== fibh
->ebh
) {
228 nameptr
= udf_get_fi_ident(fi
);
230 int poffset
; /* Unpaded ending offset */
232 poffset
= fibh
->soffset
+ sizeof(struct fileIdentDesc
) +
236 nameptr
= (uint8_t *)(fibh
->ebh
->b_data
+
240 copy_name
= kmalloc(UDF_NAME_LEN
,
243 fi
= ERR_PTR(-ENOMEM
);
248 memcpy(nameptr
, udf_get_fi_ident(fi
),
250 memcpy(nameptr
+ lfi
- poffset
,
251 fibh
->ebh
->b_data
, poffset
);
255 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
256 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_UNDELETE
))
260 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_HIDDEN
) != 0) {
261 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_UNHIDE
))
265 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_PARENT
) &&
272 flen
= udf_get_filename(sb
, nameptr
, lfi
, fname
, UDF_NAME_LEN
);
278 if (udf_match(flen
, fname
, child
->len
, child
->name
))
284 if (fibh
->sbh
!= fibh
->ebh
)
295 static struct dentry
*udf_lookup(struct inode
*dir
, struct dentry
*dentry
,
298 struct inode
*inode
= NULL
;
299 struct fileIdentDesc cfi
;
300 struct udf_fileident_bh fibh
;
301 struct fileIdentDesc
*fi
;
303 if (dentry
->d_name
.len
> UDF_NAME_LEN
)
304 return ERR_PTR(-ENAMETOOLONG
);
306 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
311 struct kernel_lb_addr loc
;
313 if (fibh
.sbh
!= fibh
.ebh
)
317 loc
= lelb_to_cpu(cfi
.icb
.extLocation
);
318 inode
= udf_iget(dir
->i_sb
, &loc
);
320 return ERR_CAST(inode
);
323 return d_splice_alias(inode
, dentry
);
326 static struct fileIdentDesc
*udf_add_entry(struct inode
*dir
,
327 struct dentry
*dentry
,
328 struct udf_fileident_bh
*fibh
,
329 struct fileIdentDesc
*cfi
, int *err
)
331 struct super_block
*sb
= dir
->i_sb
;
332 struct fileIdentDesc
*fi
= NULL
;
333 unsigned char *name
= NULL
;
336 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
339 struct kernel_lb_addr eloc
;
342 struct extent_position epos
= {};
343 struct udf_inode_info
*dinfo
;
345 fibh
->sbh
= fibh
->ebh
= NULL
;
346 name
= kmalloc(UDF_NAME_LEN_CS0
, GFP_NOFS
);
353 if (!dentry
->d_name
.len
) {
357 namelen
= udf_put_filename(sb
, dentry
->d_name
.name
,
359 name
, UDF_NAME_LEN_CS0
);
361 *err
= -ENAMETOOLONG
;
368 nfidlen
= ALIGN(sizeof(struct fileIdentDesc
) + namelen
, UDF_NAME_PAD
);
370 f_pos
= udf_ext0_offset(dir
);
372 fibh
->soffset
= fibh
->eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
374 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
375 if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
, &epos
,
376 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30)) {
377 block
= udf_get_lb_pblock(dir
->i_sb
,
378 &dinfo
->i_location
, 0);
379 fibh
->soffset
= fibh
->eoffset
= sb
->s_blocksize
;
382 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
383 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
384 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
385 epos
.offset
-= sizeof(struct short_ad
);
386 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
387 epos
.offset
-= sizeof(struct long_ad
);
391 fibh
->sbh
= fibh
->ebh
= udf_tread(dir
->i_sb
, block
);
397 block
= dinfo
->i_location
.logicalBlockNum
;
400 while (f_pos
< size
) {
401 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
409 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
410 if (udf_dir_entry_len(cfi
) == nfidlen
) {
411 cfi
->descTag
.tagSerialNum
= cpu_to_le16(1);
412 cfi
->fileVersionNum
= cpu_to_le16(1);
413 cfi
->fileCharacteristics
= 0;
414 cfi
->lengthFileIdent
= namelen
;
415 cfi
->lengthOfImpUse
= cpu_to_le16(0);
416 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
,
430 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
&&
431 sb
->s_blocksize
- fibh
->eoffset
< nfidlen
) {
434 fibh
->soffset
-= udf_ext0_offset(dir
);
435 fibh
->eoffset
-= udf_ext0_offset(dir
);
436 f_pos
-= udf_ext0_offset(dir
);
437 if (fibh
->sbh
!= fibh
->ebh
)
440 fibh
->sbh
= fibh
->ebh
=
441 udf_expand_dir_adinicb(dir
, &block
, err
);
444 epos
.block
= dinfo
->i_location
;
445 epos
.offset
= udf_file_entry_alloc_offset(dir
);
446 /* Load extent udf_expand_dir_adinicb() has created */
447 udf_current_aext(dir
, &epos
, &eloc
, &elen
, 1);
450 /* Entry fits into current block? */
451 if (sb
->s_blocksize
- fibh
->eoffset
>= nfidlen
) {
452 fibh
->soffset
= fibh
->eoffset
;
453 fibh
->eoffset
+= nfidlen
;
454 if (fibh
->sbh
!= fibh
->ebh
) {
456 fibh
->sbh
= fibh
->ebh
;
459 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
460 block
= dinfo
->i_location
.logicalBlockNum
;
461 fi
= (struct fileIdentDesc
*)
462 (dinfo
->i_data
+ fibh
->soffset
-
463 udf_ext0_offset(dir
) +
466 block
= eloc
.logicalBlockNum
+
468 dir
->i_sb
->s_blocksize_bits
);
469 fi
= (struct fileIdentDesc
*)
470 (fibh
->sbh
->b_data
+ fibh
->soffset
);
473 /* Round up last extent in the file */
474 elen
= (elen
+ sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1);
475 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
476 epos
.offset
-= sizeof(struct short_ad
);
477 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
478 epos
.offset
-= sizeof(struct long_ad
);
479 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
480 dinfo
->i_lenExtents
= (dinfo
->i_lenExtents
+ sb
->s_blocksize
481 - 1) & ~(sb
->s_blocksize
- 1);
483 fibh
->soffset
= fibh
->eoffset
- sb
->s_blocksize
;
484 fibh
->eoffset
+= nfidlen
- sb
->s_blocksize
;
485 if (fibh
->sbh
!= fibh
->ebh
) {
487 fibh
->sbh
= fibh
->ebh
;
490 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
491 dir
->i_sb
->s_blocksize_bits
);
492 fibh
->ebh
= udf_bread(dir
,
493 f_pos
>> dir
->i_sb
->s_blocksize_bits
, 1, err
);
496 /* Extents could have been merged, invalidate our position */
499 epos
.block
= dinfo
->i_location
;
500 epos
.offset
= udf_file_entry_alloc_offset(dir
);
502 if (!fibh
->soffset
) {
503 /* Find the freshly allocated block */
504 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
505 (EXT_RECORDED_ALLOCATED
>> 30))
507 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
508 dir
->i_sb
->s_blocksize_bits
);
510 fibh
->sbh
= fibh
->ebh
;
511 fi
= (struct fileIdentDesc
*)(fibh
->sbh
->b_data
);
513 fi
= (struct fileIdentDesc
*)
514 (fibh
->sbh
->b_data
+ sb
->s_blocksize
+
519 memset(cfi
, 0, sizeof(struct fileIdentDesc
));
520 if (UDF_SB(sb
)->s_udfrev
>= 0x0200)
521 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 3, 1, block
,
524 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 2, 1, block
,
526 cfi
->fileVersionNum
= cpu_to_le16(1);
527 cfi
->lengthFileIdent
= namelen
;
528 cfi
->lengthOfImpUse
= cpu_to_le16(0);
529 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
, name
)) {
530 dir
->i_size
+= nfidlen
;
531 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
532 dinfo
->i_lenAlloc
+= nfidlen
;
534 /* Find the last extent and truncate it to proper size */
535 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
536 (EXT_RECORDED_ALLOCATED
>> 30))
538 elen
-= dinfo
->i_lenExtents
- dir
->i_size
;
539 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
540 epos
.offset
-= sizeof(struct short_ad
);
541 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
542 epos
.offset
-= sizeof(struct long_ad
);
543 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
544 dinfo
->i_lenExtents
= dir
->i_size
;
547 mark_inode_dirty(dir
);
556 if (fibh
->sbh
!= fibh
->ebh
)
565 static int udf_delete_entry(struct inode
*inode
, struct fileIdentDesc
*fi
,
566 struct udf_fileident_bh
*fibh
,
567 struct fileIdentDesc
*cfi
)
569 cfi
->fileCharacteristics
|= FID_FILE_CHAR_DELETED
;
571 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
572 memset(&(cfi
->icb
), 0x00, sizeof(struct long_ad
));
574 return udf_write_fi(inode
, cfi
, fi
, fibh
, NULL
, NULL
);
577 static int udf_add_nondir(struct dentry
*dentry
, struct inode
*inode
)
579 struct udf_inode_info
*iinfo
= UDF_I(inode
);
580 struct inode
*dir
= d_inode(dentry
->d_parent
);
581 struct udf_fileident_bh fibh
;
582 struct fileIdentDesc cfi
, *fi
;
585 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
587 inode_dec_link_count(inode
);
588 discard_new_inode(inode
);
591 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
592 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
593 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
594 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
595 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
596 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
597 mark_inode_dirty(dir
);
598 if (fibh
.sbh
!= fibh
.ebh
)
601 d_instantiate_new(dentry
, inode
);
606 static int udf_create(struct user_namespace
*mnt_userns
, struct inode
*dir
,
607 struct dentry
*dentry
, umode_t mode
, bool excl
)
609 struct inode
*inode
= udf_new_inode(dir
, mode
);
612 return PTR_ERR(inode
);
614 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
615 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
617 inode
->i_data
.a_ops
= &udf_aops
;
618 inode
->i_op
= &udf_file_inode_operations
;
619 inode
->i_fop
= &udf_file_operations
;
620 mark_inode_dirty(inode
);
622 return udf_add_nondir(dentry
, inode
);
625 static int udf_tmpfile(struct user_namespace
*mnt_userns
, struct inode
*dir
,
626 struct dentry
*dentry
, umode_t mode
)
628 struct inode
*inode
= udf_new_inode(dir
, mode
);
631 return PTR_ERR(inode
);
633 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
634 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
636 inode
->i_data
.a_ops
= &udf_aops
;
637 inode
->i_op
= &udf_file_inode_operations
;
638 inode
->i_fop
= &udf_file_operations
;
639 mark_inode_dirty(inode
);
640 d_tmpfile(dentry
, inode
);
641 unlock_new_inode(inode
);
645 static int udf_mknod(struct user_namespace
*mnt_userns
, struct inode
*dir
,
646 struct dentry
*dentry
, umode_t mode
, dev_t rdev
)
650 if (!old_valid_dev(rdev
))
653 inode
= udf_new_inode(dir
, mode
);
655 return PTR_ERR(inode
);
657 init_special_inode(inode
, mode
, rdev
);
658 return udf_add_nondir(dentry
, inode
);
661 static int udf_mkdir(struct user_namespace
*mnt_userns
, struct inode
*dir
,
662 struct dentry
*dentry
, umode_t mode
)
665 struct udf_fileident_bh fibh
;
666 struct fileIdentDesc cfi
, *fi
;
668 struct udf_inode_info
*dinfo
= UDF_I(dir
);
669 struct udf_inode_info
*iinfo
;
671 inode
= udf_new_inode(dir
, S_IFDIR
| mode
);
673 return PTR_ERR(inode
);
675 iinfo
= UDF_I(inode
);
676 inode
->i_op
= &udf_dir_inode_operations
;
677 inode
->i_fop
= &udf_dir_operations
;
678 fi
= udf_add_entry(inode
, NULL
, &fibh
, &cfi
, &err
);
680 inode_dec_link_count(inode
);
681 discard_new_inode(inode
);
685 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
686 cfi
.icb
.extLocation
= cpu_to_lelb(dinfo
->i_location
);
687 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
688 cpu_to_le32(dinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
689 cfi
.fileCharacteristics
=
690 FID_FILE_CHAR_DIRECTORY
| FID_FILE_CHAR_PARENT
;
691 udf_write_fi(inode
, &cfi
, fi
, &fibh
, NULL
, NULL
);
693 mark_inode_dirty(inode
);
695 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
698 mark_inode_dirty(inode
);
699 discard_new_inode(inode
);
702 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
703 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
704 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
705 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
706 cfi
.fileCharacteristics
|= FID_FILE_CHAR_DIRECTORY
;
707 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
709 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
710 mark_inode_dirty(dir
);
711 d_instantiate_new(dentry
, inode
);
712 if (fibh
.sbh
!= fibh
.ebh
)
721 static int empty_dir(struct inode
*dir
)
723 struct fileIdentDesc
*fi
, cfi
;
724 struct udf_fileident_bh fibh
;
726 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
728 struct kernel_lb_addr eloc
;
731 struct extent_position epos
= {};
732 struct udf_inode_info
*dinfo
= UDF_I(dir
);
734 f_pos
= udf_ext0_offset(dir
);
735 fibh
.soffset
= fibh
.eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
737 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
738 fibh
.sbh
= fibh
.ebh
= NULL
;
739 else if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
,
740 &epos
, &eloc
, &elen
, &offset
) ==
741 (EXT_RECORDED_ALLOCATED
>> 30)) {
742 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
743 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
744 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
745 epos
.offset
-= sizeof(struct short_ad
);
746 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
747 epos
.offset
-= sizeof(struct long_ad
);
751 fibh
.sbh
= fibh
.ebh
= udf_tread(dir
->i_sb
, block
);
761 while (f_pos
< size
) {
762 fi
= udf_fileident_read(dir
, &f_pos
, &fibh
, &cfi
, &epos
, &eloc
,
765 if (fibh
.sbh
!= fibh
.ebh
)
772 if (cfi
.lengthFileIdent
&&
773 (cfi
.fileCharacteristics
& FID_FILE_CHAR_DELETED
) == 0) {
774 if (fibh
.sbh
!= fibh
.ebh
)
782 if (fibh
.sbh
!= fibh
.ebh
)
790 static int udf_rmdir(struct inode
*dir
, struct dentry
*dentry
)
793 struct inode
*inode
= d_inode(dentry
);
794 struct udf_fileident_bh fibh
;
795 struct fileIdentDesc
*fi
, cfi
;
796 struct kernel_lb_addr tloc
;
799 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
800 if (IS_ERR_OR_NULL(fi
)) {
802 retval
= PTR_ERR(fi
);
807 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
808 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
811 if (!empty_dir(inode
))
813 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
816 if (inode
->i_nlink
!= 2)
817 udf_warn(inode
->i_sb
, "empty directory has nlink != 2 (%u)\n",
821 inode_dec_link_count(dir
);
822 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
=
824 mark_inode_dirty(dir
);
827 if (fibh
.sbh
!= fibh
.ebh
)
835 static int udf_unlink(struct inode
*dir
, struct dentry
*dentry
)
838 struct inode
*inode
= d_inode(dentry
);
839 struct udf_fileident_bh fibh
;
840 struct fileIdentDesc
*fi
;
841 struct fileIdentDesc cfi
;
842 struct kernel_lb_addr tloc
;
845 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
847 if (IS_ERR_OR_NULL(fi
)) {
849 retval
= PTR_ERR(fi
);
854 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
855 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
858 if (!inode
->i_nlink
) {
859 udf_debug("Deleting nonexistent file (%lu), %u\n",
860 inode
->i_ino
, inode
->i_nlink
);
863 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
866 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
867 mark_inode_dirty(dir
);
868 inode_dec_link_count(inode
);
869 inode
->i_ctime
= dir
->i_ctime
;
873 if (fibh
.sbh
!= fibh
.ebh
)
881 static int udf_symlink(struct user_namespace
*mnt_userns
, struct inode
*dir
,
882 struct dentry
*dentry
, const char *symname
)
884 struct inode
*inode
= udf_new_inode(dir
, S_IFLNK
| 0777);
885 struct pathComponent
*pc
;
886 const char *compstart
;
887 struct extent_position epos
= {};
888 int eoffset
, elen
= 0;
892 unsigned char *name
= NULL
;
894 struct udf_inode_info
*iinfo
;
895 struct super_block
*sb
= dir
->i_sb
;
898 return PTR_ERR(inode
);
900 iinfo
= UDF_I(inode
);
901 down_write(&iinfo
->i_data_sem
);
902 name
= kmalloc(UDF_NAME_LEN_CS0
, GFP_NOFS
);
908 inode
->i_data
.a_ops
= &udf_symlink_aops
;
909 inode
->i_op
= &udf_symlink_inode_operations
;
910 inode_nohighmem(inode
);
912 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
913 struct kernel_lb_addr eloc
;
916 block
= udf_new_block(sb
, inode
,
917 iinfo
->i_location
.partitionReferenceNum
,
918 iinfo
->i_location
.logicalBlockNum
, &err
);
921 epos
.block
= iinfo
->i_location
;
922 epos
.offset
= udf_file_entry_alloc_offset(inode
);
924 eloc
.logicalBlockNum
= block
;
925 eloc
.partitionReferenceNum
=
926 iinfo
->i_location
.partitionReferenceNum
;
927 bsize
= sb
->s_blocksize
;
928 iinfo
->i_lenExtents
= bsize
;
929 udf_add_aext(inode
, &epos
, &eloc
, bsize
, 0);
932 block
= udf_get_pblock(sb
, block
,
933 iinfo
->i_location
.partitionReferenceNum
,
935 epos
.bh
= udf_tgetblk(sb
, block
);
936 if (unlikely(!epos
.bh
)) {
940 lock_buffer(epos
.bh
);
941 memset(epos
.bh
->b_data
, 0x00, bsize
);
942 set_buffer_uptodate(epos
.bh
);
943 unlock_buffer(epos
.bh
);
944 mark_buffer_dirty_inode(epos
.bh
, inode
);
945 ea
= epos
.bh
->b_data
+ udf_ext0_offset(inode
);
947 ea
= iinfo
->i_data
+ iinfo
->i_lenEAttr
;
949 eoffset
= sb
->s_blocksize
- udf_ext0_offset(inode
);
950 pc
= (struct pathComponent
*)ea
;
952 if (*symname
== '/') {
955 } while (*symname
== '/');
957 pc
->componentType
= 1;
958 pc
->lengthComponentIdent
= 0;
959 pc
->componentFileVersionNum
= 0;
960 elen
+= sizeof(struct pathComponent
);
966 if (elen
+ sizeof(struct pathComponent
) > eoffset
)
969 pc
= (struct pathComponent
*)(ea
+ elen
);
975 } while (*symname
&& *symname
!= '/');
977 pc
->componentType
= 5;
978 pc
->lengthComponentIdent
= 0;
979 pc
->componentFileVersionNum
= 0;
980 if (compstart
[0] == '.') {
981 if ((symname
- compstart
) == 1)
982 pc
->componentType
= 4;
983 else if ((symname
- compstart
) == 2 &&
985 pc
->componentType
= 3;
988 if (pc
->componentType
== 5) {
989 namelen
= udf_put_filename(sb
, compstart
,
991 name
, UDF_NAME_LEN_CS0
);
995 if (elen
+ sizeof(struct pathComponent
) + namelen
>
999 pc
->lengthComponentIdent
= namelen
;
1001 memcpy(pc
->componentIdent
, name
, namelen
);
1004 elen
+= sizeof(struct pathComponent
) + pc
->lengthComponentIdent
;
1009 } while (*symname
== '/');
1014 inode
->i_size
= elen
;
1015 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1016 iinfo
->i_lenAlloc
= inode
->i_size
;
1018 udf_truncate_tail_extent(inode
);
1019 mark_inode_dirty(inode
);
1020 up_write(&iinfo
->i_data_sem
);
1022 err
= udf_add_nondir(dentry
, inode
);
1028 up_write(&iinfo
->i_data_sem
);
1029 inode_dec_link_count(inode
);
1030 discard_new_inode(inode
);
1034 static int udf_link(struct dentry
*old_dentry
, struct inode
*dir
,
1035 struct dentry
*dentry
)
1037 struct inode
*inode
= d_inode(old_dentry
);
1038 struct udf_fileident_bh fibh
;
1039 struct fileIdentDesc cfi
, *fi
;
1042 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
1046 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
1047 cfi
.icb
.extLocation
= cpu_to_lelb(UDF_I(inode
)->i_location
);
1048 if (UDF_SB(inode
->i_sb
)->s_lvid_bh
) {
1049 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
1050 cpu_to_le32(lvid_get_unique_id(inode
->i_sb
));
1052 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
1053 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1054 mark_inode_dirty(dir
);
1056 if (fibh
.sbh
!= fibh
.ebh
)
1060 inode
->i_ctime
= current_time(inode
);
1061 mark_inode_dirty(inode
);
1062 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
1063 mark_inode_dirty(dir
);
1065 d_instantiate(dentry
, inode
);
1070 /* Anybody can rename anything with this: the permission checks are left to the
1071 * higher-level routines.
1073 static int udf_rename(struct user_namespace
*mnt_userns
, struct inode
*old_dir
,
1074 struct dentry
*old_dentry
, struct inode
*new_dir
,
1075 struct dentry
*new_dentry
, unsigned int flags
)
1077 struct inode
*old_inode
= d_inode(old_dentry
);
1078 struct inode
*new_inode
= d_inode(new_dentry
);
1079 struct udf_fileident_bh ofibh
, nfibh
;
1080 struct fileIdentDesc
*ofi
= NULL
, *nfi
= NULL
, *dir_fi
= NULL
;
1081 struct fileIdentDesc ocfi
, ncfi
;
1082 struct buffer_head
*dir_bh
= NULL
;
1083 int retval
= -ENOENT
;
1084 struct kernel_lb_addr tloc
;
1085 struct udf_inode_info
*old_iinfo
= UDF_I(old_inode
);
1087 if (flags
& ~RENAME_NOREPLACE
)
1090 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1092 retval
= PTR_ERR(ofi
);
1096 if (ofibh
.sbh
!= ofibh
.ebh
)
1100 tloc
= lelb_to_cpu(ocfi
.icb
.extLocation
);
1101 if (!ofi
|| udf_get_lb_pblock(old_dir
->i_sb
, &tloc
, 0)
1102 != old_inode
->i_ino
)
1105 nfi
= udf_find_entry(new_dir
, &new_dentry
->d_name
, &nfibh
, &ncfi
);
1107 retval
= PTR_ERR(nfi
);
1110 if (nfi
&& !new_inode
) {
1111 if (nfibh
.sbh
!= nfibh
.ebh
)
1116 if (S_ISDIR(old_inode
->i_mode
)) {
1117 int offset
= udf_ext0_offset(old_inode
);
1120 retval
= -ENOTEMPTY
;
1121 if (!empty_dir(new_inode
))
1125 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1126 dir_fi
= udf_get_fileident(
1129 sizeof(struct extendedFileEntry
) :
1130 sizeof(struct fileEntry
)),
1131 old_inode
->i_sb
->s_blocksize
, &offset
);
1133 dir_bh
= udf_bread(old_inode
, 0, 0, &retval
);
1136 dir_fi
= udf_get_fileident(dir_bh
->b_data
,
1137 old_inode
->i_sb
->s_blocksize
, &offset
);
1141 tloc
= lelb_to_cpu(dir_fi
->icb
.extLocation
);
1142 if (udf_get_lb_pblock(old_inode
->i_sb
, &tloc
, 0) !=
1147 nfi
= udf_add_entry(new_dir
, new_dentry
, &nfibh
, &ncfi
,
1154 * Like most other Unix systems, set the ctime for inodes on a
1157 old_inode
->i_ctime
= current_time(old_inode
);
1158 mark_inode_dirty(old_inode
);
1163 ncfi
.fileVersionNum
= ocfi
.fileVersionNum
;
1164 ncfi
.fileCharacteristics
= ocfi
.fileCharacteristics
;
1165 memcpy(&(ncfi
.icb
), &(ocfi
.icb
), sizeof(ocfi
.icb
));
1166 udf_write_fi(new_dir
, &ncfi
, nfi
, &nfibh
, NULL
, NULL
);
1168 /* The old fid may have moved - find it again */
1169 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1170 udf_delete_entry(old_dir
, ofi
, &ofibh
, &ocfi
);
1173 new_inode
->i_ctime
= current_time(new_inode
);
1174 inode_dec_link_count(new_inode
);
1176 old_dir
->i_ctime
= old_dir
->i_mtime
= current_time(old_dir
);
1177 new_dir
->i_ctime
= new_dir
->i_mtime
= current_time(new_dir
);
1178 mark_inode_dirty(old_dir
);
1179 mark_inode_dirty(new_dir
);
1182 dir_fi
->icb
.extLocation
= cpu_to_lelb(UDF_I(new_dir
)->i_location
);
1183 udf_update_tag((char *)dir_fi
, udf_dir_entry_len(dir_fi
));
1184 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1185 mark_inode_dirty(old_inode
);
1187 mark_buffer_dirty_inode(dir_bh
, old_inode
);
1189 inode_dec_link_count(old_dir
);
1191 inode_dec_link_count(new_inode
);
1194 mark_inode_dirty(new_dir
);
1199 if (ofibh
.sbh
!= ofibh
.ebh
)
1209 if (nfibh
.sbh
!= nfibh
.ebh
)
1217 static struct dentry
*udf_get_parent(struct dentry
*child
)
1219 struct kernel_lb_addr tloc
;
1220 struct inode
*inode
= NULL
;
1221 struct fileIdentDesc cfi
;
1222 struct udf_fileident_bh fibh
;
1224 if (!udf_find_entry(d_inode(child
), &dotdot_name
, &fibh
, &cfi
))
1225 return ERR_PTR(-EACCES
);
1227 if (fibh
.sbh
!= fibh
.ebh
)
1231 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
1232 inode
= udf_iget(child
->d_sb
, &tloc
);
1234 return ERR_CAST(inode
);
1236 return d_obtain_alias(inode
);
1240 static struct dentry
*udf_nfs_get_inode(struct super_block
*sb
, u32 block
,
1241 u16 partref
, __u32 generation
)
1243 struct inode
*inode
;
1244 struct kernel_lb_addr loc
;
1247 return ERR_PTR(-ESTALE
);
1249 loc
.logicalBlockNum
= block
;
1250 loc
.partitionReferenceNum
= partref
;
1251 inode
= udf_iget(sb
, &loc
);
1254 return ERR_CAST(inode
);
1256 if (generation
&& inode
->i_generation
!= generation
) {
1258 return ERR_PTR(-ESTALE
);
1260 return d_obtain_alias(inode
);
1263 static struct dentry
*udf_fh_to_dentry(struct super_block
*sb
,
1264 struct fid
*fid
, int fh_len
, int fh_type
)
1267 (fh_type
!= FILEID_UDF_WITH_PARENT
&&
1268 fh_type
!= FILEID_UDF_WITHOUT_PARENT
))
1271 return udf_nfs_get_inode(sb
, fid
->udf
.block
, fid
->udf
.partref
,
1272 fid
->udf
.generation
);
1275 static struct dentry
*udf_fh_to_parent(struct super_block
*sb
,
1276 struct fid
*fid
, int fh_len
, int fh_type
)
1278 if (fh_len
< 5 || fh_type
!= FILEID_UDF_WITH_PARENT
)
1281 return udf_nfs_get_inode(sb
, fid
->udf
.parent_block
,
1282 fid
->udf
.parent_partref
,
1283 fid
->udf
.parent_generation
);
1285 static int udf_encode_fh(struct inode
*inode
, __u32
*fh
, int *lenp
,
1286 struct inode
*parent
)
1289 struct kernel_lb_addr location
= UDF_I(inode
)->i_location
;
1290 struct fid
*fid
= (struct fid
*)fh
;
1291 int type
= FILEID_UDF_WITHOUT_PARENT
;
1293 if (parent
&& (len
< 5)) {
1295 return FILEID_INVALID
;
1296 } else if (len
< 3) {
1298 return FILEID_INVALID
;
1302 fid
->udf
.block
= location
.logicalBlockNum
;
1303 fid
->udf
.partref
= location
.partitionReferenceNum
;
1304 fid
->udf
.parent_partref
= 0;
1305 fid
->udf
.generation
= inode
->i_generation
;
1308 location
= UDF_I(parent
)->i_location
;
1309 fid
->udf
.parent_block
= location
.logicalBlockNum
;
1310 fid
->udf
.parent_partref
= location
.partitionReferenceNum
;
1311 fid
->udf
.parent_generation
= inode
->i_generation
;
1313 type
= FILEID_UDF_WITH_PARENT
;
1319 const struct export_operations udf_export_ops
= {
1320 .encode_fh
= udf_encode_fh
,
1321 .fh_to_dentry
= udf_fh_to_dentry
,
1322 .fh_to_parent
= udf_fh_to_parent
,
1323 .get_parent
= udf_get_parent
,
1326 const struct inode_operations udf_dir_inode_operations
= {
1327 .lookup
= udf_lookup
,
1328 .create
= udf_create
,
1330 .unlink
= udf_unlink
,
1331 .symlink
= udf_symlink
,
1335 .rename
= udf_rename
,
1336 .tmpfile
= udf_tmpfile
,