1 /* 2 * namei.c 3 * 4 * PURPOSE 5 * Inode name handling routines for the OSTA-UDF(tm) filesystem. 6 * 7 * COPYRIGHT 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. 12 * 13 * (C) 1998-2004 Ben Fennema 14 * (C) 1999-2000 Stelias Computing Inc 15 * 16 * HISTORY 17 * 18 * 12/12/98 blf Created. Split out the lookup code from dir.c 19 * 04/19/99 blf link, mknod, symlink support 20 */ 21 22 #include "udfdecl.h" 23 24 #include "udf_i.h" 25 #include "udf_sb.h" 26 #include <linux/string.h> 27 #include <linux/errno.h> 28 #include <linux/mm.h> 29 #include <linux/slab.h> 30 #include <linux/sched.h> 31 #include <linux/crc-itu-t.h> 32 #include <linux/exportfs.h> 33 34 static inline int udf_match(int len1, const unsigned char *name1, int len2, 35 const unsigned char *name2) 36 { 37 if (len1 != len2) 38 return 0; 39 40 return !memcmp(name1, name2, len1); 41 } 42 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) 46 { 47 uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(struct tag); 48 uint16_t crc; 49 int offset; 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); 54 int adinicb = 0; 55 56 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 57 adinicb = 1; 58 59 offset = fibh->soffset + sizeof(struct fileIdentDesc); 60 61 if (impuse) { 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); 66 } else { 67 memcpy((uint8_t *)sfi->impUse, impuse, -offset); 68 memcpy(fibh->ebh->b_data, impuse - offset, 69 liu + offset); 70 } 71 } 72 73 offset += liu; 74 75 if (fileident) { 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); 80 } else { 81 memcpy((uint8_t *)sfi->fileIdent + liu, fileident, 82 -offset); 83 memcpy(fibh->ebh->b_data, fileident - offset, 84 lfi + offset); 85 } 86 } 87 88 offset += lfi; 89 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); 94 } else { 95 memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset); 96 memset(fibh->ebh->b_data, 0x00, padlen + offset); 97 } 98 99 crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(struct tag), 100 sizeof(struct fileIdentDesc) - sizeof(struct tag)); 101 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) + 109 fibh->soffset, 110 crclen + sizeof(struct tag) - 111 sizeof(struct fileIdentDesc)); 112 } else { 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); 116 } 117 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); 121 122 if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) { 123 memcpy((uint8_t *)sfi, (uint8_t *)cfi, 124 sizeof(struct fileIdentDesc)); 125 } else { 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); 129 } 130 131 if (adinicb) { 132 mark_inode_dirty(inode); 133 } else { 134 if (fibh->sbh != fibh->ebh) 135 mark_buffer_dirty_inode(fibh->ebh, inode); 136 mark_buffer_dirty_inode(fibh->sbh, inode); 137 } 138 return 0; 139 } 140 141 /** 142 * udf_find_entry - find entry in given directory. 143 * 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 148 * 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. 157 * 158 * Returns pointer to FID, NULL when nothing found, or error code. 159 */ 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) 164 { 165 struct fileIdentDesc *fi = NULL; 166 loff_t f_pos; 167 udf_pblk_t block; 168 int flen; 169 unsigned char *fname = NULL, *copy_name = NULL; 170 unsigned char *nameptr; 171 uint8_t lfi; 172 uint16_t liu; 173 loff_t size; 174 struct kernel_lb_addr eloc; 175 uint32_t elen; 176 sector_t offset; 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; 182 183 size = udf_ext0_offset(dir) + dir->i_size; 184 f_pos = udf_ext0_offset(dir); 185 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)) { 191 fi = ERR_PTR(-EIO); 192 goto out_err; 193 } 194 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); 201 } else 202 offset = 0; 203 204 fibh->sbh = fibh->ebh = udf_tread(sb, block); 205 if (!fibh->sbh) { 206 fi = ERR_PTR(-EIO); 207 goto out_err; 208 } 209 } 210 211 fname = kmalloc(UDF_NAME_LEN, GFP_NOFS); 212 if (!fname) { 213 fi = ERR_PTR(-ENOMEM); 214 goto out_err; 215 } 216 217 while (f_pos < size) { 218 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, 219 &elen, &offset); 220 if (!fi) { 221 fi = ERR_PTR(-EIO); 222 goto out_err; 223 } 224 225 liu = le16_to_cpu(cfi->lengthOfImpUse); 226 lfi = cfi->lengthFileIdent; 227 228 if (fibh->sbh == fibh->ebh) { 229 nameptr = fi->fileIdent + liu; 230 } else { 231 int poffset; /* Unpaded ending offset */ 232 233 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + 234 liu + lfi; 235 236 if (poffset >= lfi) 237 nameptr = (uint8_t *)(fibh->ebh->b_data + 238 poffset - lfi); 239 else { 240 if (!copy_name) { 241 copy_name = kmalloc(UDF_NAME_LEN, 242 GFP_NOFS); 243 if (!copy_name) { 244 fi = ERR_PTR(-ENOMEM); 245 goto out_err; 246 } 247 } 248 nameptr = copy_name; 249 memcpy(nameptr, fi->fileIdent + liu, 250 lfi - poffset); 251 memcpy(nameptr + lfi - poffset, 252 fibh->ebh->b_data, poffset); 253 } 254 } 255 256 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { 257 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE)) 258 continue; 259 } 260 261 if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) { 262 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE)) 263 continue; 264 } 265 266 if ((cfi->fileCharacteristics & FID_FILE_CHAR_PARENT) && 267 isdotdot) 268 goto out_ok; 269 270 if (!lfi) 271 continue; 272 273 flen = udf_get_filename(sb, nameptr, lfi, fname, UDF_NAME_LEN); 274 if (flen < 0) { 275 fi = ERR_PTR(flen); 276 goto out_err; 277 } 278 279 if (udf_match(flen, fname, child->len, child->name)) 280 goto out_ok; 281 } 282 283 fi = NULL; 284 out_err: 285 if (fibh->sbh != fibh->ebh) 286 brelse(fibh->ebh); 287 brelse(fibh->sbh); 288 out_ok: 289 brelse(epos.bh); 290 kfree(fname); 291 kfree(copy_name); 292 293 return fi; 294 } 295 296 static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, 297 unsigned int flags) 298 { 299 struct inode *inode = NULL; 300 struct fileIdentDesc cfi; 301 struct udf_fileident_bh fibh; 302 struct fileIdentDesc *fi; 303 304 if (dentry->d_name.len > UDF_NAME_LEN) 305 return ERR_PTR(-ENAMETOOLONG); 306 307 #ifdef UDF_RECOVERY 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, 314 NULL, 0), 315 }; 316 inode = udf_iget(dir->i_sb, lb); 317 if (IS_ERR(inode)) 318 return inode; 319 } else 320 #endif /* UDF_RECOVERY */ 321 322 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 323 if (IS_ERR(fi)) 324 return ERR_CAST(fi); 325 326 if (fi) { 327 struct kernel_lb_addr loc; 328 329 if (fibh.sbh != fibh.ebh) 330 brelse(fibh.ebh); 331 brelse(fibh.sbh); 332 333 loc = lelb_to_cpu(cfi.icb.extLocation); 334 inode = udf_iget(dir->i_sb, &loc); 335 if (IS_ERR(inode)) 336 return ERR_CAST(inode); 337 } 338 339 return d_splice_alias(inode, dentry); 340 } 341 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) 346 { 347 struct super_block *sb = dir->i_sb; 348 struct fileIdentDesc *fi = NULL; 349 unsigned char *name = NULL; 350 int namelen; 351 loff_t f_pos; 352 loff_t size = udf_ext0_offset(dir) + dir->i_size; 353 int nfidlen; 354 uint8_t lfi; 355 uint16_t liu; 356 udf_pblk_t block; 357 struct kernel_lb_addr eloc; 358 uint32_t elen = 0; 359 sector_t offset; 360 struct extent_position epos = {}; 361 struct udf_inode_info *dinfo; 362 363 fibh->sbh = fibh->ebh = NULL; 364 name = kmalloc(UDF_NAME_LEN_CS0, GFP_NOFS); 365 if (!name) { 366 *err = -ENOMEM; 367 goto out_err; 368 } 369 370 if (dentry) { 371 if (!dentry->d_name.len) { 372 *err = -EINVAL; 373 goto out_err; 374 } 375 namelen = udf_put_filename(sb, dentry->d_name.name, 376 dentry->d_name.len, 377 name, UDF_NAME_LEN_CS0); 378 if (!namelen) { 379 *err = -ENAMETOOLONG; 380 goto out_err; 381 } 382 } else { 383 namelen = 0; 384 } 385 386 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3; 387 388 f_pos = udf_ext0_offset(dir); 389 390 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 391 dinfo = UDF_I(dir); 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; 398 goto add; 399 } 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); 406 } else 407 offset = 0; 408 409 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); 410 if (!fibh->sbh) { 411 *err = -EIO; 412 goto out_err; 413 } 414 415 block = dinfo->i_location.logicalBlockNum; 416 } 417 418 while (f_pos < size) { 419 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, 420 &elen, &offset); 421 422 if (!fi) { 423 *err = -EIO; 424 goto out_err; 425 } 426 427 liu = le16_to_cpu(cfi->lengthOfImpUse); 428 lfi = cfi->lengthFileIdent; 429 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, 439 name)) 440 goto out_ok; 441 else { 442 *err = -EIO; 443 goto out_err; 444 } 445 } 446 } 447 } 448 449 add: 450 f_pos += nfidlen; 451 452 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB && 453 sb->s_blocksize - fibh->eoffset < nfidlen) { 454 brelse(epos.bh); 455 epos.bh = NULL; 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) 460 brelse(fibh->ebh); 461 brelse(fibh->sbh); 462 fibh->sbh = fibh->ebh = 463 udf_expand_dir_adinicb(dir, &block, err); 464 if (!fibh->sbh) 465 goto out_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); 470 } 471 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) { 477 brelse(fibh->sbh); 478 fibh->sbh = fibh->ebh; 479 } 480 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 + 485 fibh->soffset - 486 udf_ext0_offset(dir) + 487 dinfo->i_lenEAttr); 488 } else { 489 block = eloc.logicalBlockNum + 490 ((elen - 1) >> 491 dir->i_sb->s_blocksize_bits); 492 fi = (struct fileIdentDesc *) 493 (fibh->sbh->b_data + fibh->soffset); 494 } 495 } else { 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); 505 506 fibh->soffset = fibh->eoffset - sb->s_blocksize; 507 fibh->eoffset += nfidlen - sb->s_blocksize; 508 if (fibh->sbh != fibh->ebh) { 509 brelse(fibh->sbh); 510 fibh->sbh = fibh->ebh; 511 } 512 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); 517 if (!fibh->ebh) 518 goto out_err; 519 /* Extents could have been merged, invalidate our position */ 520 brelse(epos.bh); 521 epos.bh = NULL; 522 epos.block = dinfo->i_location; 523 epos.offset = udf_file_entry_alloc_offset(dir); 524 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)) 529 ; 530 block = eloc.logicalBlockNum + ((elen - 1) >> 531 dir->i_sb->s_blocksize_bits); 532 brelse(fibh->sbh); 533 fibh->sbh = fibh->ebh; 534 fi = (struct fileIdentDesc *)(fibh->sbh->b_data); 535 } else { 536 fi = (struct fileIdentDesc *) 537 (fibh->sbh->b_data + sb->s_blocksize + 538 fibh->soffset); 539 } 540 } 541 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, 545 sizeof(struct tag)); 546 else 547 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, 548 sizeof(struct tag)); 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; 556 else { 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)) 560 ; 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; 568 } 569 570 mark_inode_dirty(dir); 571 goto out_ok; 572 } else { 573 *err = -EIO; 574 goto out_err; 575 } 576 577 out_err: 578 fi = NULL; 579 if (fibh->sbh != fibh->ebh) 580 brelse(fibh->ebh); 581 brelse(fibh->sbh); 582 out_ok: 583 brelse(epos.bh); 584 kfree(name); 585 return fi; 586 } 587 588 static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, 589 struct udf_fileident_bh *fibh, 590 struct fileIdentDesc *cfi) 591 { 592 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; 593 594 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 595 memset(&(cfi->icb), 0x00, sizeof(struct long_ad)); 596 597 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); 598 } 599 600 static int udf_add_nondir(struct dentry *dentry, struct inode *inode) 601 { 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; 606 int err; 607 608 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 609 if (unlikely(!fi)) { 610 inode_dec_link_count(inode); 611 unlock_new_inode(inode); 612 iput(inode); 613 return err; 614 } 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) 623 brelse(fibh.ebh); 624 brelse(fibh.sbh); 625 d_instantiate_new(dentry, inode); 626 627 return 0; 628 } 629 630 static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode, 631 bool excl) 632 { 633 struct inode *inode = udf_new_inode(dir, mode); 634 635 if (IS_ERR(inode)) 636 return PTR_ERR(inode); 637 638 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 639 inode->i_data.a_ops = &udf_adinicb_aops; 640 else 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); 645 646 return udf_add_nondir(dentry, inode); 647 } 648 649 static int udf_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 650 { 651 struct inode *inode = udf_new_inode(dir, mode); 652 653 if (IS_ERR(inode)) 654 return PTR_ERR(inode); 655 656 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 657 inode->i_data.a_ops = &udf_adinicb_aops; 658 else 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); 665 return 0; 666 } 667 668 static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, 669 dev_t rdev) 670 { 671 struct inode *inode; 672 673 if (!old_valid_dev(rdev)) 674 return -EINVAL; 675 676 inode = udf_new_inode(dir, mode); 677 if (IS_ERR(inode)) 678 return PTR_ERR(inode); 679 680 init_special_inode(inode, mode, rdev); 681 return udf_add_nondir(dentry, inode); 682 } 683 684 static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 685 { 686 struct inode *inode; 687 struct udf_fileident_bh fibh; 688 struct fileIdentDesc cfi, *fi; 689 int err; 690 struct udf_inode_info *dinfo = UDF_I(dir); 691 struct udf_inode_info *iinfo; 692 693 inode = udf_new_inode(dir, S_IFDIR | mode); 694 if (IS_ERR(inode)) 695 return PTR_ERR(inode); 696 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); 701 if (!fi) { 702 inode_dec_link_count(inode); 703 unlock_new_inode(inode); 704 iput(inode); 705 goto out; 706 } 707 set_nlink(inode, 2); 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); 715 brelse(fibh.sbh); 716 mark_inode_dirty(inode); 717 718 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 719 if (!fi) { 720 clear_nlink(inode); 721 mark_inode_dirty(inode); 722 unlock_new_inode(inode); 723 iput(inode); 724 goto out; 725 } 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); 732 inc_nlink(dir); 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) 737 brelse(fibh.ebh); 738 brelse(fibh.sbh); 739 err = 0; 740 741 out: 742 return err; 743 } 744 745 static int empty_dir(struct inode *dir) 746 { 747 struct fileIdentDesc *fi, cfi; 748 struct udf_fileident_bh fibh; 749 loff_t f_pos; 750 loff_t size = udf_ext0_offset(dir) + dir->i_size; 751 udf_pblk_t block; 752 struct kernel_lb_addr eloc; 753 uint32_t elen; 754 sector_t offset; 755 struct extent_position epos = {}; 756 struct udf_inode_info *dinfo = UDF_I(dir); 757 758 f_pos = udf_ext0_offset(dir); 759 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 760 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); 772 } else 773 offset = 0; 774 775 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); 776 if (!fibh.sbh) { 777 brelse(epos.bh); 778 return 0; 779 } 780 } else { 781 brelse(epos.bh); 782 return 0; 783 } 784 785 while (f_pos < size) { 786 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, 787 &elen, &offset); 788 if (!fi) { 789 if (fibh.sbh != fibh.ebh) 790 brelse(fibh.ebh); 791 brelse(fibh.sbh); 792 brelse(epos.bh); 793 return 0; 794 } 795 796 if (cfi.lengthFileIdent && 797 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) { 798 if (fibh.sbh != fibh.ebh) 799 brelse(fibh.ebh); 800 brelse(fibh.sbh); 801 brelse(epos.bh); 802 return 0; 803 } 804 } 805 806 if (fibh.sbh != fibh.ebh) 807 brelse(fibh.ebh); 808 brelse(fibh.sbh); 809 brelse(epos.bh); 810 811 return 1; 812 } 813 814 static int udf_rmdir(struct inode *dir, struct dentry *dentry) 815 { 816 int retval; 817 struct inode *inode = d_inode(dentry); 818 struct udf_fileident_bh fibh; 819 struct fileIdentDesc *fi, cfi; 820 struct kernel_lb_addr tloc; 821 822 retval = -ENOENT; 823 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 824 if (IS_ERR_OR_NULL(fi)) { 825 if (fi) 826 retval = PTR_ERR(fi); 827 goto out; 828 } 829 830 retval = -EIO; 831 tloc = lelb_to_cpu(cfi.icb.extLocation); 832 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 833 goto end_rmdir; 834 retval = -ENOTEMPTY; 835 if (!empty_dir(inode)) 836 goto end_rmdir; 837 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 838 if (retval) 839 goto end_rmdir; 840 if (inode->i_nlink != 2) 841 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%u)\n", 842 inode->i_nlink); 843 clear_nlink(inode); 844 inode->i_size = 0; 845 inode_dec_link_count(dir); 846 inode->i_ctime = dir->i_ctime = dir->i_mtime = 847 current_time(inode); 848 mark_inode_dirty(dir); 849 850 end_rmdir: 851 if (fibh.sbh != fibh.ebh) 852 brelse(fibh.ebh); 853 brelse(fibh.sbh); 854 855 out: 856 return retval; 857 } 858 859 static int udf_unlink(struct inode *dir, struct dentry *dentry) 860 { 861 int retval; 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; 867 868 retval = -ENOENT; 869 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 870 871 if (IS_ERR_OR_NULL(fi)) { 872 if (fi) 873 retval = PTR_ERR(fi); 874 goto out; 875 } 876 877 retval = -EIO; 878 tloc = lelb_to_cpu(cfi.icb.extLocation); 879 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 880 goto end_unlink; 881 882 if (!inode->i_nlink) { 883 udf_debug("Deleting nonexistent file (%lu), %u\n", 884 inode->i_ino, inode->i_nlink); 885 set_nlink(inode, 1); 886 } 887 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 888 if (retval) 889 goto end_unlink; 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; 894 retval = 0; 895 896 end_unlink: 897 if (fibh.sbh != fibh.ebh) 898 brelse(fibh.ebh); 899 brelse(fibh.sbh); 900 901 out: 902 return retval; 903 } 904 905 static int udf_symlink(struct inode *dir, struct dentry *dentry, 906 const char *symname) 907 { 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; 913 uint8_t *ea; 914 int err; 915 udf_pblk_t block; 916 unsigned char *name = NULL; 917 int namelen; 918 struct udf_inode_info *iinfo; 919 struct super_block *sb = dir->i_sb; 920 921 if (IS_ERR(inode)) 922 return PTR_ERR(inode); 923 924 iinfo = UDF_I(inode); 925 down_write(&iinfo->i_data_sem); 926 name = kmalloc(UDF_NAME_LEN_CS0, GFP_NOFS); 927 if (!name) { 928 err = -ENOMEM; 929 goto out_no_entry; 930 } 931 932 inode->i_data.a_ops = &udf_symlink_aops; 933 inode->i_op = &udf_symlink_inode_operations; 934 inode_nohighmem(inode); 935 936 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 937 struct kernel_lb_addr eloc; 938 uint32_t bsize; 939 940 block = udf_new_block(sb, inode, 941 iinfo->i_location.partitionReferenceNum, 942 iinfo->i_location.logicalBlockNum, &err); 943 if (!block) 944 goto out_no_entry; 945 epos.block = iinfo->i_location; 946 epos.offset = udf_file_entry_alloc_offset(inode); 947 epos.bh = NULL; 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); 954 brelse(epos.bh); 955 956 block = udf_get_pblock(sb, block, 957 iinfo->i_location.partitionReferenceNum, 958 0); 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); 966 } else 967 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr; 968 969 eoffset = sb->s_blocksize - udf_ext0_offset(inode); 970 pc = (struct pathComponent *)ea; 971 972 if (*symname == '/') { 973 do { 974 symname++; 975 } while (*symname == '/'); 976 977 pc->componentType = 1; 978 pc->lengthComponentIdent = 0; 979 pc->componentFileVersionNum = 0; 980 elen += sizeof(struct pathComponent); 981 } 982 983 err = -ENAMETOOLONG; 984 985 while (*symname) { 986 if (elen + sizeof(struct pathComponent) > eoffset) 987 goto out_no_entry; 988 989 pc = (struct pathComponent *)(ea + elen); 990 991 compstart = symname; 992 993 do { 994 symname++; 995 } while (*symname && *symname != '/'); 996 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; 1006 } 1007 1008 if (pc->componentType == 5) { 1009 namelen = udf_put_filename(sb, compstart, 1010 symname - compstart, 1011 name, UDF_NAME_LEN_CS0); 1012 if (!namelen) 1013 goto out_no_entry; 1014 1015 if (elen + sizeof(struct pathComponent) + namelen > 1016 eoffset) 1017 goto out_no_entry; 1018 else 1019 pc->lengthComponentIdent = namelen; 1020 1021 memcpy(pc->componentIdent, name, namelen); 1022 } 1023 1024 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; 1025 1026 if (*symname) { 1027 do { 1028 symname++; 1029 } while (*symname == '/'); 1030 } 1031 } 1032 1033 brelse(epos.bh); 1034 inode->i_size = elen; 1035 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1036 iinfo->i_lenAlloc = inode->i_size; 1037 else 1038 udf_truncate_tail_extent(inode); 1039 mark_inode_dirty(inode); 1040 up_write(&iinfo->i_data_sem); 1041 1042 err = udf_add_nondir(dentry, inode); 1043 out: 1044 kfree(name); 1045 return err; 1046 1047 out_no_entry: 1048 up_write(&iinfo->i_data_sem); 1049 inode_dec_link_count(inode); 1050 unlock_new_inode(inode); 1051 iput(inode); 1052 goto out; 1053 } 1054 1055 static int udf_link(struct dentry *old_dentry, struct inode *dir, 1056 struct dentry *dentry) 1057 { 1058 struct inode *inode = d_inode(old_dentry); 1059 struct udf_fileident_bh fibh; 1060 struct fileIdentDesc cfi, *fi; 1061 int err; 1062 1063 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 1064 if (!fi) { 1065 return err; 1066 } 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)); 1072 } 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); 1076 1077 if (fibh.sbh != fibh.ebh) 1078 brelse(fibh.ebh); 1079 brelse(fibh.sbh); 1080 inc_nlink(inode); 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); 1085 ihold(inode); 1086 d_instantiate(dentry, inode); 1087 1088 return 0; 1089 } 1090 1091 /* Anybody can rename anything with this: the permission checks are left to the 1092 * higher-level routines. 1093 */ 1094 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, 1095 struct inode *new_dir, struct dentry *new_dentry, 1096 unsigned int flags) 1097 { 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); 1107 1108 if (flags & ~RENAME_NOREPLACE) 1109 return -EINVAL; 1110 1111 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1112 if (IS_ERR(ofi)) { 1113 retval = PTR_ERR(ofi); 1114 goto end_rename; 1115 } 1116 1117 if (ofibh.sbh != ofibh.ebh) 1118 brelse(ofibh.ebh); 1119 1120 brelse(ofibh.sbh); 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) 1124 goto end_rename; 1125 1126 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi); 1127 if (IS_ERR(nfi)) { 1128 retval = PTR_ERR(nfi); 1129 goto end_rename; 1130 } 1131 if (nfi && !new_inode) { 1132 if (nfibh.sbh != nfibh.ebh) 1133 brelse(nfibh.ebh); 1134 brelse(nfibh.sbh); 1135 nfi = NULL; 1136 } 1137 if (S_ISDIR(old_inode->i_mode)) { 1138 int offset = udf_ext0_offset(old_inode); 1139 1140 if (new_inode) { 1141 retval = -ENOTEMPTY; 1142 if (!empty_dir(new_inode)) 1143 goto end_rename; 1144 } 1145 retval = -EIO; 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 - 1149 (old_iinfo->i_efe ? 1150 sizeof(struct extendedFileEntry) : 1151 sizeof(struct fileEntry)), 1152 old_inode->i_sb->s_blocksize, &offset); 1153 } else { 1154 dir_bh = udf_bread(old_inode, 0, 0, &retval); 1155 if (!dir_bh) 1156 goto end_rename; 1157 dir_fi = udf_get_fileident(dir_bh->b_data, 1158 old_inode->i_sb->s_blocksize, &offset); 1159 } 1160 if (!dir_fi) 1161 goto end_rename; 1162 tloc = lelb_to_cpu(dir_fi->icb.extLocation); 1163 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) != 1164 old_dir->i_ino) 1165 goto end_rename; 1166 } 1167 if (!nfi) { 1168 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, 1169 &retval); 1170 if (!nfi) 1171 goto end_rename; 1172 } 1173 1174 /* 1175 * Like most other Unix systems, set the ctime for inodes on a 1176 * rename. 1177 */ 1178 old_inode->i_ctime = current_time(old_inode); 1179 mark_inode_dirty(old_inode); 1180 1181 /* 1182 * ok, that's it 1183 */ 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); 1188 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); 1192 1193 if (new_inode) { 1194 new_inode->i_ctime = current_time(new_inode); 1195 inode_dec_link_count(new_inode); 1196 } 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); 1201 1202 if (dir_fi) { 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); 1209 else 1210 mark_buffer_dirty_inode(dir_bh, old_inode); 1211 1212 inode_dec_link_count(old_dir); 1213 if (new_inode) 1214 inode_dec_link_count(new_inode); 1215 else { 1216 inc_nlink(new_dir); 1217 mark_inode_dirty(new_dir); 1218 } 1219 } 1220 1221 if (ofi) { 1222 if (ofibh.sbh != ofibh.ebh) 1223 brelse(ofibh.ebh); 1224 brelse(ofibh.sbh); 1225 } 1226 1227 retval = 0; 1228 1229 end_rename: 1230 brelse(dir_bh); 1231 if (nfi) { 1232 if (nfibh.sbh != nfibh.ebh) 1233 brelse(nfibh.ebh); 1234 brelse(nfibh.sbh); 1235 } 1236 1237 return retval; 1238 } 1239 1240 static struct dentry *udf_get_parent(struct dentry *child) 1241 { 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; 1247 1248 if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi)) 1249 return ERR_PTR(-EACCES); 1250 1251 if (fibh.sbh != fibh.ebh) 1252 brelse(fibh.ebh); 1253 brelse(fibh.sbh); 1254 1255 tloc = lelb_to_cpu(cfi.icb.extLocation); 1256 inode = udf_iget(child->d_sb, &tloc); 1257 if (IS_ERR(inode)) 1258 return ERR_CAST(inode); 1259 1260 return d_obtain_alias(inode); 1261 } 1262 1263 1264 static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block, 1265 u16 partref, __u32 generation) 1266 { 1267 struct inode *inode; 1268 struct kernel_lb_addr loc; 1269 1270 if (block == 0) 1271 return ERR_PTR(-ESTALE); 1272 1273 loc.logicalBlockNum = block; 1274 loc.partitionReferenceNum = partref; 1275 inode = udf_iget(sb, &loc); 1276 1277 if (IS_ERR(inode)) 1278 return ERR_CAST(inode); 1279 1280 if (generation && inode->i_generation != generation) { 1281 iput(inode); 1282 return ERR_PTR(-ESTALE); 1283 } 1284 return d_obtain_alias(inode); 1285 } 1286 1287 static struct dentry *udf_fh_to_dentry(struct super_block *sb, 1288 struct fid *fid, int fh_len, int fh_type) 1289 { 1290 if (fh_len < 3 || 1291 (fh_type != FILEID_UDF_WITH_PARENT && 1292 fh_type != FILEID_UDF_WITHOUT_PARENT)) 1293 return NULL; 1294 1295 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref, 1296 fid->udf.generation); 1297 } 1298 1299 static struct dentry *udf_fh_to_parent(struct super_block *sb, 1300 struct fid *fid, int fh_len, int fh_type) 1301 { 1302 if (fh_len < 5 || fh_type != FILEID_UDF_WITH_PARENT) 1303 return NULL; 1304 1305 return udf_nfs_get_inode(sb, fid->udf.parent_block, 1306 fid->udf.parent_partref, 1307 fid->udf.parent_generation); 1308 } 1309 static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp, 1310 struct inode *parent) 1311 { 1312 int len = *lenp; 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; 1316 1317 if (parent && (len < 5)) { 1318 *lenp = 5; 1319 return FILEID_INVALID; 1320 } else if (len < 3) { 1321 *lenp = 3; 1322 return FILEID_INVALID; 1323 } 1324 1325 *lenp = 3; 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; 1330 1331 if (parent) { 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; 1336 *lenp = 5; 1337 type = FILEID_UDF_WITH_PARENT; 1338 } 1339 1340 return type; 1341 } 1342 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, 1348 }; 1349 1350 const struct inode_operations udf_dir_inode_operations = { 1351 .lookup = udf_lookup, 1352 .create = udf_create, 1353 .link = udf_link, 1354 .unlink = udf_unlink, 1355 .symlink = udf_symlink, 1356 .mkdir = udf_mkdir, 1357 .rmdir = udf_rmdir, 1358 .mknod = udf_mknod, 1359 .rename = udf_rename, 1360 .tmpfile = udf_tmpfile, 1361 }; 1362