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