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 int block, flen; 168 unsigned char *fname = NULL; 169 unsigned char *nameptr; 170 uint8_t lfi; 171 uint16_t liu; 172 loff_t size; 173 struct kernel_lb_addr eloc; 174 uint32_t elen; 175 sector_t offset; 176 struct extent_position epos = {}; 177 struct udf_inode_info *dinfo = UDF_I(dir); 178 int isdotdot = child->len == 2 && 179 child->name[0] == '.' && child->name[1] == '.'; 180 struct super_block *sb = dir->i_sb; 181 182 size = udf_ext0_offset(dir) + dir->i_size; 183 f_pos = udf_ext0_offset(dir); 184 185 fibh->sbh = fibh->ebh = NULL; 186 fibh->soffset = fibh->eoffset = f_pos & (sb->s_blocksize - 1); 187 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 188 if (inode_bmap(dir, f_pos >> sb->s_blocksize_bits, &epos, 189 &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) { 190 fi = ERR_PTR(-EIO); 191 goto out_err; 192 } 193 194 block = udf_get_lb_pblock(sb, &eloc, offset); 195 if ((++offset << sb->s_blocksize_bits) < elen) { 196 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 197 epos.offset -= sizeof(struct short_ad); 198 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 199 epos.offset -= sizeof(struct long_ad); 200 } else 201 offset = 0; 202 203 fibh->sbh = fibh->ebh = udf_tread(sb, block); 204 if (!fibh->sbh) { 205 fi = ERR_PTR(-EIO); 206 goto out_err; 207 } 208 } 209 210 fname = kmalloc(UDF_NAME_LEN, GFP_NOFS); 211 if (!fname) { 212 fi = ERR_PTR(-ENOMEM); 213 goto out_err; 214 } 215 216 while (f_pos < size) { 217 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, 218 &elen, &offset); 219 if (!fi) { 220 fi = ERR_PTR(-EIO); 221 goto out_err; 222 } 223 224 liu = le16_to_cpu(cfi->lengthOfImpUse); 225 lfi = cfi->lengthFileIdent; 226 227 if (fibh->sbh == fibh->ebh) { 228 nameptr = fi->fileIdent + liu; 229 } else { 230 int poffset; /* Unpaded ending offset */ 231 232 poffset = fibh->soffset + sizeof(struct fileIdentDesc) + 233 liu + lfi; 234 235 if (poffset >= lfi) 236 nameptr = (uint8_t *)(fibh->ebh->b_data + 237 poffset - lfi); 238 else { 239 nameptr = fname; 240 memcpy(nameptr, fi->fileIdent + liu, 241 lfi - poffset); 242 memcpy(nameptr + lfi - poffset, 243 fibh->ebh->b_data, poffset); 244 } 245 } 246 247 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { 248 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE)) 249 continue; 250 } 251 252 if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) { 253 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE)) 254 continue; 255 } 256 257 if ((cfi->fileCharacteristics & FID_FILE_CHAR_PARENT) && 258 isdotdot) 259 goto out_ok; 260 261 if (!lfi) 262 continue; 263 264 flen = udf_get_filename(sb, nameptr, lfi, fname, UDF_NAME_LEN); 265 if (flen < 0) { 266 fi = ERR_PTR(flen); 267 goto out_err; 268 } 269 270 if (udf_match(flen, fname, child->len, child->name)) 271 goto out_ok; 272 } 273 274 fi = NULL; 275 out_err: 276 if (fibh->sbh != fibh->ebh) 277 brelse(fibh->ebh); 278 brelse(fibh->sbh); 279 out_ok: 280 brelse(epos.bh); 281 kfree(fname); 282 283 return fi; 284 } 285 286 static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, 287 unsigned int flags) 288 { 289 struct inode *inode = NULL; 290 struct fileIdentDesc cfi; 291 struct udf_fileident_bh fibh; 292 struct fileIdentDesc *fi; 293 294 if (dentry->d_name.len > UDF_NAME_LEN - 2) 295 return ERR_PTR(-ENAMETOOLONG); 296 297 #ifdef UDF_RECOVERY 298 /* temporary shorthand for specifying files by inode number */ 299 if (!strncmp(dentry->d_name.name, ".B=", 3)) { 300 struct kernel_lb_addr lb = { 301 .logicalBlockNum = 0, 302 .partitionReferenceNum = 303 simple_strtoul(dentry->d_name.name + 3, 304 NULL, 0), 305 }; 306 inode = udf_iget(dir->i_sb, lb); 307 if (IS_ERR(inode)) 308 return inode; 309 } else 310 #endif /* UDF_RECOVERY */ 311 312 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 313 if (IS_ERR(fi)) 314 return ERR_CAST(fi); 315 316 if (fi) { 317 struct kernel_lb_addr loc; 318 319 if (fibh.sbh != fibh.ebh) 320 brelse(fibh.ebh); 321 brelse(fibh.sbh); 322 323 loc = lelb_to_cpu(cfi.icb.extLocation); 324 inode = udf_iget(dir->i_sb, &loc); 325 if (IS_ERR(inode)) 326 return ERR_CAST(inode); 327 } 328 329 return d_splice_alias(inode, dentry); 330 } 331 332 static struct fileIdentDesc *udf_add_entry(struct inode *dir, 333 struct dentry *dentry, 334 struct udf_fileident_bh *fibh, 335 struct fileIdentDesc *cfi, int *err) 336 { 337 struct super_block *sb = dir->i_sb; 338 struct fileIdentDesc *fi = NULL; 339 unsigned char *name = NULL; 340 int namelen; 341 loff_t f_pos; 342 loff_t size = udf_ext0_offset(dir) + dir->i_size; 343 int nfidlen; 344 uint8_t lfi; 345 uint16_t liu; 346 int block; 347 struct kernel_lb_addr eloc; 348 uint32_t elen = 0; 349 sector_t offset; 350 struct extent_position epos = {}; 351 struct udf_inode_info *dinfo; 352 353 fibh->sbh = fibh->ebh = NULL; 354 name = kmalloc(UDF_NAME_LEN, GFP_NOFS); 355 if (!name) { 356 *err = -ENOMEM; 357 goto out_err; 358 } 359 360 if (dentry) { 361 if (!dentry->d_name.len) { 362 *err = -EINVAL; 363 goto out_err; 364 } 365 namelen = udf_put_filename(sb, dentry->d_name.name, name, 366 dentry->d_name.len); 367 if (!namelen) { 368 *err = -ENAMETOOLONG; 369 goto out_err; 370 } 371 } else { 372 namelen = 0; 373 } 374 375 nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3; 376 377 f_pos = udf_ext0_offset(dir); 378 379 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 380 dinfo = UDF_I(dir); 381 if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 382 if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, 383 &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) { 384 block = udf_get_lb_pblock(dir->i_sb, 385 &dinfo->i_location, 0); 386 fibh->soffset = fibh->eoffset = sb->s_blocksize; 387 goto add; 388 } 389 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); 390 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 391 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 392 epos.offset -= sizeof(struct short_ad); 393 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 394 epos.offset -= sizeof(struct long_ad); 395 } else 396 offset = 0; 397 398 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); 399 if (!fibh->sbh) { 400 *err = -EIO; 401 goto out_err; 402 } 403 404 block = dinfo->i_location.logicalBlockNum; 405 } 406 407 while (f_pos < size) { 408 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, 409 &elen, &offset); 410 411 if (!fi) { 412 *err = -EIO; 413 goto out_err; 414 } 415 416 liu = le16_to_cpu(cfi->lengthOfImpUse); 417 lfi = cfi->lengthFileIdent; 418 419 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { 420 if (((sizeof(struct fileIdentDesc) + 421 liu + lfi + 3) & ~3) == nfidlen) { 422 cfi->descTag.tagSerialNum = cpu_to_le16(1); 423 cfi->fileVersionNum = cpu_to_le16(1); 424 cfi->fileCharacteristics = 0; 425 cfi->lengthFileIdent = namelen; 426 cfi->lengthOfImpUse = cpu_to_le16(0); 427 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, 428 name)) 429 goto out_ok; 430 else { 431 *err = -EIO; 432 goto out_err; 433 } 434 } 435 } 436 } 437 438 add: 439 f_pos += nfidlen; 440 441 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB && 442 sb->s_blocksize - fibh->eoffset < nfidlen) { 443 brelse(epos.bh); 444 epos.bh = NULL; 445 fibh->soffset -= udf_ext0_offset(dir); 446 fibh->eoffset -= udf_ext0_offset(dir); 447 f_pos -= udf_ext0_offset(dir); 448 if (fibh->sbh != fibh->ebh) 449 brelse(fibh->ebh); 450 brelse(fibh->sbh); 451 fibh->sbh = fibh->ebh = 452 udf_expand_dir_adinicb(dir, &block, err); 453 if (!fibh->sbh) 454 goto out_err; 455 epos.block = dinfo->i_location; 456 epos.offset = udf_file_entry_alloc_offset(dir); 457 /* Load extent udf_expand_dir_adinicb() has created */ 458 udf_current_aext(dir, &epos, &eloc, &elen, 1); 459 } 460 461 /* Entry fits into current block? */ 462 if (sb->s_blocksize - fibh->eoffset >= nfidlen) { 463 fibh->soffset = fibh->eoffset; 464 fibh->eoffset += nfidlen; 465 if (fibh->sbh != fibh->ebh) { 466 brelse(fibh->sbh); 467 fibh->sbh = fibh->ebh; 468 } 469 470 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 471 block = dinfo->i_location.logicalBlockNum; 472 fi = (struct fileIdentDesc *) 473 (dinfo->i_ext.i_data + 474 fibh->soffset - 475 udf_ext0_offset(dir) + 476 dinfo->i_lenEAttr); 477 } else { 478 block = eloc.logicalBlockNum + 479 ((elen - 1) >> 480 dir->i_sb->s_blocksize_bits); 481 fi = (struct fileIdentDesc *) 482 (fibh->sbh->b_data + fibh->soffset); 483 } 484 } else { 485 /* Round up last extent in the file */ 486 elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1); 487 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 488 epos.offset -= sizeof(struct short_ad); 489 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 490 epos.offset -= sizeof(struct long_ad); 491 udf_write_aext(dir, &epos, &eloc, elen, 1); 492 dinfo->i_lenExtents = (dinfo->i_lenExtents + sb->s_blocksize 493 - 1) & ~(sb->s_blocksize - 1); 494 495 fibh->soffset = fibh->eoffset - sb->s_blocksize; 496 fibh->eoffset += nfidlen - sb->s_blocksize; 497 if (fibh->sbh != fibh->ebh) { 498 brelse(fibh->sbh); 499 fibh->sbh = fibh->ebh; 500 } 501 502 block = eloc.logicalBlockNum + ((elen - 1) >> 503 dir->i_sb->s_blocksize_bits); 504 fibh->ebh = udf_bread(dir, 505 f_pos >> dir->i_sb->s_blocksize_bits, 1, err); 506 if (!fibh->ebh) 507 goto out_err; 508 /* Extents could have been merged, invalidate our position */ 509 brelse(epos.bh); 510 epos.bh = NULL; 511 epos.block = dinfo->i_location; 512 epos.offset = udf_file_entry_alloc_offset(dir); 513 514 if (!fibh->soffset) { 515 /* Find the freshly allocated block */ 516 while (udf_next_aext(dir, &epos, &eloc, &elen, 1) == 517 (EXT_RECORDED_ALLOCATED >> 30)) 518 ; 519 block = eloc.logicalBlockNum + ((elen - 1) >> 520 dir->i_sb->s_blocksize_bits); 521 brelse(fibh->sbh); 522 fibh->sbh = fibh->ebh; 523 fi = (struct fileIdentDesc *)(fibh->sbh->b_data); 524 } else { 525 fi = (struct fileIdentDesc *) 526 (fibh->sbh->b_data + sb->s_blocksize + 527 fibh->soffset); 528 } 529 } 530 531 memset(cfi, 0, sizeof(struct fileIdentDesc)); 532 if (UDF_SB(sb)->s_udfrev >= 0x0200) 533 udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, 534 sizeof(struct tag)); 535 else 536 udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, 537 sizeof(struct tag)); 538 cfi->fileVersionNum = cpu_to_le16(1); 539 cfi->lengthFileIdent = namelen; 540 cfi->lengthOfImpUse = cpu_to_le16(0); 541 if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { 542 dir->i_size += nfidlen; 543 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 544 dinfo->i_lenAlloc += nfidlen; 545 else { 546 /* Find the last extent and truncate it to proper size */ 547 while (udf_next_aext(dir, &epos, &eloc, &elen, 1) == 548 (EXT_RECORDED_ALLOCATED >> 30)) 549 ; 550 elen -= dinfo->i_lenExtents - dir->i_size; 551 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 552 epos.offset -= sizeof(struct short_ad); 553 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 554 epos.offset -= sizeof(struct long_ad); 555 udf_write_aext(dir, &epos, &eloc, elen, 1); 556 dinfo->i_lenExtents = dir->i_size; 557 } 558 559 mark_inode_dirty(dir); 560 goto out_ok; 561 } else { 562 *err = -EIO; 563 goto out_err; 564 } 565 566 out_err: 567 fi = NULL; 568 if (fibh->sbh != fibh->ebh) 569 brelse(fibh->ebh); 570 brelse(fibh->sbh); 571 out_ok: 572 brelse(epos.bh); 573 kfree(name); 574 return fi; 575 } 576 577 static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, 578 struct udf_fileident_bh *fibh, 579 struct fileIdentDesc *cfi) 580 { 581 cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; 582 583 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) 584 memset(&(cfi->icb), 0x00, sizeof(struct long_ad)); 585 586 return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); 587 } 588 589 static int udf_add_nondir(struct dentry *dentry, struct inode *inode) 590 { 591 struct udf_inode_info *iinfo = UDF_I(inode); 592 struct inode *dir = d_inode(dentry->d_parent); 593 struct udf_fileident_bh fibh; 594 struct fileIdentDesc cfi, *fi; 595 int err; 596 597 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 598 if (unlikely(!fi)) { 599 inode_dec_link_count(inode); 600 unlock_new_inode(inode); 601 iput(inode); 602 return err; 603 } 604 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 605 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 606 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 607 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 608 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 609 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 610 mark_inode_dirty(dir); 611 if (fibh.sbh != fibh.ebh) 612 brelse(fibh.ebh); 613 brelse(fibh.sbh); 614 unlock_new_inode(inode); 615 d_instantiate(dentry, inode); 616 617 return 0; 618 } 619 620 static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode, 621 bool excl) 622 { 623 struct inode *inode = udf_new_inode(dir, mode); 624 625 if (IS_ERR(inode)) 626 return PTR_ERR(inode); 627 628 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 629 inode->i_data.a_ops = &udf_adinicb_aops; 630 else 631 inode->i_data.a_ops = &udf_aops; 632 inode->i_op = &udf_file_inode_operations; 633 inode->i_fop = &udf_file_operations; 634 mark_inode_dirty(inode); 635 636 return udf_add_nondir(dentry, inode); 637 } 638 639 static int udf_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) 640 { 641 struct inode *inode = udf_new_inode(dir, mode); 642 643 if (IS_ERR(inode)) 644 return PTR_ERR(inode); 645 646 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 647 inode->i_data.a_ops = &udf_adinicb_aops; 648 else 649 inode->i_data.a_ops = &udf_aops; 650 inode->i_op = &udf_file_inode_operations; 651 inode->i_fop = &udf_file_operations; 652 mark_inode_dirty(inode); 653 d_tmpfile(dentry, inode); 654 unlock_new_inode(inode); 655 return 0; 656 } 657 658 static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, 659 dev_t rdev) 660 { 661 struct inode *inode; 662 663 if (!old_valid_dev(rdev)) 664 return -EINVAL; 665 666 inode = udf_new_inode(dir, mode); 667 if (IS_ERR(inode)) 668 return PTR_ERR(inode); 669 670 init_special_inode(inode, mode, rdev); 671 return udf_add_nondir(dentry, inode); 672 } 673 674 static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 675 { 676 struct inode *inode; 677 struct udf_fileident_bh fibh; 678 struct fileIdentDesc cfi, *fi; 679 int err; 680 struct udf_inode_info *dinfo = UDF_I(dir); 681 struct udf_inode_info *iinfo; 682 683 inode = udf_new_inode(dir, S_IFDIR | mode); 684 if (IS_ERR(inode)) 685 return PTR_ERR(inode); 686 687 iinfo = UDF_I(inode); 688 inode->i_op = &udf_dir_inode_operations; 689 inode->i_fop = &udf_dir_operations; 690 fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err); 691 if (!fi) { 692 inode_dec_link_count(inode); 693 unlock_new_inode(inode); 694 iput(inode); 695 goto out; 696 } 697 set_nlink(inode, 2); 698 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 699 cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location); 700 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 701 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL); 702 cfi.fileCharacteristics = 703 FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; 704 udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); 705 brelse(fibh.sbh); 706 mark_inode_dirty(inode); 707 708 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 709 if (!fi) { 710 clear_nlink(inode); 711 mark_inode_dirty(inode); 712 unlock_new_inode(inode); 713 iput(inode); 714 goto out; 715 } 716 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 717 cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); 718 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 719 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); 720 cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; 721 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 722 inc_nlink(dir); 723 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 724 mark_inode_dirty(dir); 725 unlock_new_inode(inode); 726 d_instantiate(dentry, inode); 727 if (fibh.sbh != fibh.ebh) 728 brelse(fibh.ebh); 729 brelse(fibh.sbh); 730 err = 0; 731 732 out: 733 return err; 734 } 735 736 static int empty_dir(struct inode *dir) 737 { 738 struct fileIdentDesc *fi, cfi; 739 struct udf_fileident_bh fibh; 740 loff_t f_pos; 741 loff_t size = udf_ext0_offset(dir) + dir->i_size; 742 int block; 743 struct kernel_lb_addr eloc; 744 uint32_t elen; 745 sector_t offset; 746 struct extent_position epos = {}; 747 struct udf_inode_info *dinfo = UDF_I(dir); 748 749 f_pos = udf_ext0_offset(dir); 750 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); 751 752 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 753 fibh.sbh = fibh.ebh = NULL; 754 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, 755 &epos, &eloc, &elen, &offset) == 756 (EXT_RECORDED_ALLOCATED >> 30)) { 757 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); 758 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { 759 if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 760 epos.offset -= sizeof(struct short_ad); 761 else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 762 epos.offset -= sizeof(struct long_ad); 763 } else 764 offset = 0; 765 766 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); 767 if (!fibh.sbh) { 768 brelse(epos.bh); 769 return 0; 770 } 771 } else { 772 brelse(epos.bh); 773 return 0; 774 } 775 776 while (f_pos < size) { 777 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, 778 &elen, &offset); 779 if (!fi) { 780 if (fibh.sbh != fibh.ebh) 781 brelse(fibh.ebh); 782 brelse(fibh.sbh); 783 brelse(epos.bh); 784 return 0; 785 } 786 787 if (cfi.lengthFileIdent && 788 (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) { 789 if (fibh.sbh != fibh.ebh) 790 brelse(fibh.ebh); 791 brelse(fibh.sbh); 792 brelse(epos.bh); 793 return 0; 794 } 795 } 796 797 if (fibh.sbh != fibh.ebh) 798 brelse(fibh.ebh); 799 brelse(fibh.sbh); 800 brelse(epos.bh); 801 802 return 1; 803 } 804 805 static int udf_rmdir(struct inode *dir, struct dentry *dentry) 806 { 807 int retval; 808 struct inode *inode = d_inode(dentry); 809 struct udf_fileident_bh fibh; 810 struct fileIdentDesc *fi, cfi; 811 struct kernel_lb_addr tloc; 812 813 retval = -ENOENT; 814 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 815 if (IS_ERR_OR_NULL(fi)) { 816 if (fi) 817 retval = PTR_ERR(fi); 818 goto out; 819 } 820 821 retval = -EIO; 822 tloc = lelb_to_cpu(cfi.icb.extLocation); 823 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 824 goto end_rmdir; 825 retval = -ENOTEMPTY; 826 if (!empty_dir(inode)) 827 goto end_rmdir; 828 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 829 if (retval) 830 goto end_rmdir; 831 if (inode->i_nlink != 2) 832 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%d)\n", 833 inode->i_nlink); 834 clear_nlink(inode); 835 inode->i_size = 0; 836 inode_dec_link_count(dir); 837 inode->i_ctime = dir->i_ctime = dir->i_mtime = 838 current_fs_time(dir->i_sb); 839 mark_inode_dirty(dir); 840 841 end_rmdir: 842 if (fibh.sbh != fibh.ebh) 843 brelse(fibh.ebh); 844 brelse(fibh.sbh); 845 846 out: 847 return retval; 848 } 849 850 static int udf_unlink(struct inode *dir, struct dentry *dentry) 851 { 852 int retval; 853 struct inode *inode = d_inode(dentry); 854 struct udf_fileident_bh fibh; 855 struct fileIdentDesc *fi; 856 struct fileIdentDesc cfi; 857 struct kernel_lb_addr tloc; 858 859 retval = -ENOENT; 860 fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi); 861 862 if (IS_ERR_OR_NULL(fi)) { 863 if (fi) 864 retval = PTR_ERR(fi); 865 goto out; 866 } 867 868 retval = -EIO; 869 tloc = lelb_to_cpu(cfi.icb.extLocation); 870 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) 871 goto end_unlink; 872 873 if (!inode->i_nlink) { 874 udf_debug("Deleting nonexistent file (%lu), %d\n", 875 inode->i_ino, inode->i_nlink); 876 set_nlink(inode, 1); 877 } 878 retval = udf_delete_entry(dir, fi, &fibh, &cfi); 879 if (retval) 880 goto end_unlink; 881 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 882 mark_inode_dirty(dir); 883 inode_dec_link_count(inode); 884 inode->i_ctime = dir->i_ctime; 885 retval = 0; 886 887 end_unlink: 888 if (fibh.sbh != fibh.ebh) 889 brelse(fibh.ebh); 890 brelse(fibh.sbh); 891 892 out: 893 return retval; 894 } 895 896 static int udf_symlink(struct inode *dir, struct dentry *dentry, 897 const char *symname) 898 { 899 struct inode *inode = udf_new_inode(dir, S_IFLNK | S_IRWXUGO); 900 struct pathComponent *pc; 901 const char *compstart; 902 struct extent_position epos = {}; 903 int eoffset, elen = 0; 904 uint8_t *ea; 905 int err; 906 int block; 907 unsigned char *name = NULL; 908 int namelen; 909 struct udf_inode_info *iinfo; 910 struct super_block *sb = dir->i_sb; 911 912 if (IS_ERR(inode)) 913 return PTR_ERR(inode); 914 915 iinfo = UDF_I(inode); 916 down_write(&iinfo->i_data_sem); 917 name = kmalloc(UDF_NAME_LEN, GFP_NOFS); 918 if (!name) { 919 err = -ENOMEM; 920 goto out_no_entry; 921 } 922 923 inode->i_data.a_ops = &udf_symlink_aops; 924 inode->i_op = &udf_symlink_inode_operations; 925 926 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 927 struct kernel_lb_addr eloc; 928 uint32_t bsize; 929 930 block = udf_new_block(sb, inode, 931 iinfo->i_location.partitionReferenceNum, 932 iinfo->i_location.logicalBlockNum, &err); 933 if (!block) 934 goto out_no_entry; 935 epos.block = iinfo->i_location; 936 epos.offset = udf_file_entry_alloc_offset(inode); 937 epos.bh = NULL; 938 eloc.logicalBlockNum = block; 939 eloc.partitionReferenceNum = 940 iinfo->i_location.partitionReferenceNum; 941 bsize = sb->s_blocksize; 942 iinfo->i_lenExtents = bsize; 943 udf_add_aext(inode, &epos, &eloc, bsize, 0); 944 brelse(epos.bh); 945 946 block = udf_get_pblock(sb, block, 947 iinfo->i_location.partitionReferenceNum, 948 0); 949 epos.bh = udf_tgetblk(sb, block); 950 lock_buffer(epos.bh); 951 memset(epos.bh->b_data, 0x00, bsize); 952 set_buffer_uptodate(epos.bh); 953 unlock_buffer(epos.bh); 954 mark_buffer_dirty_inode(epos.bh, inode); 955 ea = epos.bh->b_data + udf_ext0_offset(inode); 956 } else 957 ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr; 958 959 eoffset = sb->s_blocksize - udf_ext0_offset(inode); 960 pc = (struct pathComponent *)ea; 961 962 if (*symname == '/') { 963 do { 964 symname++; 965 } while (*symname == '/'); 966 967 pc->componentType = 1; 968 pc->lengthComponentIdent = 0; 969 pc->componentFileVersionNum = 0; 970 elen += sizeof(struct pathComponent); 971 } 972 973 err = -ENAMETOOLONG; 974 975 while (*symname) { 976 if (elen + sizeof(struct pathComponent) > eoffset) 977 goto out_no_entry; 978 979 pc = (struct pathComponent *)(ea + elen); 980 981 compstart = symname; 982 983 do { 984 symname++; 985 } while (*symname && *symname != '/'); 986 987 pc->componentType = 5; 988 pc->lengthComponentIdent = 0; 989 pc->componentFileVersionNum = 0; 990 if (compstart[0] == '.') { 991 if ((symname - compstart) == 1) 992 pc->componentType = 4; 993 else if ((symname - compstart) == 2 && 994 compstart[1] == '.') 995 pc->componentType = 3; 996 } 997 998 if (pc->componentType == 5) { 999 namelen = udf_put_filename(sb, compstart, name, 1000 symname - compstart); 1001 if (!namelen) 1002 goto out_no_entry; 1003 1004 if (elen + sizeof(struct pathComponent) + namelen > 1005 eoffset) 1006 goto out_no_entry; 1007 else 1008 pc->lengthComponentIdent = namelen; 1009 1010 memcpy(pc->componentIdent, name, namelen); 1011 } 1012 1013 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; 1014 1015 if (*symname) { 1016 do { 1017 symname++; 1018 } while (*symname == '/'); 1019 } 1020 } 1021 1022 brelse(epos.bh); 1023 inode->i_size = elen; 1024 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1025 iinfo->i_lenAlloc = inode->i_size; 1026 else 1027 udf_truncate_tail_extent(inode); 1028 mark_inode_dirty(inode); 1029 up_write(&iinfo->i_data_sem); 1030 1031 err = udf_add_nondir(dentry, inode); 1032 out: 1033 kfree(name); 1034 return err; 1035 1036 out_no_entry: 1037 up_write(&iinfo->i_data_sem); 1038 inode_dec_link_count(inode); 1039 unlock_new_inode(inode); 1040 iput(inode); 1041 goto out; 1042 } 1043 1044 static int udf_link(struct dentry *old_dentry, struct inode *dir, 1045 struct dentry *dentry) 1046 { 1047 struct inode *inode = d_inode(old_dentry); 1048 struct udf_fileident_bh fibh; 1049 struct fileIdentDesc cfi, *fi; 1050 int err; 1051 1052 fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); 1053 if (!fi) { 1054 return err; 1055 } 1056 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); 1057 cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location); 1058 if (UDF_SB(inode->i_sb)->s_lvid_bh) { 1059 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = 1060 cpu_to_le32(lvid_get_unique_id(inode->i_sb)); 1061 } 1062 udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); 1063 if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1064 mark_inode_dirty(dir); 1065 1066 if (fibh.sbh != fibh.ebh) 1067 brelse(fibh.ebh); 1068 brelse(fibh.sbh); 1069 inc_nlink(inode); 1070 inode->i_ctime = current_fs_time(inode->i_sb); 1071 mark_inode_dirty(inode); 1072 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); 1073 mark_inode_dirty(dir); 1074 ihold(inode); 1075 d_instantiate(dentry, inode); 1076 1077 return 0; 1078 } 1079 1080 /* Anybody can rename anything with this: the permission checks are left to the 1081 * higher-level routines. 1082 */ 1083 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, 1084 struct inode *new_dir, struct dentry *new_dentry) 1085 { 1086 struct inode *old_inode = d_inode(old_dentry); 1087 struct inode *new_inode = d_inode(new_dentry); 1088 struct udf_fileident_bh ofibh, nfibh; 1089 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL; 1090 struct fileIdentDesc ocfi, ncfi; 1091 struct buffer_head *dir_bh = NULL; 1092 int retval = -ENOENT; 1093 struct kernel_lb_addr tloc; 1094 struct udf_inode_info *old_iinfo = UDF_I(old_inode); 1095 1096 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1097 if (IS_ERR(ofi)) { 1098 retval = PTR_ERR(ofi); 1099 goto end_rename; 1100 } 1101 1102 if (ofibh.sbh != ofibh.ebh) 1103 brelse(ofibh.ebh); 1104 1105 brelse(ofibh.sbh); 1106 tloc = lelb_to_cpu(ocfi.icb.extLocation); 1107 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0) 1108 != old_inode->i_ino) 1109 goto end_rename; 1110 1111 nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi); 1112 if (IS_ERR(nfi)) { 1113 retval = PTR_ERR(nfi); 1114 goto end_rename; 1115 } 1116 if (nfi && !new_inode) { 1117 if (nfibh.sbh != nfibh.ebh) 1118 brelse(nfibh.ebh); 1119 brelse(nfibh.sbh); 1120 nfi = NULL; 1121 } 1122 if (S_ISDIR(old_inode->i_mode)) { 1123 int offset = udf_ext0_offset(old_inode); 1124 1125 if (new_inode) { 1126 retval = -ENOTEMPTY; 1127 if (!empty_dir(new_inode)) 1128 goto end_rename; 1129 } 1130 retval = -EIO; 1131 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { 1132 dir_fi = udf_get_fileident( 1133 old_iinfo->i_ext.i_data - 1134 (old_iinfo->i_efe ? 1135 sizeof(struct extendedFileEntry) : 1136 sizeof(struct fileEntry)), 1137 old_inode->i_sb->s_blocksize, &offset); 1138 } else { 1139 dir_bh = udf_bread(old_inode, 0, 0, &retval); 1140 if (!dir_bh) 1141 goto end_rename; 1142 dir_fi = udf_get_fileident(dir_bh->b_data, 1143 old_inode->i_sb->s_blocksize, &offset); 1144 } 1145 if (!dir_fi) 1146 goto end_rename; 1147 tloc = lelb_to_cpu(dir_fi->icb.extLocation); 1148 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) != 1149 old_dir->i_ino) 1150 goto end_rename; 1151 } 1152 if (!nfi) { 1153 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, 1154 &retval); 1155 if (!nfi) 1156 goto end_rename; 1157 } 1158 1159 /* 1160 * Like most other Unix systems, set the ctime for inodes on a 1161 * rename. 1162 */ 1163 old_inode->i_ctime = current_fs_time(old_inode->i_sb); 1164 mark_inode_dirty(old_inode); 1165 1166 /* 1167 * ok, that's it 1168 */ 1169 ncfi.fileVersionNum = ocfi.fileVersionNum; 1170 ncfi.fileCharacteristics = ocfi.fileCharacteristics; 1171 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad)); 1172 udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL); 1173 1174 /* The old fid may have moved - find it again */ 1175 ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi); 1176 udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); 1177 1178 if (new_inode) { 1179 new_inode->i_ctime = current_fs_time(new_inode->i_sb); 1180 inode_dec_link_count(new_inode); 1181 } 1182 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); 1183 new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb); 1184 mark_inode_dirty(old_dir); 1185 mark_inode_dirty(new_dir); 1186 1187 if (dir_fi) { 1188 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location); 1189 udf_update_tag((char *)dir_fi, 1190 (sizeof(struct fileIdentDesc) + 1191 le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); 1192 if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) 1193 mark_inode_dirty(old_inode); 1194 else 1195 mark_buffer_dirty_inode(dir_bh, old_inode); 1196 1197 inode_dec_link_count(old_dir); 1198 if (new_inode) 1199 inode_dec_link_count(new_inode); 1200 else { 1201 inc_nlink(new_dir); 1202 mark_inode_dirty(new_dir); 1203 } 1204 } 1205 1206 if (ofi) { 1207 if (ofibh.sbh != ofibh.ebh) 1208 brelse(ofibh.ebh); 1209 brelse(ofibh.sbh); 1210 } 1211 1212 retval = 0; 1213 1214 end_rename: 1215 brelse(dir_bh); 1216 if (nfi) { 1217 if (nfibh.sbh != nfibh.ebh) 1218 brelse(nfibh.ebh); 1219 brelse(nfibh.sbh); 1220 } 1221 1222 return retval; 1223 } 1224 1225 static struct dentry *udf_get_parent(struct dentry *child) 1226 { 1227 struct kernel_lb_addr tloc; 1228 struct inode *inode = NULL; 1229 struct qstr dotdot = QSTR_INIT("..", 2); 1230 struct fileIdentDesc cfi; 1231 struct udf_fileident_bh fibh; 1232 1233 if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi)) 1234 return ERR_PTR(-EACCES); 1235 1236 if (fibh.sbh != fibh.ebh) 1237 brelse(fibh.ebh); 1238 brelse(fibh.sbh); 1239 1240 tloc = lelb_to_cpu(cfi.icb.extLocation); 1241 inode = udf_iget(d_inode(child)->i_sb, &tloc); 1242 if (IS_ERR(inode)) 1243 return ERR_CAST(inode); 1244 1245 return d_obtain_alias(inode); 1246 } 1247 1248 1249 static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block, 1250 u16 partref, __u32 generation) 1251 { 1252 struct inode *inode; 1253 struct kernel_lb_addr loc; 1254 1255 if (block == 0) 1256 return ERR_PTR(-ESTALE); 1257 1258 loc.logicalBlockNum = block; 1259 loc.partitionReferenceNum = partref; 1260 inode = udf_iget(sb, &loc); 1261 1262 if (IS_ERR(inode)) 1263 return ERR_CAST(inode); 1264 1265 if (generation && inode->i_generation != generation) { 1266 iput(inode); 1267 return ERR_PTR(-ESTALE); 1268 } 1269 return d_obtain_alias(inode); 1270 } 1271 1272 static struct dentry *udf_fh_to_dentry(struct super_block *sb, 1273 struct fid *fid, int fh_len, int fh_type) 1274 { 1275 if (fh_len < 3 || 1276 (fh_type != FILEID_UDF_WITH_PARENT && 1277 fh_type != FILEID_UDF_WITHOUT_PARENT)) 1278 return NULL; 1279 1280 return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref, 1281 fid->udf.generation); 1282 } 1283 1284 static struct dentry *udf_fh_to_parent(struct super_block *sb, 1285 struct fid *fid, int fh_len, int fh_type) 1286 { 1287 if (fh_len < 5 || fh_type != FILEID_UDF_WITH_PARENT) 1288 return NULL; 1289 1290 return udf_nfs_get_inode(sb, fid->udf.parent_block, 1291 fid->udf.parent_partref, 1292 fid->udf.parent_generation); 1293 } 1294 static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp, 1295 struct inode *parent) 1296 { 1297 int len = *lenp; 1298 struct kernel_lb_addr location = UDF_I(inode)->i_location; 1299 struct fid *fid = (struct fid *)fh; 1300 int type = FILEID_UDF_WITHOUT_PARENT; 1301 1302 if (parent && (len < 5)) { 1303 *lenp = 5; 1304 return FILEID_INVALID; 1305 } else if (len < 3) { 1306 *lenp = 3; 1307 return FILEID_INVALID; 1308 } 1309 1310 *lenp = 3; 1311 fid->udf.block = location.logicalBlockNum; 1312 fid->udf.partref = location.partitionReferenceNum; 1313 fid->udf.parent_partref = 0; 1314 fid->udf.generation = inode->i_generation; 1315 1316 if (parent) { 1317 location = UDF_I(parent)->i_location; 1318 fid->udf.parent_block = location.logicalBlockNum; 1319 fid->udf.parent_partref = location.partitionReferenceNum; 1320 fid->udf.parent_generation = inode->i_generation; 1321 *lenp = 5; 1322 type = FILEID_UDF_WITH_PARENT; 1323 } 1324 1325 return type; 1326 } 1327 1328 const struct export_operations udf_export_ops = { 1329 .encode_fh = udf_encode_fh, 1330 .fh_to_dentry = udf_fh_to_dentry, 1331 .fh_to_parent = udf_fh_to_parent, 1332 .get_parent = udf_get_parent, 1333 }; 1334 1335 const struct inode_operations udf_dir_inode_operations = { 1336 .lookup = udf_lookup, 1337 .create = udf_create, 1338 .link = udf_link, 1339 .unlink = udf_unlink, 1340 .symlink = udf_symlink, 1341 .mkdir = udf_mkdir, 1342 .rmdir = udf_rmdir, 1343 .mknod = udf_mknod, 1344 .rename = udf_rename, 1345 .tmpfile = udf_tmpfile, 1346 }; 1347 const struct inode_operations udf_symlink_inode_operations = { 1348 .readlink = generic_readlink, 1349 .follow_link = page_follow_link_light, 1350 .put_link = page_put_link, 1351 }; 1352