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