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