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((uint8_t *)sfi
->fileIdent
+ liu
, fileident
, lfi
);
78 } else if (offset
>= 0) {
79 memcpy(fibh
->ebh
->b_data
+ offset
, fileident
, lfi
);
81 memcpy((uint8_t *)sfi
->fileIdent
+ liu
, fileident
,
83 memcpy(fibh
->ebh
->b_data
, fileident
- offset
,
90 if (adinicb
|| (offset
+ padlen
< 0)) {
91 memset((uint8_t *)sfi
->padding
+ liu
+ lfi
, 0x00, padlen
);
92 } else if (offset
>= 0) {
93 memset(fibh
->ebh
->b_data
+ offset
, 0x00, padlen
);
95 memset((uint8_t *)sfi
->padding
+ liu
+ lfi
, 0x00, -offset
);
96 memset(fibh
->ebh
->b_data
, 0x00, padlen
+ offset
);
99 crc
= crc_itu_t(0, (uint8_t *)cfi
+ sizeof(struct tag
),
100 sizeof(struct fileIdentDesc
) - sizeof(struct tag
));
102 if (fibh
->sbh
== fibh
->ebh
) {
103 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
104 crclen
+ sizeof(struct tag
) -
105 sizeof(struct fileIdentDesc
));
106 } else if (sizeof(struct fileIdentDesc
) >= -fibh
->soffset
) {
107 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
+
108 sizeof(struct fileIdentDesc
) +
110 crclen
+ sizeof(struct tag
) -
111 sizeof(struct fileIdentDesc
));
113 crc
= crc_itu_t(crc
, (uint8_t *)sfi
->impUse
,
114 -fibh
->soffset
- sizeof(struct fileIdentDesc
));
115 crc
= crc_itu_t(crc
, fibh
->ebh
->b_data
, fibh
->eoffset
);
118 cfi
->descTag
.descCRC
= cpu_to_le16(crc
);
119 cfi
->descTag
.descCRCLength
= cpu_to_le16(crclen
);
120 cfi
->descTag
.tagChecksum
= udf_tag_checksum(&cfi
->descTag
);
122 if (adinicb
|| (sizeof(struct fileIdentDesc
) <= -fibh
->soffset
)) {
123 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
,
124 sizeof(struct fileIdentDesc
));
126 memcpy((uint8_t *)sfi
, (uint8_t *)cfi
, -fibh
->soffset
);
127 memcpy(fibh
->ebh
->b_data
, (uint8_t *)cfi
- fibh
->soffset
,
128 sizeof(struct fileIdentDesc
) + fibh
->soffset
);
132 mark_inode_dirty(inode
);
134 if (fibh
->sbh
!= fibh
->ebh
)
135 mark_buffer_dirty_inode(fibh
->ebh
, inode
);
136 mark_buffer_dirty_inode(fibh
->sbh
, inode
);
142 * udf_find_entry - find entry in given directory.
144 * @dir: directory inode to search in
145 * @child: qstr of the name
146 * @fibh: buffer head / inode with file identifier descriptor we found
147 * @cfi: found file identifier descriptor with given name
149 * This function searches in the directory @dir for a file name @child. When
150 * found, @fibh points to the buffer head(s) (bh is NULL for in ICB
151 * directories) containing the file identifier descriptor (FID). In that case
152 * the function returns pointer to the FID in the buffer or inode - but note
153 * that FID may be split among two buffers (blocks) so accessing it via that
154 * pointer isn't easily possible. This pointer can be used only as an iterator
155 * for other directory manipulation functions. For inspection of the FID @cfi
156 * can be used - the found FID is copied there.
158 * Returns pointer to FID, NULL when nothing found, or error code.
160 static struct fileIdentDesc
*udf_find_entry(struct inode
*dir
,
161 const struct qstr
*child
,
162 struct udf_fileident_bh
*fibh
,
163 struct fileIdentDesc
*cfi
)
165 struct fileIdentDesc
*fi
= NULL
;
169 unsigned char *fname
= NULL
, *copy_name
= NULL
;
170 unsigned char *nameptr
;
174 struct kernel_lb_addr eloc
;
177 struct extent_position epos
= {};
178 struct udf_inode_info
*dinfo
= UDF_I(dir
);
179 int isdotdot
= child
->len
== 2 &&
180 child
->name
[0] == '.' && child
->name
[1] == '.';
181 struct super_block
*sb
= dir
->i_sb
;
183 size
= udf_ext0_offset(dir
) + dir
->i_size
;
184 f_pos
= udf_ext0_offset(dir
);
186 fibh
->sbh
= fibh
->ebh
= NULL
;
187 fibh
->soffset
= fibh
->eoffset
= f_pos
& (sb
->s_blocksize
- 1);
188 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
189 if (inode_bmap(dir
, f_pos
>> sb
->s_blocksize_bits
, &epos
,
190 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30)) {
195 block
= udf_get_lb_pblock(sb
, &eloc
, offset
);
196 if ((++offset
<< sb
->s_blocksize_bits
) < elen
) {
197 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
198 epos
.offset
-= sizeof(struct short_ad
);
199 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
200 epos
.offset
-= sizeof(struct long_ad
);
204 fibh
->sbh
= fibh
->ebh
= udf_tread(sb
, block
);
211 fname
= kmalloc(UDF_NAME_LEN
, GFP_NOFS
);
213 fi
= ERR_PTR(-ENOMEM
);
217 while (f_pos
< size
) {
218 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
225 liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
226 lfi
= cfi
->lengthFileIdent
;
228 if (fibh
->sbh
== fibh
->ebh
) {
229 nameptr
= fi
->fileIdent
+ liu
;
231 int poffset
; /* Unpaded ending offset */
233 poffset
= fibh
->soffset
+ sizeof(struct fileIdentDesc
) +
237 nameptr
= (uint8_t *)(fibh
->ebh
->b_data
+
241 copy_name
= kmalloc(UDF_NAME_LEN
,
244 fi
= ERR_PTR(-ENOMEM
);
249 memcpy(nameptr
, fi
->fileIdent
+ liu
,
251 memcpy(nameptr
+ lfi
- poffset
,
252 fibh
->ebh
->b_data
, poffset
);
256 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
257 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_UNDELETE
))
261 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_HIDDEN
) != 0) {
262 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_UNHIDE
))
266 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_PARENT
) &&
273 flen
= udf_get_filename(sb
, nameptr
, lfi
, fname
, UDF_NAME_LEN
);
279 if (udf_match(flen
, fname
, child
->len
, child
->name
))
285 if (fibh
->sbh
!= fibh
->ebh
)
296 static struct dentry
*udf_lookup(struct inode
*dir
, struct dentry
*dentry
,
299 struct inode
*inode
= NULL
;
300 struct fileIdentDesc cfi
;
301 struct udf_fileident_bh fibh
;
302 struct fileIdentDesc
*fi
;
304 if (dentry
->d_name
.len
> UDF_NAME_LEN
)
305 return ERR_PTR(-ENAMETOOLONG
);
308 /* temporary shorthand for specifying files by inode number */
309 if (!strncmp(dentry
->d_name
.name
, ".B=", 3)) {
310 struct kernel_lb_addr lb
= {
311 .logicalBlockNum
= 0,
312 .partitionReferenceNum
=
313 simple_strtoul(dentry
->d_name
.name
+ 3,
316 inode
= udf_iget(dir
->i_sb
, lb
);
320 #endif /* UDF_RECOVERY */
322 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
327 struct kernel_lb_addr loc
;
329 if (fibh
.sbh
!= fibh
.ebh
)
333 loc
= lelb_to_cpu(cfi
.icb
.extLocation
);
334 inode
= udf_iget(dir
->i_sb
, &loc
);
336 return ERR_CAST(inode
);
339 return d_splice_alias(inode
, dentry
);
342 static struct fileIdentDesc
*udf_add_entry(struct inode
*dir
,
343 struct dentry
*dentry
,
344 struct udf_fileident_bh
*fibh
,
345 struct fileIdentDesc
*cfi
, int *err
)
347 struct super_block
*sb
= dir
->i_sb
;
348 struct fileIdentDesc
*fi
= NULL
;
349 unsigned char *name
= NULL
;
352 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
357 struct kernel_lb_addr eloc
;
360 struct extent_position epos
= {};
361 struct udf_inode_info
*dinfo
;
363 fibh
->sbh
= fibh
->ebh
= NULL
;
364 name
= kmalloc(UDF_NAME_LEN_CS0
, GFP_NOFS
);
371 if (!dentry
->d_name
.len
) {
375 namelen
= udf_put_filename(sb
, dentry
->d_name
.name
,
377 name
, UDF_NAME_LEN_CS0
);
379 *err
= -ENAMETOOLONG
;
386 nfidlen
= (sizeof(struct fileIdentDesc
) + namelen
+ 3) & ~3;
388 f_pos
= udf_ext0_offset(dir
);
390 fibh
->soffset
= fibh
->eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
392 if (dinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
393 if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
, &epos
,
394 &eloc
, &elen
, &offset
) != (EXT_RECORDED_ALLOCATED
>> 30)) {
395 block
= udf_get_lb_pblock(dir
->i_sb
,
396 &dinfo
->i_location
, 0);
397 fibh
->soffset
= fibh
->eoffset
= sb
->s_blocksize
;
400 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
401 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
402 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
403 epos
.offset
-= sizeof(struct short_ad
);
404 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
405 epos
.offset
-= sizeof(struct long_ad
);
409 fibh
->sbh
= fibh
->ebh
= udf_tread(dir
->i_sb
, block
);
415 block
= dinfo
->i_location
.logicalBlockNum
;
418 while (f_pos
< size
) {
419 fi
= udf_fileident_read(dir
, &f_pos
, fibh
, cfi
, &epos
, &eloc
,
427 liu
= le16_to_cpu(cfi
->lengthOfImpUse
);
428 lfi
= cfi
->lengthFileIdent
;
430 if ((cfi
->fileCharacteristics
& FID_FILE_CHAR_DELETED
) != 0) {
431 if (((sizeof(struct fileIdentDesc
) +
432 liu
+ lfi
+ 3) & ~3) == nfidlen
) {
433 cfi
->descTag
.tagSerialNum
= cpu_to_le16(1);
434 cfi
->fileVersionNum
= cpu_to_le16(1);
435 cfi
->fileCharacteristics
= 0;
436 cfi
->lengthFileIdent
= namelen
;
437 cfi
->lengthOfImpUse
= cpu_to_le16(0);
438 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
,
452 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
&&
453 sb
->s_blocksize
- fibh
->eoffset
< nfidlen
) {
456 fibh
->soffset
-= udf_ext0_offset(dir
);
457 fibh
->eoffset
-= udf_ext0_offset(dir
);
458 f_pos
-= udf_ext0_offset(dir
);
459 if (fibh
->sbh
!= fibh
->ebh
)
462 fibh
->sbh
= fibh
->ebh
=
463 udf_expand_dir_adinicb(dir
, &block
, err
);
466 epos
.block
= dinfo
->i_location
;
467 epos
.offset
= udf_file_entry_alloc_offset(dir
);
468 /* Load extent udf_expand_dir_adinicb() has created */
469 udf_current_aext(dir
, &epos
, &eloc
, &elen
, 1);
472 /* Entry fits into current block? */
473 if (sb
->s_blocksize
- fibh
->eoffset
>= nfidlen
) {
474 fibh
->soffset
= fibh
->eoffset
;
475 fibh
->eoffset
+= nfidlen
;
476 if (fibh
->sbh
!= fibh
->ebh
) {
478 fibh
->sbh
= fibh
->ebh
;
481 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
482 block
= dinfo
->i_location
.logicalBlockNum
;
483 fi
= (struct fileIdentDesc
*)
484 (dinfo
->i_ext
.i_data
+
486 udf_ext0_offset(dir
) +
489 block
= eloc
.logicalBlockNum
+
491 dir
->i_sb
->s_blocksize_bits
);
492 fi
= (struct fileIdentDesc
*)
493 (fibh
->sbh
->b_data
+ fibh
->soffset
);
496 /* Round up last extent in the file */
497 elen
= (elen
+ sb
->s_blocksize
- 1) & ~(sb
->s_blocksize
- 1);
498 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
499 epos
.offset
-= sizeof(struct short_ad
);
500 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
501 epos
.offset
-= sizeof(struct long_ad
);
502 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
503 dinfo
->i_lenExtents
= (dinfo
->i_lenExtents
+ sb
->s_blocksize
504 - 1) & ~(sb
->s_blocksize
- 1);
506 fibh
->soffset
= fibh
->eoffset
- sb
->s_blocksize
;
507 fibh
->eoffset
+= nfidlen
- sb
->s_blocksize
;
508 if (fibh
->sbh
!= fibh
->ebh
) {
510 fibh
->sbh
= fibh
->ebh
;
513 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
514 dir
->i_sb
->s_blocksize_bits
);
515 fibh
->ebh
= udf_bread(dir
,
516 f_pos
>> dir
->i_sb
->s_blocksize_bits
, 1, err
);
519 /* Extents could have been merged, invalidate our position */
522 epos
.block
= dinfo
->i_location
;
523 epos
.offset
= udf_file_entry_alloc_offset(dir
);
525 if (!fibh
->soffset
) {
526 /* Find the freshly allocated block */
527 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
528 (EXT_RECORDED_ALLOCATED
>> 30))
530 block
= eloc
.logicalBlockNum
+ ((elen
- 1) >>
531 dir
->i_sb
->s_blocksize_bits
);
533 fibh
->sbh
= fibh
->ebh
;
534 fi
= (struct fileIdentDesc
*)(fibh
->sbh
->b_data
);
536 fi
= (struct fileIdentDesc
*)
537 (fibh
->sbh
->b_data
+ sb
->s_blocksize
+
542 memset(cfi
, 0, sizeof(struct fileIdentDesc
));
543 if (UDF_SB(sb
)->s_udfrev
>= 0x0200)
544 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 3, 1, block
,
547 udf_new_tag((char *)cfi
, TAG_IDENT_FID
, 2, 1, block
,
549 cfi
->fileVersionNum
= cpu_to_le16(1);
550 cfi
->lengthFileIdent
= namelen
;
551 cfi
->lengthOfImpUse
= cpu_to_le16(0);
552 if (!udf_write_fi(dir
, cfi
, fi
, fibh
, NULL
, name
)) {
553 dir
->i_size
+= nfidlen
;
554 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
555 dinfo
->i_lenAlloc
+= nfidlen
;
557 /* Find the last extent and truncate it to proper size */
558 while (udf_next_aext(dir
, &epos
, &eloc
, &elen
, 1) ==
559 (EXT_RECORDED_ALLOCATED
>> 30))
561 elen
-= dinfo
->i_lenExtents
- dir
->i_size
;
562 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
563 epos
.offset
-= sizeof(struct short_ad
);
564 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
565 epos
.offset
-= sizeof(struct long_ad
);
566 udf_write_aext(dir
, &epos
, &eloc
, elen
, 1);
567 dinfo
->i_lenExtents
= dir
->i_size
;
570 mark_inode_dirty(dir
);
579 if (fibh
->sbh
!= fibh
->ebh
)
588 static int udf_delete_entry(struct inode
*inode
, struct fileIdentDesc
*fi
,
589 struct udf_fileident_bh
*fibh
,
590 struct fileIdentDesc
*cfi
)
592 cfi
->fileCharacteristics
|= FID_FILE_CHAR_DELETED
;
594 if (UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
))
595 memset(&(cfi
->icb
), 0x00, sizeof(struct long_ad
));
597 return udf_write_fi(inode
, cfi
, fi
, fibh
, NULL
, NULL
);
600 static int udf_add_nondir(struct dentry
*dentry
, struct inode
*inode
)
602 struct udf_inode_info
*iinfo
= UDF_I(inode
);
603 struct inode
*dir
= d_inode(dentry
->d_parent
);
604 struct udf_fileident_bh fibh
;
605 struct fileIdentDesc cfi
, *fi
;
608 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
610 inode_dec_link_count(inode
);
611 unlock_new_inode(inode
);
615 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
616 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
617 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
618 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
619 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
620 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
621 mark_inode_dirty(dir
);
622 if (fibh
.sbh
!= fibh
.ebh
)
625 d_instantiate_new(dentry
, inode
);
630 static int udf_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
633 struct inode
*inode
= udf_new_inode(dir
, mode
);
636 return PTR_ERR(inode
);
638 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
639 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
641 inode
->i_data
.a_ops
= &udf_aops
;
642 inode
->i_op
= &udf_file_inode_operations
;
643 inode
->i_fop
= &udf_file_operations
;
644 mark_inode_dirty(inode
);
646 return udf_add_nondir(dentry
, inode
);
649 static int udf_tmpfile(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
651 struct inode
*inode
= udf_new_inode(dir
, mode
);
654 return PTR_ERR(inode
);
656 if (UDF_I(inode
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
657 inode
->i_data
.a_ops
= &udf_adinicb_aops
;
659 inode
->i_data
.a_ops
= &udf_aops
;
660 inode
->i_op
= &udf_file_inode_operations
;
661 inode
->i_fop
= &udf_file_operations
;
662 mark_inode_dirty(inode
);
663 d_tmpfile(dentry
, inode
);
664 unlock_new_inode(inode
);
668 static int udf_mknod(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
673 if (!old_valid_dev(rdev
))
676 inode
= udf_new_inode(dir
, mode
);
678 return PTR_ERR(inode
);
680 init_special_inode(inode
, mode
, rdev
);
681 return udf_add_nondir(dentry
, inode
);
684 static int udf_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
687 struct udf_fileident_bh fibh
;
688 struct fileIdentDesc cfi
, *fi
;
690 struct udf_inode_info
*dinfo
= UDF_I(dir
);
691 struct udf_inode_info
*iinfo
;
693 inode
= udf_new_inode(dir
, S_IFDIR
| mode
);
695 return PTR_ERR(inode
);
697 iinfo
= UDF_I(inode
);
698 inode
->i_op
= &udf_dir_inode_operations
;
699 inode
->i_fop
= &udf_dir_operations
;
700 fi
= udf_add_entry(inode
, NULL
, &fibh
, &cfi
, &err
);
702 inode_dec_link_count(inode
);
703 unlock_new_inode(inode
);
708 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
709 cfi
.icb
.extLocation
= cpu_to_lelb(dinfo
->i_location
);
710 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
711 cpu_to_le32(dinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
712 cfi
.fileCharacteristics
=
713 FID_FILE_CHAR_DIRECTORY
| FID_FILE_CHAR_PARENT
;
714 udf_write_fi(inode
, &cfi
, fi
, &fibh
, NULL
, NULL
);
716 mark_inode_dirty(inode
);
718 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
721 mark_inode_dirty(inode
);
722 unlock_new_inode(inode
);
726 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
727 cfi
.icb
.extLocation
= cpu_to_lelb(iinfo
->i_location
);
728 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
729 cpu_to_le32(iinfo
->i_unique
& 0x00000000FFFFFFFFUL
);
730 cfi
.fileCharacteristics
|= FID_FILE_CHAR_DIRECTORY
;
731 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
733 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
734 mark_inode_dirty(dir
);
735 d_instantiate_new(dentry
, inode
);
736 if (fibh
.sbh
!= fibh
.ebh
)
745 static int empty_dir(struct inode
*dir
)
747 struct fileIdentDesc
*fi
, cfi
;
748 struct udf_fileident_bh fibh
;
750 loff_t size
= udf_ext0_offset(dir
) + dir
->i_size
;
752 struct kernel_lb_addr eloc
;
755 struct extent_position epos
= {};
756 struct udf_inode_info
*dinfo
= UDF_I(dir
);
758 f_pos
= udf_ext0_offset(dir
);
759 fibh
.soffset
= fibh
.eoffset
= f_pos
& (dir
->i_sb
->s_blocksize
- 1);
761 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
762 fibh
.sbh
= fibh
.ebh
= NULL
;
763 else if (inode_bmap(dir
, f_pos
>> dir
->i_sb
->s_blocksize_bits
,
764 &epos
, &eloc
, &elen
, &offset
) ==
765 (EXT_RECORDED_ALLOCATED
>> 30)) {
766 block
= udf_get_lb_pblock(dir
->i_sb
, &eloc
, offset
);
767 if ((++offset
<< dir
->i_sb
->s_blocksize_bits
) < elen
) {
768 if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_SHORT
)
769 epos
.offset
-= sizeof(struct short_ad
);
770 else if (dinfo
->i_alloc_type
== ICBTAG_FLAG_AD_LONG
)
771 epos
.offset
-= sizeof(struct long_ad
);
775 fibh
.sbh
= fibh
.ebh
= udf_tread(dir
->i_sb
, block
);
785 while (f_pos
< size
) {
786 fi
= udf_fileident_read(dir
, &f_pos
, &fibh
, &cfi
, &epos
, &eloc
,
789 if (fibh
.sbh
!= fibh
.ebh
)
796 if (cfi
.lengthFileIdent
&&
797 (cfi
.fileCharacteristics
& FID_FILE_CHAR_DELETED
) == 0) {
798 if (fibh
.sbh
!= fibh
.ebh
)
806 if (fibh
.sbh
!= fibh
.ebh
)
814 static int udf_rmdir(struct inode
*dir
, struct dentry
*dentry
)
817 struct inode
*inode
= d_inode(dentry
);
818 struct udf_fileident_bh fibh
;
819 struct fileIdentDesc
*fi
, cfi
;
820 struct kernel_lb_addr tloc
;
823 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
824 if (IS_ERR_OR_NULL(fi
)) {
826 retval
= PTR_ERR(fi
);
831 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
832 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
835 if (!empty_dir(inode
))
837 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
840 if (inode
->i_nlink
!= 2)
841 udf_warn(inode
->i_sb
, "empty directory has nlink != 2 (%u)\n",
845 inode_dec_link_count(dir
);
846 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
=
848 mark_inode_dirty(dir
);
851 if (fibh
.sbh
!= fibh
.ebh
)
859 static int udf_unlink(struct inode
*dir
, struct dentry
*dentry
)
862 struct inode
*inode
= d_inode(dentry
);
863 struct udf_fileident_bh fibh
;
864 struct fileIdentDesc
*fi
;
865 struct fileIdentDesc cfi
;
866 struct kernel_lb_addr tloc
;
869 fi
= udf_find_entry(dir
, &dentry
->d_name
, &fibh
, &cfi
);
871 if (IS_ERR_OR_NULL(fi
)) {
873 retval
= PTR_ERR(fi
);
878 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
879 if (udf_get_lb_pblock(dir
->i_sb
, &tloc
, 0) != inode
->i_ino
)
882 if (!inode
->i_nlink
) {
883 udf_debug("Deleting nonexistent file (%lu), %u\n",
884 inode
->i_ino
, inode
->i_nlink
);
887 retval
= udf_delete_entry(dir
, fi
, &fibh
, &cfi
);
890 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
891 mark_inode_dirty(dir
);
892 inode_dec_link_count(inode
);
893 inode
->i_ctime
= dir
->i_ctime
;
897 if (fibh
.sbh
!= fibh
.ebh
)
905 static int udf_symlink(struct inode
*dir
, struct dentry
*dentry
,
908 struct inode
*inode
= udf_new_inode(dir
, S_IFLNK
| 0777);
909 struct pathComponent
*pc
;
910 const char *compstart
;
911 struct extent_position epos
= {};
912 int eoffset
, elen
= 0;
916 unsigned char *name
= NULL
;
918 struct udf_inode_info
*iinfo
;
919 struct super_block
*sb
= dir
->i_sb
;
922 return PTR_ERR(inode
);
924 iinfo
= UDF_I(inode
);
925 down_write(&iinfo
->i_data_sem
);
926 name
= kmalloc(UDF_NAME_LEN_CS0
, GFP_NOFS
);
932 inode
->i_data
.a_ops
= &udf_symlink_aops
;
933 inode
->i_op
= &udf_symlink_inode_operations
;
934 inode_nohighmem(inode
);
936 if (iinfo
->i_alloc_type
!= ICBTAG_FLAG_AD_IN_ICB
) {
937 struct kernel_lb_addr eloc
;
940 block
= udf_new_block(sb
, inode
,
941 iinfo
->i_location
.partitionReferenceNum
,
942 iinfo
->i_location
.logicalBlockNum
, &err
);
945 epos
.block
= iinfo
->i_location
;
946 epos
.offset
= udf_file_entry_alloc_offset(inode
);
948 eloc
.logicalBlockNum
= block
;
949 eloc
.partitionReferenceNum
=
950 iinfo
->i_location
.partitionReferenceNum
;
951 bsize
= sb
->s_blocksize
;
952 iinfo
->i_lenExtents
= bsize
;
953 udf_add_aext(inode
, &epos
, &eloc
, bsize
, 0);
956 block
= udf_get_pblock(sb
, block
,
957 iinfo
->i_location
.partitionReferenceNum
,
959 epos
.bh
= udf_tgetblk(sb
, block
);
960 lock_buffer(epos
.bh
);
961 memset(epos
.bh
->b_data
, 0x00, bsize
);
962 set_buffer_uptodate(epos
.bh
);
963 unlock_buffer(epos
.bh
);
964 mark_buffer_dirty_inode(epos
.bh
, inode
);
965 ea
= epos
.bh
->b_data
+ udf_ext0_offset(inode
);
967 ea
= iinfo
->i_ext
.i_data
+ iinfo
->i_lenEAttr
;
969 eoffset
= sb
->s_blocksize
- udf_ext0_offset(inode
);
970 pc
= (struct pathComponent
*)ea
;
972 if (*symname
== '/') {
975 } while (*symname
== '/');
977 pc
->componentType
= 1;
978 pc
->lengthComponentIdent
= 0;
979 pc
->componentFileVersionNum
= 0;
980 elen
+= sizeof(struct pathComponent
);
986 if (elen
+ sizeof(struct pathComponent
) > eoffset
)
989 pc
= (struct pathComponent
*)(ea
+ elen
);
995 } while (*symname
&& *symname
!= '/');
997 pc
->componentType
= 5;
998 pc
->lengthComponentIdent
= 0;
999 pc
->componentFileVersionNum
= 0;
1000 if (compstart
[0] == '.') {
1001 if ((symname
- compstart
) == 1)
1002 pc
->componentType
= 4;
1003 else if ((symname
- compstart
) == 2 &&
1004 compstart
[1] == '.')
1005 pc
->componentType
= 3;
1008 if (pc
->componentType
== 5) {
1009 namelen
= udf_put_filename(sb
, compstart
,
1010 symname
- compstart
,
1011 name
, UDF_NAME_LEN_CS0
);
1015 if (elen
+ sizeof(struct pathComponent
) + namelen
>
1019 pc
->lengthComponentIdent
= namelen
;
1021 memcpy(pc
->componentIdent
, name
, namelen
);
1024 elen
+= sizeof(struct pathComponent
) + pc
->lengthComponentIdent
;
1029 } while (*symname
== '/');
1034 inode
->i_size
= elen
;
1035 if (iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1036 iinfo
->i_lenAlloc
= inode
->i_size
;
1038 udf_truncate_tail_extent(inode
);
1039 mark_inode_dirty(inode
);
1040 up_write(&iinfo
->i_data_sem
);
1042 err
= udf_add_nondir(dentry
, inode
);
1048 up_write(&iinfo
->i_data_sem
);
1049 inode_dec_link_count(inode
);
1050 unlock_new_inode(inode
);
1055 static int udf_link(struct dentry
*old_dentry
, struct inode
*dir
,
1056 struct dentry
*dentry
)
1058 struct inode
*inode
= d_inode(old_dentry
);
1059 struct udf_fileident_bh fibh
;
1060 struct fileIdentDesc cfi
, *fi
;
1063 fi
= udf_add_entry(dir
, dentry
, &fibh
, &cfi
, &err
);
1067 cfi
.icb
.extLength
= cpu_to_le32(inode
->i_sb
->s_blocksize
);
1068 cfi
.icb
.extLocation
= cpu_to_lelb(UDF_I(inode
)->i_location
);
1069 if (UDF_SB(inode
->i_sb
)->s_lvid_bh
) {
1070 *(__le32
*)((struct allocDescImpUse
*)cfi
.icb
.impUse
)->impUse
=
1071 cpu_to_le32(lvid_get_unique_id(inode
->i_sb
));
1073 udf_write_fi(dir
, &cfi
, fi
, &fibh
, NULL
, NULL
);
1074 if (UDF_I(dir
)->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1075 mark_inode_dirty(dir
);
1077 if (fibh
.sbh
!= fibh
.ebh
)
1081 inode
->i_ctime
= current_time(inode
);
1082 mark_inode_dirty(inode
);
1083 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
1084 mark_inode_dirty(dir
);
1086 d_instantiate(dentry
, inode
);
1091 /* Anybody can rename anything with this: the permission checks are left to the
1092 * higher-level routines.
1094 static int udf_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1095 struct inode
*new_dir
, struct dentry
*new_dentry
,
1098 struct inode
*old_inode
= d_inode(old_dentry
);
1099 struct inode
*new_inode
= d_inode(new_dentry
);
1100 struct udf_fileident_bh ofibh
, nfibh
;
1101 struct fileIdentDesc
*ofi
= NULL
, *nfi
= NULL
, *dir_fi
= NULL
;
1102 struct fileIdentDesc ocfi
, ncfi
;
1103 struct buffer_head
*dir_bh
= NULL
;
1104 int retval
= -ENOENT
;
1105 struct kernel_lb_addr tloc
;
1106 struct udf_inode_info
*old_iinfo
= UDF_I(old_inode
);
1108 if (flags
& ~RENAME_NOREPLACE
)
1111 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1113 retval
= PTR_ERR(ofi
);
1117 if (ofibh
.sbh
!= ofibh
.ebh
)
1121 tloc
= lelb_to_cpu(ocfi
.icb
.extLocation
);
1122 if (!ofi
|| udf_get_lb_pblock(old_dir
->i_sb
, &tloc
, 0)
1123 != old_inode
->i_ino
)
1126 nfi
= udf_find_entry(new_dir
, &new_dentry
->d_name
, &nfibh
, &ncfi
);
1128 retval
= PTR_ERR(nfi
);
1131 if (nfi
&& !new_inode
) {
1132 if (nfibh
.sbh
!= nfibh
.ebh
)
1137 if (S_ISDIR(old_inode
->i_mode
)) {
1138 int offset
= udf_ext0_offset(old_inode
);
1141 retval
= -ENOTEMPTY
;
1142 if (!empty_dir(new_inode
))
1146 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
) {
1147 dir_fi
= udf_get_fileident(
1148 old_iinfo
->i_ext
.i_data
-
1150 sizeof(struct extendedFileEntry
) :
1151 sizeof(struct fileEntry
)),
1152 old_inode
->i_sb
->s_blocksize
, &offset
);
1154 dir_bh
= udf_bread(old_inode
, 0, 0, &retval
);
1157 dir_fi
= udf_get_fileident(dir_bh
->b_data
,
1158 old_inode
->i_sb
->s_blocksize
, &offset
);
1162 tloc
= lelb_to_cpu(dir_fi
->icb
.extLocation
);
1163 if (udf_get_lb_pblock(old_inode
->i_sb
, &tloc
, 0) !=
1168 nfi
= udf_add_entry(new_dir
, new_dentry
, &nfibh
, &ncfi
,
1175 * Like most other Unix systems, set the ctime for inodes on a
1178 old_inode
->i_ctime
= current_time(old_inode
);
1179 mark_inode_dirty(old_inode
);
1184 ncfi
.fileVersionNum
= ocfi
.fileVersionNum
;
1185 ncfi
.fileCharacteristics
= ocfi
.fileCharacteristics
;
1186 memcpy(&(ncfi
.icb
), &(ocfi
.icb
), sizeof(ocfi
.icb
));
1187 udf_write_fi(new_dir
, &ncfi
, nfi
, &nfibh
, NULL
, NULL
);
1189 /* The old fid may have moved - find it again */
1190 ofi
= udf_find_entry(old_dir
, &old_dentry
->d_name
, &ofibh
, &ocfi
);
1191 udf_delete_entry(old_dir
, ofi
, &ofibh
, &ocfi
);
1194 new_inode
->i_ctime
= current_time(new_inode
);
1195 inode_dec_link_count(new_inode
);
1197 old_dir
->i_ctime
= old_dir
->i_mtime
= current_time(old_dir
);
1198 new_dir
->i_ctime
= new_dir
->i_mtime
= current_time(new_dir
);
1199 mark_inode_dirty(old_dir
);
1200 mark_inode_dirty(new_dir
);
1203 dir_fi
->icb
.extLocation
= cpu_to_lelb(UDF_I(new_dir
)->i_location
);
1204 udf_update_tag((char *)dir_fi
,
1205 (sizeof(struct fileIdentDesc
) +
1206 le16_to_cpu(dir_fi
->lengthOfImpUse
) + 3) & ~3);
1207 if (old_iinfo
->i_alloc_type
== ICBTAG_FLAG_AD_IN_ICB
)
1208 mark_inode_dirty(old_inode
);
1210 mark_buffer_dirty_inode(dir_bh
, old_inode
);
1212 inode_dec_link_count(old_dir
);
1214 inode_dec_link_count(new_inode
);
1217 mark_inode_dirty(new_dir
);
1222 if (ofibh
.sbh
!= ofibh
.ebh
)
1232 if (nfibh
.sbh
!= nfibh
.ebh
)
1240 static struct dentry
*udf_get_parent(struct dentry
*child
)
1242 struct kernel_lb_addr tloc
;
1243 struct inode
*inode
= NULL
;
1244 struct qstr dotdot
= QSTR_INIT("..", 2);
1245 struct fileIdentDesc cfi
;
1246 struct udf_fileident_bh fibh
;
1248 if (!udf_find_entry(d_inode(child
), &dotdot
, &fibh
, &cfi
))
1249 return ERR_PTR(-EACCES
);
1251 if (fibh
.sbh
!= fibh
.ebh
)
1255 tloc
= lelb_to_cpu(cfi
.icb
.extLocation
);
1256 inode
= udf_iget(child
->d_sb
, &tloc
);
1258 return ERR_CAST(inode
);
1260 return d_obtain_alias(inode
);
1264 static struct dentry
*udf_nfs_get_inode(struct super_block
*sb
, u32 block
,
1265 u16 partref
, __u32 generation
)
1267 struct inode
*inode
;
1268 struct kernel_lb_addr loc
;
1271 return ERR_PTR(-ESTALE
);
1273 loc
.logicalBlockNum
= block
;
1274 loc
.partitionReferenceNum
= partref
;
1275 inode
= udf_iget(sb
, &loc
);
1278 return ERR_CAST(inode
);
1280 if (generation
&& inode
->i_generation
!= generation
) {
1282 return ERR_PTR(-ESTALE
);
1284 return d_obtain_alias(inode
);
1287 static struct dentry
*udf_fh_to_dentry(struct super_block
*sb
,
1288 struct fid
*fid
, int fh_len
, int fh_type
)
1291 (fh_type
!= FILEID_UDF_WITH_PARENT
&&
1292 fh_type
!= FILEID_UDF_WITHOUT_PARENT
))
1295 return udf_nfs_get_inode(sb
, fid
->udf
.block
, fid
->udf
.partref
,
1296 fid
->udf
.generation
);
1299 static struct dentry
*udf_fh_to_parent(struct super_block
*sb
,
1300 struct fid
*fid
, int fh_len
, int fh_type
)
1302 if (fh_len
< 5 || fh_type
!= FILEID_UDF_WITH_PARENT
)
1305 return udf_nfs_get_inode(sb
, fid
->udf
.parent_block
,
1306 fid
->udf
.parent_partref
,
1307 fid
->udf
.parent_generation
);
1309 static int udf_encode_fh(struct inode
*inode
, __u32
*fh
, int *lenp
,
1310 struct inode
*parent
)
1313 struct kernel_lb_addr location
= UDF_I(inode
)->i_location
;
1314 struct fid
*fid
= (struct fid
*)fh
;
1315 int type
= FILEID_UDF_WITHOUT_PARENT
;
1317 if (parent
&& (len
< 5)) {
1319 return FILEID_INVALID
;
1320 } else if (len
< 3) {
1322 return FILEID_INVALID
;
1326 fid
->udf
.block
= location
.logicalBlockNum
;
1327 fid
->udf
.partref
= location
.partitionReferenceNum
;
1328 fid
->udf
.parent_partref
= 0;
1329 fid
->udf
.generation
= inode
->i_generation
;
1332 location
= UDF_I(parent
)->i_location
;
1333 fid
->udf
.parent_block
= location
.logicalBlockNum
;
1334 fid
->udf
.parent_partref
= location
.partitionReferenceNum
;
1335 fid
->udf
.parent_generation
= inode
->i_generation
;
1337 type
= FILEID_UDF_WITH_PARENT
;
1343 const struct export_operations udf_export_ops
= {
1344 .encode_fh
= udf_encode_fh
,
1345 .fh_to_dentry
= udf_fh_to_dentry
,
1346 .fh_to_parent
= udf_fh_to_parent
,
1347 .get_parent
= udf_get_parent
,
1350 const struct inode_operations udf_dir_inode_operations
= {
1351 .lookup
= udf_lookup
,
1352 .create
= udf_create
,
1354 .unlink
= udf_unlink
,
1355 .symlink
= udf_symlink
,
1359 .rename
= udf_rename
,
1360 .tmpfile
= udf_tmpfile
,