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 unlock_new_inode(inode); 626 d_instantiate(dentry, inode); 627 628 return 0; 629 } 630 631 static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode, 632 bool excl) 633 { 634 struct inode *inode = udf_new_inode(dir, mode); 635 636 if (IS_ERR(inode)) 637 return PTR_ERR(inode); 638 639 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 640 inode->i_data.a_ops = &udf_adinicb_aops; 641 else 642 inode->i_data.a_ops = &udf_aops; 643 inode->i_op = &udf_file_inode_operations; 644 inode->i_fop = &udf_file_operations; 645 mark_inode_dirty(inode); 646 647 return udf_add_nondir(dentry, inode); 648 } 649 650 static int udf_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 651 { 652 struct inode *inode = udf_new_inode(dir, mode); 653 654 if (IS_ERR(inode)) 655 return PTR_ERR(inode); 656 657 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 658 inode->i_data.a_ops = &udf_adinicb_aops; 659 else 660 inode->i_data.a_ops = &udf_aops; 661 inode->i_op = &udf_file_inode_operations; 662 inode->i_fop = &udf_file_operations; 663 mark_inode_dirty(inode); 664 d_tmpfile(dentry, inode); 665 unlock_new_inode(inode); 666 return 0; 667 } 668 669 static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, 670 dev_t rdev) 671 { 672 struct inode *inode; 673 674 if (!old_valid_dev(rdev)) 675 return -EINVAL; 676 677 inode = udf_new_inode(dir, mode); 678 if (IS_ERR(inode)) 679 return PTR_ERR(inode); 680 681 init_special_inode(inode, mode, rdev); 682 return udf_add_nondir(dentry, inode); 683 } 684 685 static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 686 { 687 struct inode *inode; 688 struct udf_fileident_bh fibh; 689 struct fileIdentDesc cfi, *fi; 690 int err; 691 struct udf_inode_info *dinfo = UDF_I(dir); 692 struct udf_inode_info *iinfo; 693 694 inode = udf_new_inode(dir, S_IFDIR | mode); 695 if (IS_ERR(inode)) 696 return PTR_ERR(inode); 697 698 iinfo = UDF_I(inode); 699 inode->i_op = &udf_dir_inode_operations; 700 inode->i_fop = &udf_dir_operations; 701 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err); 702 if (!fi) { 703 inode_dec_link_count(inode); 704 unlock_new_inode(inode); 705 iput(inode); 706 goto out; 707 } 708 set_nlink(inode, 2); 709 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 710 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location); 711 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 712 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL); 713 cfi.fileCharacteristics = 714 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; 715 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); 716 brelse(fibh.sbh); 717 mark_inode_dirty(inode); 718 719 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 720 if (!fi) { 721 clear_nlink(inode); 722 mark_inode_dirty(inode); 723 unlock_new_inode(inode); 724 iput(inode); 725 goto out; 726 } 727 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 728 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 729 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 730 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 731 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; 732 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 733 inc_nlink(dir); 734 dir->i_ctime = dir->i_mtime = current_time(dir); 735 mark_inode_dirty(dir); 736 unlock_new_inode(inode); 737 d_instantiate(dentry, inode); 738 if (fibh.sbh != fibh.ebh) 739 brelse(fibh.ebh); 740 brelse(fibh.sbh); 741 err = 0; 742 743 out: 744 return err; 745 } 746 747 static int empty_dir(struct inode *dir) 748 { 749 struct fileIdentDesc *fi, cfi; 750 struct udf_fileident_bh fibh; 751 loff_t f_pos; 752 loff_t size = udf_ext0_offset(dir) + dir->i_size; 753 udf_pblk_t block; 754 struct kernel_lb_addr eloc; 755 uint32_t elen; 756 sector_t offset; 757 struct extent_position epos = {}; 758 struct udf_inode_info *dinfo = UDF_I(dir); 759 760 f_pos = udf_ext0_offset(dir); 761 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 762 763 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 764 fibh.sbh = fibh.ebh = NULL; 765 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, 766 &epos, &eloc, &elen, &offset) == 767 (EXT_RECORDED_ALLOCATED >> 30)) { 768 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); 769 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 770 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 771 epos.offset -= sizeof(struct short_ad); 772 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 773 epos.offset -= sizeof(struct long_ad); 774 } else 775 offset = 0; 776 777 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); 778 if (!fibh.sbh) { 779 brelse(epos.bh); 780 return 0; 781 } 782 } else { 783 brelse(epos.bh); 784 return 0; 785 } 786 787 while (f_pos < size) { 788 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, 789 &elen, &offset); 790 if (!fi) { 791 if (fibh.sbh != fibh.ebh) 792 brelse(fibh.ebh); 793 brelse(fibh.sbh); 794 brelse(epos.bh); 795 return 0; 796 } 797 798 if (cfi.lengthFileIdent && 799 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) { 800 if (fibh.sbh != fibh.ebh) 801 brelse(fibh.ebh); 802 brelse(fibh.sbh); 803 brelse(epos.bh); 804 return 0; 805 } 806 } 807 808 if (fibh.sbh != fibh.ebh) 809 brelse(fibh.ebh); 810 brelse(fibh.sbh); 811 brelse(epos.bh); 812 813 return 1; 814 } 815 816 static int udf_rmdir(struct inode *dir, struct dentry *dentry) 817 { 818 int retval; 819 struct inode *inode = d_inode(dentry); 820 struct udf_fileident_bh fibh; 821 struct fileIdentDesc *fi, cfi; 822 struct kernel_lb_addr tloc; 823 824 retval = -ENOENT; 825 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 826 if (IS_ERR_OR_NULL(fi)) { 827 if (fi) 828 retval = PTR_ERR(fi); 829 goto out; 830 } 831 832 retval = -EIO; 833 tloc = lelb_to_cpu(cfi.icb.extLocation); 834 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 835 goto end_rmdir; 836 retval = -ENOTEMPTY; 837 if (!empty_dir(inode)) 838 goto end_rmdir; 839 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 840 if (retval) 841 goto end_rmdir; 842 if (inode->i_nlink != 2) 843 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%u)\n", 844 inode->i_nlink); 845 clear_nlink(inode); 846 inode->i_size = 0; 847 inode_dec_link_count(dir); 848 inode->i_ctime = dir->i_ctime = dir->i_mtime = 849 current_time(inode); 850 mark_inode_dirty(dir); 851 852 end_rmdir: 853 if (fibh.sbh != fibh.ebh) 854 brelse(fibh.ebh); 855 brelse(fibh.sbh); 856 857 out: 858 return retval; 859 } 860 861 static int udf_unlink(struct inode *dir, struct dentry *dentry) 862 { 863 int retval; 864 struct inode *inode = d_inode(dentry); 865 struct udf_fileident_bh fibh; 866 struct fileIdentDesc *fi; 867 struct fileIdentDesc cfi; 868 struct kernel_lb_addr tloc; 869 870 retval = -ENOENT; 871 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 872 873 if (IS_ERR_OR_NULL(fi)) { 874 if (fi) 875 retval = PTR_ERR(fi); 876 goto out; 877 } 878 879 retval = -EIO; 880 tloc = lelb_to_cpu(cfi.icb.extLocation); 881 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 882 goto end_unlink; 883 884 if (!inode->i_nlink) { 885 udf_debug("Deleting nonexistent file (%lu), %u\n", 886 inode->i_ino, inode->i_nlink); 887 set_nlink(inode, 1); 888 } 889 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 890 if (retval) 891 goto end_unlink; 892 dir->i_ctime = dir->i_mtime = current_time(dir); 893 mark_inode_dirty(dir); 894 inode_dec_link_count(inode); 895 inode->i_ctime = dir->i_ctime; 896 retval = 0; 897 898 end_unlink: 899 if (fibh.sbh != fibh.ebh) 900 brelse(fibh.ebh); 901 brelse(fibh.sbh); 902 903 out: 904 return retval; 905 } 906 907 static int udf_symlink(struct inode *dir, struct dentry *dentry, 908 const char *symname) 909 { 910 struct inode *inode = udf_new_inode(dir, S_IFLNK | 0777); 911 struct pathComponent *pc; 912 const char *compstart; 913 struct extent_position epos = {}; 914 int eoffset, elen = 0; 915 uint8_t *ea; 916 int err; 917 udf_pblk_t block; 918 unsigned char *name = NULL; 919 int namelen; 920 struct udf_inode_info *iinfo; 921 struct super_block *sb = dir->i_sb; 922 923 if (IS_ERR(inode)) 924 return PTR_ERR(inode); 925 926 iinfo = UDF_I(inode); 927 down_write(&iinfo->i_data_sem); 928 name = kmalloc(UDF_NAME_LEN_CS0, GFP_NOFS); 929 if (!name) { 930 err = -ENOMEM; 931 goto out_no_entry; 932 } 933 934 inode->i_data.a_ops = &udf_symlink_aops; 935 inode->i_op = &udf_symlink_inode_operations; 936 inode_nohighmem(inode); 937 938 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 939 struct kernel_lb_addr eloc; 940 uint32_t bsize; 941 942 block = udf_new_block(sb, inode, 943 iinfo->i_location.partitionReferenceNum, 944 iinfo->i_location.logicalBlockNum, &err); 945 if (!block) 946 goto out_no_entry; 947 epos.block = iinfo->i_location; 948 epos.offset = udf_file_entry_alloc_offset(inode); 949 epos.bh = NULL; 950 eloc.logicalBlockNum = block; 951 eloc.partitionReferenceNum = 952 iinfo->i_location.partitionReferenceNum; 953 bsize = sb->s_blocksize; 954 iinfo->i_lenExtents = bsize; 955 udf_add_aext(inode, &epos, &eloc, bsize, 0); 956 brelse(epos.bh); 957 958 block = udf_get_pblock(sb, block, 959 iinfo->i_location.partitionReferenceNum, 960 0); 961 epos.bh = udf_tgetblk(sb, block); 962 lock_buffer(epos.bh); 963 memset(epos.bh->b_data, 0x00, bsize); 964 set_buffer_uptodate(epos.bh); 965 unlock_buffer(epos.bh); 966 mark_buffer_dirty_inode(epos.bh, inode); 967 ea = epos.bh->b_data + udf_ext0_offset(inode); 968 } else 969 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr; 970 971 eoffset = sb->s_blocksize - udf_ext0_offset(inode); 972 pc = (struct pathComponent *)ea; 973 974 if (*symname == '/') { 975 do { 976 symname++; 977 } while (*symname == '/'); 978 979 pc->componentType = 1; 980 pc->lengthComponentIdent = 0; 981 pc->componentFileVersionNum = 0; 982 elen += sizeof(struct pathComponent); 983 } 984 985 err = -ENAMETOOLONG; 986 987 while (*symname) { 988 if (elen + sizeof(struct pathComponent) > eoffset) 989 goto out_no_entry; 990 991 pc = (struct pathComponent *)(ea + elen); 992 993 compstart = symname; 994 995 do { 996 symname++; 997 } while (*symname && *symname != '/'); 998 999 pc->componentType = 5; 1000 pc->lengthComponentIdent = 0; 1001 pc->componentFileVersionNum = 0; 1002 if (compstart[0] == '.') { 1003 if ((symname - compstart) == 1) 1004 pc->componentType = 4; 1005 else if ((symname - compstart) == 2 && 1006 compstart[1] == '.') 1007 pc->componentType = 3; 1008 } 1009 1010 if (pc->componentType == 5) { 1011 namelen = udf_put_filename(sb, compstart, 1012 symname - compstart, 1013 name, UDF_NAME_LEN_CS0); 1014 if (!namelen) 1015 goto out_no_entry; 1016 1017 if (elen + sizeof(struct pathComponent) + namelen > 1018 eoffset) 1019 goto out_no_entry; 1020 else 1021 pc->lengthComponentIdent = namelen; 1022 1023 memcpy(pc->componentIdent, name, namelen); 1024 } 1025 1026 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; 1027 1028 if (*symname) { 1029 do { 1030 symname++; 1031 } while (*symname == '/'); 1032 } 1033 } 1034 1035 brelse(epos.bh); 1036 inode->i_size = elen; 1037 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1038 iinfo->i_lenAlloc = inode->i_size; 1039 else 1040 udf_truncate_tail_extent(inode); 1041 mark_inode_dirty(inode); 1042 up_write(&iinfo->i_data_sem); 1043 1044 err = udf_add_nondir(dentry, inode); 1045 out: 1046 kfree(name); 1047 return err; 1048 1049 out_no_entry: 1050 up_write(&iinfo->i_data_sem); 1051 inode_dec_link_count(inode); 1052 unlock_new_inode(inode); 1053 iput(inode); 1054 goto out; 1055 } 1056 1057 static int udf_link(struct dentry *old_dentry, struct inode *dir, 1058 struct dentry *dentry) 1059 { 1060 struct inode *inode = d_inode(old_dentry); 1061 struct udf_fileident_bh fibh; 1062 struct fileIdentDesc cfi, *fi; 1063 int err; 1064 1065 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 1066 if (!fi) { 1067 return err; 1068 } 1069 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1070 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location); 1071 if (UDF_SB(inode->i_sb)->s_lvid_bh) { 1072 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1073 cpu_to_le32(lvid_get_unique_id(inode->i_sb)); 1074 } 1075 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1076 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1077 mark_inode_dirty(dir); 1078 1079 if (fibh.sbh != fibh.ebh) 1080 brelse(fibh.ebh); 1081 brelse(fibh.sbh); 1082 inc_nlink(inode); 1083 inode->i_ctime = current_time(inode); 1084 mark_inode_dirty(inode); 1085 dir->i_ctime = dir->i_mtime = current_time(dir); 1086 mark_inode_dirty(dir); 1087 ihold(inode); 1088 d_instantiate(dentry, inode); 1089 1090 return 0; 1091 } 1092 1093 /* Anybody can rename anything with this: the permission checks are left to the 1094 * higher-level routines. 1095 */ 1096 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, 1097 struct inode *new_dir, struct dentry *new_dentry, 1098 unsigned int flags) 1099 { 1100 struct inode *old_inode = d_inode(old_dentry); 1101 struct inode *new_inode = d_inode(new_dentry); 1102 struct udf_fileident_bh ofibh, nfibh; 1103 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL; 1104 struct fileIdentDesc ocfi, ncfi; 1105 struct buffer_head *dir_bh = NULL; 1106 int retval = -ENOENT; 1107 struct kernel_lb_addr tloc; 1108 struct udf_inode_info *old_iinfo = UDF_I(old_inode); 1109 1110 if (flags & ~RENAME_NOREPLACE) 1111 return -EINVAL; 1112 1113 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1114 if (IS_ERR(ofi)) { 1115 retval = PTR_ERR(ofi); 1116 goto end_rename; 1117 } 1118 1119 if (ofibh.sbh != ofibh.ebh) 1120 brelse(ofibh.ebh); 1121 1122 brelse(ofibh.sbh); 1123 tloc = lelb_to_cpu(ocfi.icb.extLocation); 1124 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0) 1125 != old_inode->i_ino) 1126 goto end_rename; 1127 1128 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi); 1129 if (IS_ERR(nfi)) { 1130 retval = PTR_ERR(nfi); 1131 goto end_rename; 1132 } 1133 if (nfi && !new_inode) { 1134 if (nfibh.sbh != nfibh.ebh) 1135 brelse(nfibh.ebh); 1136 brelse(nfibh.sbh); 1137 nfi = NULL; 1138 } 1139 if (S_ISDIR(old_inode->i_mode)) { 1140 int offset = udf_ext0_offset(old_inode); 1141 1142 if (new_inode) { 1143 retval = -ENOTEMPTY; 1144 if (!empty_dir(new_inode)) 1145 goto end_rename; 1146 } 1147 retval = -EIO; 1148 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 1149 dir_fi = udf_get_fileident( 1150 old_iinfo->i_ext.i_data - 1151 (old_iinfo->i_efe ? 1152 sizeof(struct extendedFileEntry) : 1153 sizeof(struct fileEntry)), 1154 old_inode->i_sb->s_blocksize, &offset); 1155 } else { 1156 dir_bh = udf_bread(old_inode, 0, 0, &retval); 1157 if (!dir_bh) 1158 goto end_rename; 1159 dir_fi = udf_get_fileident(dir_bh->b_data, 1160 old_inode->i_sb->s_blocksize, &offset); 1161 } 1162 if (!dir_fi) 1163 goto end_rename; 1164 tloc = lelb_to_cpu(dir_fi->icb.extLocation); 1165 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) != 1166 old_dir->i_ino) 1167 goto end_rename; 1168 } 1169 if (!nfi) { 1170 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, 1171 &retval); 1172 if (!nfi) 1173 goto end_rename; 1174 } 1175 1176 /* 1177 * Like most other Unix systems, set the ctime for inodes on a 1178 * rename. 1179 */ 1180 old_inode->i_ctime = current_time(old_inode); 1181 mark_inode_dirty(old_inode); 1182 1183 /* 1184 * ok, that's it 1185 */ 1186 ncfi.fileVersionNum = ocfi.fileVersionNum; 1187 ncfi.fileCharacteristics = ocfi.fileCharacteristics; 1188 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(ocfi.icb)); 1189 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL); 1190 1191 /* The old fid may have moved - find it again */ 1192 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1193 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); 1194 1195 if (new_inode) { 1196 new_inode->i_ctime = current_time(new_inode); 1197 inode_dec_link_count(new_inode); 1198 } 1199 old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir); 1200 new_dir->i_ctime = new_dir->i_mtime = current_time(new_dir); 1201 mark_inode_dirty(old_dir); 1202 mark_inode_dirty(new_dir); 1203 1204 if (dir_fi) { 1205 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location); 1206 udf_update_tag((char *)dir_fi, 1207 (sizeof(struct fileIdentDesc) + 1208 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); 1209 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1210 mark_inode_dirty(old_inode); 1211 else 1212 mark_buffer_dirty_inode(dir_bh, old_inode); 1213 1214 inode_dec_link_count(old_dir); 1215 if (new_inode) 1216 inode_dec_link_count(new_inode); 1217 else { 1218 inc_nlink(new_dir); 1219 mark_inode_dirty(new_dir); 1220 } 1221 } 1222 1223 if (ofi) { 1224 if (ofibh.sbh != ofibh.ebh) 1225 brelse(ofibh.ebh); 1226 brelse(ofibh.sbh); 1227 } 1228 1229 retval = 0; 1230 1231 end_rename: 1232 brelse(dir_bh); 1233 if (nfi) { 1234 if (nfibh.sbh != nfibh.ebh) 1235 brelse(nfibh.ebh); 1236 brelse(nfibh.sbh); 1237 } 1238 1239 return retval; 1240 } 1241 1242 static struct dentry *udf_get_parent(struct dentry *child) 1243 { 1244 struct kernel_lb_addr tloc; 1245 struct inode *inode = NULL; 1246 struct qstr dotdot = QSTR_INIT("..", 2); 1247 struct fileIdentDesc cfi; 1248 struct udf_fileident_bh fibh; 1249 1250 if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi)) 1251 return ERR_PTR(-EACCES); 1252 1253 if (fibh.sbh != fibh.ebh) 1254 brelse(fibh.ebh); 1255 brelse(fibh.sbh); 1256 1257 tloc = lelb_to_cpu(cfi.icb.extLocation); 1258 inode = udf_iget(child->d_sb, &tloc); 1259 if (IS_ERR(inode)) 1260 return ERR_CAST(inode); 1261 1262 return d_obtain_alias(inode); 1263 } 1264 1265 1266 static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block, 1267 u16 partref, __u32 generation) 1268 { 1269 struct inode *inode; 1270 struct kernel_lb_addr loc; 1271 1272 if (block == 0) 1273 return ERR_PTR(-ESTALE); 1274 1275 loc.logicalBlockNum = block; 1276 loc.partitionReferenceNum = partref; 1277 inode = udf_iget(sb, &loc); 1278 1279 if (IS_ERR(inode)) 1280 return ERR_CAST(inode); 1281 1282 if (generation && inode->i_generation != generation) { 1283 iput(inode); 1284 return ERR_PTR(-ESTALE); 1285 } 1286 return d_obtain_alias(inode); 1287 } 1288 1289 static struct dentry *udf_fh_to_dentry(struct super_block *sb, 1290 struct fid *fid, int fh_len, int fh_type) 1291 { 1292 if (fh_len < 3 || 1293 (fh_type != FILEID_UDF_WITH_PARENT && 1294 fh_type != FILEID_UDF_WITHOUT_PARENT)) 1295 return NULL; 1296 1297 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref, 1298 fid->udf.generation); 1299 } 1300 1301 static struct dentry *udf_fh_to_parent(struct super_block *sb, 1302 struct fid *fid, int fh_len, int fh_type) 1303 { 1304 if (fh_len < 5 || fh_type != FILEID_UDF_WITH_PARENT) 1305 return NULL; 1306 1307 return udf_nfs_get_inode(sb, fid->udf.parent_block, 1308 fid->udf.parent_partref, 1309 fid->udf.parent_generation); 1310 } 1311 static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp, 1312 struct inode *parent) 1313 { 1314 int len = *lenp; 1315 struct kernel_lb_addr location = UDF_I(inode)->i_location; 1316 struct fid *fid = (struct fid *)fh; 1317 int type = FILEID_UDF_WITHOUT_PARENT; 1318 1319 if (parent && (len < 5)) { 1320 *lenp = 5; 1321 return FILEID_INVALID; 1322 } else if (len < 3) { 1323 *lenp = 3; 1324 return FILEID_INVALID; 1325 } 1326 1327 *lenp = 3; 1328 fid->udf.block = location.logicalBlockNum; 1329 fid->udf.partref = location.partitionReferenceNum; 1330 fid->udf.parent_partref = 0; 1331 fid->udf.generation = inode->i_generation; 1332 1333 if (parent) { 1334 location = UDF_I(parent)->i_location; 1335 fid->udf.parent_block = location.logicalBlockNum; 1336 fid->udf.parent_partref = location.partitionReferenceNum; 1337 fid->udf.parent_generation = inode->i_generation; 1338 *lenp = 5; 1339 type = FILEID_UDF_WITH_PARENT; 1340 } 1341 1342 return type; 1343 } 1344 1345 const struct export_operations udf_export_ops = { 1346 .encode_fh = udf_encode_fh, 1347 .fh_to_dentry = udf_fh_to_dentry, 1348 .fh_to_parent = udf_fh_to_parent, 1349 .get_parent = udf_get_parent, 1350 }; 1351 1352 const struct inode_operations udf_dir_inode_operations = { 1353 .lookup = udf_lookup, 1354 .create = udf_create, 1355 .link = udf_link, 1356 .unlink = udf_unlink, 1357 .symlink = udf_symlink, 1358 .mkdir = udf_mkdir, 1359 .rmdir = udf_rmdir, 1360 .mknod = udf_mknod, 1361 .rename = udf_rename, 1362 .tmpfile = udf_tmpfile, 1363 }; 1364