fs/udf/namei.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * namei.c
   4  *
   5  * PURPOSE
   6  *      Inode name handling routines for the OSTA-UDF(tm) filesystem.
   7  *
   8  * COPYRIGHT
   9  *  (C) 1998-2004 Ben Fennema
  10  *  (C) 1999-2000 Stelias Computing Inc
  11  *
  12  * HISTORY
  13  *
  14  *  12/12/98 blf  Created. Split out the lookup code from dir.c
  15  *  04/19/99 blf  link, mknod, symlink support
  16  */
  17
  18 #include "udfdecl.h"
  19
  20 #include "udf_i.h"
  21 #include "udf_sb.h"
  22 #include <linux/string.h>
  23 #include <linux/errno.h>
  24 #include <linux/mm.h>
  25 #include <linux/slab.h>
  26 #include <linux/sched.h>
  27 #include <linux/crc-itu-t.h>
  28 #include <linux/exportfs.h>
  29 #include <linux/iversion.h>
  30
  31 static inline int udf_match(int len1, const unsigned char *name1, int len2,
  32                             const unsigned char *name2)
  33 {
  34         if (len1 != len2)
  35                 return 0;
  36
  37         return !memcmp(name1, name2, len1);
  38 }
  39
  40 /**
  41  * udf_fiiter_find_entry - find entry in given directory.
  42  *
  43  * @dir:        directory inode to search in
  44  * @child:      qstr of the name
  45  * @iter:       iter to use for searching
  46  *
  47  * This function searches in the directory @dir for a file name @child. When
  48  * found, @iter points to the position in the directory with given entry.
  49  *
  50  * Returns 0 on success, < 0 on error (including -ENOENT).
  51  */
  52 static int udf_fiiter_find_entry(struct inode *dir, const struct qstr *child,
  53                                  struct udf_fileident_iter *iter)
  54 {
  55         int flen;
  56         unsigned char *fname = NULL;
  57         struct super_block *sb = dir->i_sb;
  58         int isdotdot = child->len == 2 &&
  59                 child->name[0] == '.' && child->name[1] == '.';
  60         int ret;
  61
  62         fname = kmalloc(UDF_NAME_LEN, GFP_KERNEL);
  63         if (!fname)
  64                 return -ENOMEM;
  65
  66         for (ret = udf_fiiter_init(iter, dir, 0);
  67              !ret && iter->pos < dir->i_size;
  68              ret = udf_fiiter_advance(iter)) {
  69                 if (iter->fi.fileCharacteristics & FID_FILE_CHAR_DELETED) {
  70                         if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
  71                                 continue;
  72                 }
  73
  74                 if (iter->fi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) {
  75                         if (!UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
  76                                 continue;
  77                 }
  78
  79                 if ((iter->fi.fileCharacteristics & FID_FILE_CHAR_PARENT) &&
  80                     isdotdot)
  81                         goto out_ok;
  82
  83                 if (!iter->fi.lengthFileIdent)
  84                         continue;
  85
  86                 flen = udf_get_filename(sb, iter->name,
  87                                 iter->fi.lengthFileIdent, fname, UDF_NAME_LEN);
  88                 if (flen < 0) {
  89                         ret = flen;
  90                         goto out_err;
  91                 }
  92
  93                 if (udf_match(flen, fname, child->len, child->name))
  94                         goto out_ok;
  95         }
  96         if (!ret)
  97                 ret = -ENOENT;
  98
  99 out_err:
 100         udf_fiiter_release(iter);
 101 out_ok:
 102         kfree(fname);
 103
 104         return ret;
 105 }
 106
 107 static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
 108                                  unsigned int flags)
 109 {
 110         struct inode *inode = NULL;
 111         struct udf_fileident_iter iter;
 112         int err;
 113
 114         if (dentry->d_name.len > UDF_NAME_LEN)
 115                 return ERR_PTR(-ENAMETOOLONG);
 116
 117         err = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);
 118         if (err < 0 && err != -ENOENT)
 119                 return ERR_PTR(err);
 120
 121         if (err == 0) {
 122                 struct kernel_lb_addr loc;
 123
 124                 loc = lelb_to_cpu(iter.fi.icb.extLocation);
 125                 udf_fiiter_release(&iter);
 126
 127                 inode = udf_iget(dir->i_sb, &loc);
 128         }
 129
 130         return d_splice_alias(inode, dentry);
 131 }
 132
 133 static int udf_expand_dir_adinicb(struct inode *inode, udf_pblk_t *block)
 134 {
 135         udf_pblk_t newblock;
 136         struct buffer_head *dbh = NULL;
 137         struct kernel_lb_addr eloc;
 138         struct extent_position epos;
 139         uint8_t alloctype;
 140         struct udf_inode_info *iinfo = UDF_I(inode);
 141         struct udf_fileident_iter iter;
 142         uint8_t *impuse;
 143         int ret;
 144
 145         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
 146                 alloctype = ICBTAG_FLAG_AD_SHORT;
 147         else
 148                 alloctype = ICBTAG_FLAG_AD_LONG;
 149
 150         if (!inode->i_size) {
 151                 iinfo->i_alloc_type = alloctype;
 152                 mark_inode_dirty(inode);
 153                 return 0;
 154         }
 155
 156         /* alloc block, and copy data to it */
 157         *block = udf_new_block(inode->i_sb, inode,
 158                                iinfo->i_location.partitionReferenceNum,
 159                                iinfo->i_location.logicalBlockNum, &ret);
 160         if (!(*block))
 161                 return ret;
 162         newblock = udf_get_pblock(inode->i_sb, *block,
 163                                   iinfo->i_location.partitionReferenceNum,
 164                                 0);
 165         if (newblock == 0xffffffff)
 166                 return -EFSCORRUPTED;
 167         dbh = sb_getblk(inode->i_sb, newblock);
 168         if (!dbh)
 169                 return -ENOMEM;
 170         lock_buffer(dbh);
 171         memcpy(dbh->b_data, iinfo->i_data, inode->i_size);
 172         memset(dbh->b_data + inode->i_size, 0,
 173                inode->i_sb->s_blocksize - inode->i_size);
 174         set_buffer_uptodate(dbh);
 175         unlock_buffer(dbh);
 176
 177         /* Drop inline data, add block instead */
 178         iinfo->i_alloc_type = alloctype;
 179         memset(iinfo->i_data + iinfo->i_lenEAttr, 0, iinfo->i_lenAlloc);
 180         iinfo->i_lenAlloc = 0;
 181         eloc.logicalBlockNum = *block;
 182         eloc.partitionReferenceNum =
 183                                 iinfo->i_location.partitionReferenceNum;
 184         iinfo->i_lenExtents = inode->i_size;
 185         epos.bh = NULL;
 186         epos.block = iinfo->i_location;
 187         epos.offset = udf_file_entry_alloc_offset(inode);
 188         ret = udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
 189         brelse(epos.bh);
 190         if (ret < 0) {
 191                 brelse(dbh);
 192                 udf_free_blocks(inode->i_sb, inode, &eloc, 0, 1);
 193                 return ret;
 194         }
 195         mark_inode_dirty(inode);
 196
 197         /* Now fixup tags in moved directory entries */
 198         for (ret = udf_fiiter_init(&iter, inode, 0);
 199              !ret && iter.pos < inode->i_size;
 200              ret = udf_fiiter_advance(&iter)) {
 201                 iter.fi.descTag.tagLocation = cpu_to_le32(*block);
 202                 if (iter.fi.lengthOfImpUse != cpu_to_le16(0))
 203                         impuse = dbh->b_data + iter.pos +
 204                                                 sizeof(struct fileIdentDesc);
 205                 else
 206                         impuse = NULL;
 207                 udf_fiiter_write_fi(&iter, impuse);
 208         }
 209         brelse(dbh);
 210         /*
 211          * We don't expect the iteration to fail as the directory has been
 212          * already verified to be correct
 213          */
 214         WARN_ON_ONCE(ret);
 215         udf_fiiter_release(&iter);
 216
 217         return 0;
 218 }
 219
 220 static int udf_fiiter_add_entry(struct inode *dir, struct dentry *dentry,
 221                                 struct udf_fileident_iter *iter)
 222 {
 223         struct udf_inode_info *dinfo = UDF_I(dir);
 224         int nfidlen, namelen = 0;
 225         int ret;
 226         int off, blksize = 1 << dir->i_blkbits;
 227         udf_pblk_t block;
 228         char name[UDF_NAME_LEN_CS0];
 229
 230         if (dentry) {
 231                 namelen = udf_put_filename(dir->i_sb, dentry->d_name.name,
 232                                            dentry->d_name.len,
 233                                            name, UDF_NAME_LEN_CS0);
 234                 if (!namelen)
 235                         return -ENAMETOOLONG;
 236         }
 237         nfidlen = ALIGN(sizeof(struct fileIdentDesc) + namelen, UDF_NAME_PAD);
 238
 239         for (ret = udf_fiiter_init(iter, dir, 0);
 240              !ret && iter->pos < dir->i_size;
 241              ret = udf_fiiter_advance(iter)) {
 242                 if (iter->fi.fileCharacteristics & FID_FILE_CHAR_DELETED) {
 243                         if (udf_dir_entry_len(&iter->fi) == nfidlen) {
 244                                 iter->fi.descTag.tagSerialNum = cpu_to_le16(1);
 245                                 iter->fi.fileVersionNum = cpu_to_le16(1);
 246                                 iter->fi.fileCharacteristics = 0;
 247                                 iter->fi.lengthFileIdent = namelen;
 248                                 iter->fi.lengthOfImpUse = cpu_to_le16(0);
 249                                 memcpy(iter->namebuf, name, namelen);
 250                                 iter->name = iter->namebuf;
 251                                 return 0;
 252                         }
 253                 }
 254         }
 255         if (ret) {
 256                 udf_fiiter_release(iter);
 257                 return ret;
 258         }
 259         if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
 260             blksize - udf_ext0_offset(dir) - iter->pos < nfidlen) {
 261                 udf_fiiter_release(iter);
 262                 ret = udf_expand_dir_adinicb(dir, &block);
 263                 if (ret)
 264                         return ret;
 265                 ret = udf_fiiter_init(iter, dir, dir->i_size);
 266                 if (ret < 0)
 267                         return ret;
 268         }
 269
 270         /* Get blocknumber to use for entry tag */
 271         if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
 272                 block = dinfo->i_location.logicalBlockNum;
 273         } else {
 274                 block = iter->eloc.logicalBlockNum +
 275                                 ((iter->elen - 1) >> dir->i_blkbits);
 276         }
 277         off = iter->pos & (blksize - 1);
 278         if (!off)
 279                 off = blksize;
 280         /* Entry fits into current block? */
 281         if (blksize - udf_ext0_offset(dir) - off >= nfidlen)
 282                 goto store_fi;
 283
 284         ret = udf_fiiter_append_blk(iter);
 285         if (ret) {
 286                 udf_fiiter_release(iter);
 287                 return ret;
 288         }
 289
 290         /* Entry will be completely in the new block? Update tag location... */
 291         if (!(iter->pos & (blksize - 1)))
 292                 block = iter->eloc.logicalBlockNum +
 293                                 ((iter->elen - 1) >> dir->i_blkbits);
 294 store_fi:
 295         memset(&iter->fi, 0, sizeof(struct fileIdentDesc));
 296         if (UDF_SB(dir->i_sb)->s_udfrev >= 0x0200)
 297                 udf_new_tag((char *)(&iter->fi), TAG_IDENT_FID, 3, 1, block,
 298                             sizeof(struct tag));
 299         else
 300                 udf_new_tag((char *)(&iter->fi), TAG_IDENT_FID, 2, 1, block,
 301                             sizeof(struct tag));
 302         iter->fi.fileVersionNum = cpu_to_le16(1);
 303         iter->fi.lengthFileIdent = namelen;
 304         iter->fi.lengthOfImpUse = cpu_to_le16(0);
 305         memcpy(iter->namebuf, name, namelen);
 306         iter->name = iter->namebuf;
 307
 308         dir->i_size += nfidlen;
 309         if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
 310                 dinfo->i_lenAlloc += nfidlen;
 311         } else {
 312                 /* Truncate last extent to proper size */
 313                 udf_fiiter_update_elen(iter, iter->elen -
 314                                         (dinfo->i_lenExtents - dir->i_size));
 315         }
 316         mark_inode_dirty(dir);
 317
 318         return 0;
 319 }
 320
 321 static void udf_fiiter_delete_entry(struct udf_fileident_iter *iter)
 322 {
 323         iter->fi.fileCharacteristics |= FID_FILE_CHAR_DELETED;
 324
 325         if (UDF_QUERY_FLAG(iter->dir->i_sb, UDF_FLAG_STRICT))
 326                 memset(&iter->fi.icb, 0x00, sizeof(struct long_ad));
 327
 328         udf_fiiter_write_fi(iter, NULL);
 329 }
 330
 331 static void udf_add_fid_counter(struct super_block *sb, bool dir, int val)
 332 {
 333         struct logicalVolIntegrityDescImpUse *lvidiu = udf_sb_lvidiu(sb);
 334
 335         if (!lvidiu)
 336                 return;
 337         mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
 338         if (dir)
 339                 le32_add_cpu(&lvidiu->numDirs, val);
 340         else
 341                 le32_add_cpu(&lvidiu->numFiles, val);
 342         udf_updated_lvid(sb);
 343         mutex_unlock(&UDF_SB(sb)->s_alloc_mutex);
 344 }
 345
 346 static int udf_add_nondir(struct dentry *dentry, struct inode *inode)
 347 {
 348         struct udf_inode_info *iinfo = UDF_I(inode);
 349         struct inode *dir = d_inode(dentry->d_parent);
 350         struct udf_fileident_iter iter;
 351         int err;
 352
 353         err = udf_fiiter_add_entry(dir, dentry, &iter);
 354         if (err) {
 355                 inode_dec_link_count(inode);
 356                 discard_new_inode(inode);
 357                 return err;
 358         }
 359         iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
 360         iter.fi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
 361         *(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =
 362                 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
 363         udf_fiiter_write_fi(&iter, NULL);
 364         inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
 365         mark_inode_dirty(dir);
 366         udf_fiiter_release(&iter);
 367         udf_add_fid_counter(dir->i_sb, false, 1);
 368         d_instantiate_new(dentry, inode);
 369
 370         return 0;
 371 }
 372
 373 static int udf_create(struct mnt_idmap *idmap, struct inode *dir,
 374                       struct dentry *dentry, umode_t mode, bool excl)
 375 {
 376         struct inode *inode = udf_new_inode(dir, mode);
 377
 378         if (IS_ERR(inode))
 379                 return PTR_ERR(inode);
 380
 381         inode->i_data.a_ops = &udf_aops;
 382         inode->i_op = &udf_file_inode_operations;
 383         inode->i_fop = &udf_file_operations;
 384         mark_inode_dirty(inode);
 385
 386         return udf_add_nondir(dentry, inode);
 387 }
 388
 389 static int udf_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
 390                        struct file *file, umode_t mode)
 391 {
 392         struct inode *inode = udf_new_inode(dir, mode);
 393
 394         if (IS_ERR(inode))
 395                 return PTR_ERR(inode);
 396
 397         inode->i_data.a_ops = &udf_aops;
 398         inode->i_op = &udf_file_inode_operations;
 399         inode->i_fop = &udf_file_operations;
 400         mark_inode_dirty(inode);
 401         d_tmpfile(file, inode);
 402         unlock_new_inode(inode);
 403         return finish_open_simple(file, 0);
 404 }
 405
 406 static int udf_mknod(struct mnt_idmap *idmap, struct inode *dir,
 407                      struct dentry *dentry, umode_t mode, dev_t rdev)
 408 {
 409         struct inode *inode;
 410
 411         if (!old_valid_dev(rdev))
 412                 return -EINVAL;
 413
 414         inode = udf_new_inode(dir, mode);
 415         if (IS_ERR(inode))
 416                 return PTR_ERR(inode);
 417
 418         init_special_inode(inode, mode, rdev);
 419         return udf_add_nondir(dentry, inode);
 420 }
 421
 422 static int udf_mkdir(struct mnt_idmap *idmap, struct inode *dir,
 423                      struct dentry *dentry, umode_t mode)
 424 {
 425         struct inode *inode;
 426         struct udf_fileident_iter iter;
 427         int err;
 428         struct udf_inode_info *dinfo = UDF_I(dir);
 429         struct udf_inode_info *iinfo;
 430
 431         inode = udf_new_inode(dir, S_IFDIR | mode);
 432         if (IS_ERR(inode))
 433                 return PTR_ERR(inode);
 434
 435         iinfo = UDF_I(inode);
 436         inode->i_op = &udf_dir_inode_operations;
 437         inode->i_fop = &udf_dir_operations;
 438         err = udf_fiiter_add_entry(inode, NULL, &iter);
 439         if (err) {
 440                 clear_nlink(inode);
 441                 discard_new_inode(inode);
 442                 return err;
 443         }
 444         set_nlink(inode, 2);
 445         iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
 446         iter.fi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
 447         *(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =
 448                 cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
 449         iter.fi.fileCharacteristics =
 450                         FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
 451         udf_fiiter_write_fi(&iter, NULL);
 452         udf_fiiter_release(&iter);
 453         mark_inode_dirty(inode);
 454
 455         err = udf_fiiter_add_entry(dir, dentry, &iter);
 456         if (err) {
 457                 clear_nlink(inode);
 458                 discard_new_inode(inode);
 459                 return err;
 460         }
 461         iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
 462         iter.fi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
 463         *(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =
 464                 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
 465         iter.fi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
 466         udf_fiiter_write_fi(&iter, NULL);
 467         udf_fiiter_release(&iter);
 468         udf_add_fid_counter(dir->i_sb, true, 1);
 469         inc_nlink(dir);
 470         inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
 471         mark_inode_dirty(dir);
 472         d_instantiate_new(dentry, inode);
 473
 474         return 0;
 475 }
 476
 477 static int empty_dir(struct inode *dir)
 478 {
 479         struct udf_fileident_iter iter;
 480         int ret;
 481
 482         for (ret = udf_fiiter_init(&iter, dir, 0);
 483              !ret && iter.pos < dir->i_size;
 484              ret = udf_fiiter_advance(&iter)) {
 485                 if (iter.fi.lengthFileIdent &&
 486                     !(iter.fi.fileCharacteristics & FID_FILE_CHAR_DELETED)) {
 487                         udf_fiiter_release(&iter);
 488                         return 0;
 489                 }
 490         }
 491         udf_fiiter_release(&iter);
 492
 493         return 1;
 494 }
 495
 496 static int udf_rmdir(struct inode *dir, struct dentry *dentry)
 497 {
 498         int ret;
 499         struct inode *inode = d_inode(dentry);
 500         struct udf_fileident_iter iter;
 501         struct kernel_lb_addr tloc;
 502
 503         ret = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);
 504         if (ret)
 505                 goto out;
 506
 507         ret = -EFSCORRUPTED;
 508         tloc = lelb_to_cpu(iter.fi.icb.extLocation);
 509         if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
 510                 goto end_rmdir;
 511         ret = -ENOTEMPTY;
 512         if (!empty_dir(inode))
 513                 goto end_rmdir;
 514         udf_fiiter_delete_entry(&iter);
 515         if (inode->i_nlink != 2)
 516                 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%u)\n",
 517                          inode->i_nlink);
 518         clear_nlink(inode);
 519         inode->i_size = 0;
 520         if (dir->i_nlink >= 3)
 521                 inode_dec_link_count(dir);
 522         else
 523                 udf_warn(inode->i_sb, "parent dir link count too low (%u)\n",
 524                          dir->i_nlink);
 525         udf_add_fid_counter(dir->i_sb, true, -1);
 526         inode_set_mtime_to_ts(dir,
 527                               inode_set_ctime_to_ts(dir, inode_set_ctime_current(inode)));
 528         mark_inode_dirty(dir);
 529         ret = 0;
 530 end_rmdir:
 531         udf_fiiter_release(&iter);
 532 out:
 533         return ret;
 534 }
 535
 536 static int udf_unlink(struct inode *dir, struct dentry *dentry)
 537 {
 538         int ret;
 539         struct inode *inode = d_inode(dentry);
 540         struct udf_fileident_iter iter;
 541         struct kernel_lb_addr tloc;
 542
 543         ret = udf_fiiter_find_entry(dir, &dentry->d_name, &iter);
 544         if (ret)
 545                 goto out;
 546
 547         ret = -EFSCORRUPTED;
 548         tloc = lelb_to_cpu(iter.fi.icb.extLocation);
 549         if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)
 550                 goto end_unlink;
 551
 552         if (!inode->i_nlink) {
 553                 udf_debug("Deleting nonexistent file (%lu), %u\n",
 554                           inode->i_ino, inode->i_nlink);
 555                 set_nlink(inode, 1);
 556         }
 557         udf_fiiter_delete_entry(&iter);
 558         inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
 559         mark_inode_dirty(dir);
 560         inode_dec_link_count(inode);
 561         udf_add_fid_counter(dir->i_sb, false, -1);
 562         inode_set_ctime_to_ts(inode, inode_get_ctime(dir));
 563         ret = 0;
 564 end_unlink:
 565         udf_fiiter_release(&iter);
 566 out:
 567         return ret;
 568 }
 569
 570 static int udf_symlink(struct mnt_idmap *idmap, struct inode *dir,
 571                        struct dentry *dentry, const char *symname)
 572 {
 573         struct inode *inode;
 574         struct pathComponent *pc;
 575         const char *compstart;
 576         struct extent_position epos = {};
 577         int eoffset, elen = 0;
 578         uint8_t *ea;
 579         int err;
 580         udf_pblk_t block;
 581         unsigned char *name = NULL;
 582         int namelen;
 583         struct udf_inode_info *iinfo;
 584         struct super_block *sb = dir->i_sb;
 585
 586         name = kmalloc(UDF_NAME_LEN_CS0, GFP_KERNEL);
 587         if (!name) {
 588                 err = -ENOMEM;
 589                 goto out;
 590         }
 591
 592         inode = udf_new_inode(dir, S_IFLNK | 0777);
 593         if (IS_ERR(inode)) {
 594                 err = PTR_ERR(inode);
 595                 goto out;
 596         }
 597
 598         iinfo = UDF_I(inode);
 599         down_write(&iinfo->i_data_sem);
 600         inode->i_data.a_ops = &udf_symlink_aops;
 601         inode->i_op = &udf_symlink_inode_operations;
 602         inode_nohighmem(inode);
 603
 604         if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
 605                 struct kernel_lb_addr eloc;
 606                 uint32_t bsize;
 607
 608                 block = udf_new_block(sb, inode,
 609                                 iinfo->i_location.partitionReferenceNum,
 610                                 iinfo->i_location.logicalBlockNum, &err);
 611                 if (!block)
 612                         goto out_no_entry;
 613                 epos.block = iinfo->i_location;
 614                 epos.offset = udf_file_entry_alloc_offset(inode);
 615                 epos.bh = NULL;
 616                 eloc.logicalBlockNum = block;
 617                 eloc.partitionReferenceNum =
 618                                 iinfo->i_location.partitionReferenceNum;
 619                 bsize = sb->s_blocksize;
 620                 iinfo->i_lenExtents = bsize;
 621                 err = udf_add_aext(inode, &epos, &eloc, bsize, 0);
 622                 brelse(epos.bh);
 623                 if (err < 0) {
 624                         udf_free_blocks(sb, inode, &eloc, 0, 1);
 625                         goto out_no_entry;
 626                 }
 627
 628                 block = udf_get_pblock(sb, block,
 629                                 iinfo->i_location.partitionReferenceNum,
 630                                 0);
 631                 epos.bh = sb_getblk(sb, block);
 632                 if (unlikely(!epos.bh)) {
 633                         err = -ENOMEM;
 634                         udf_free_blocks(sb, inode, &eloc, 0, 1);
 635                         goto out_no_entry;
 636                 }
 637                 lock_buffer(epos.bh);
 638                 memset(epos.bh->b_data, 0x00, bsize);
 639                 set_buffer_uptodate(epos.bh);
 640                 unlock_buffer(epos.bh);
 641                 mark_buffer_dirty_inode(epos.bh, inode);
 642                 ea = epos.bh->b_data + udf_ext0_offset(inode);
 643         } else
 644                 ea = iinfo->i_data + iinfo->i_lenEAttr;
 645
 646         eoffset = sb->s_blocksize - udf_ext0_offset(inode);
 647         pc = (struct pathComponent *)ea;
 648
 649         if (*symname == '/') {
 650                 do {
 651                         symname++;
 652                 } while (*symname == '/');
 653
 654                 pc->componentType = 1;
 655                 pc->lengthComponentIdent = 0;
 656                 pc->componentFileVersionNum = 0;
 657                 elen += sizeof(struct pathComponent);
 658         }
 659
 660         err = -ENAMETOOLONG;
 661
 662         while (*symname) {
 663                 if (elen + sizeof(struct pathComponent) > eoffset)
 664                         goto out_no_entry;
 665
 666                 pc = (struct pathComponent *)(ea + elen);
 667
 668                 compstart = symname;
 669
 670                 do {
 671                         symname++;
 672                 } while (*symname && *symname != '/');
 673
 674                 pc->componentType = 5;
 675                 pc->lengthComponentIdent = 0;
 676                 pc->componentFileVersionNum = 0;
 677                 if (compstart[0] == '.') {
 678                         if ((symname - compstart) == 1)
 679                                 pc->componentType = 4;
 680                         else if ((symname - compstart) == 2 &&
 681                                         compstart[1] == '.')
 682                                 pc->componentType = 3;
 683                 }
 684
 685                 if (pc->componentType == 5) {
 686                         namelen = udf_put_filename(sb, compstart,
 687                                                    symname - compstart,
 688                                                    name, UDF_NAME_LEN_CS0);
 689                         if (!namelen)
 690                                 goto out_no_entry;
 691
 692                         if (elen + sizeof(struct pathComponent) + namelen >
 693                                         eoffset)
 694                                 goto out_no_entry;
 695                         else
 696                                 pc->lengthComponentIdent = namelen;
 697
 698                         memcpy(pc->componentIdent, name, namelen);
 699                 }
 700
 701                 elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;
 702
 703                 if (*symname) {
 704                         do {
 705                                 symname++;
 706                         } while (*symname == '/');
 707                 }
 708         }
 709
 710         brelse(epos.bh);
 711         inode->i_size = elen;
 712         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
 713                 iinfo->i_lenAlloc = inode->i_size;
 714         else
 715                 udf_truncate_tail_extent(inode);
 716         mark_inode_dirty(inode);
 717         up_write(&iinfo->i_data_sem);
 718
 719         err = udf_add_nondir(dentry, inode);
 720 out:
 721         kfree(name);
 722         return err;
 723
 724 out_no_entry:
 725         up_write(&iinfo->i_data_sem);
 726         inode_dec_link_count(inode);
 727         discard_new_inode(inode);
 728         goto out;
 729 }
 730
 731 static int udf_link(struct dentry *old_dentry, struct inode *dir,
 732                     struct dentry *dentry)
 733 {
 734         struct inode *inode = d_inode(old_dentry);
 735         struct udf_fileident_iter iter;
 736         int err;
 737
 738         err = udf_fiiter_add_entry(dir, dentry, &iter);
 739         if (err)
 740                 return err;
 741         iter.fi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
 742         iter.fi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
 743         if (UDF_SB(inode->i_sb)->s_lvid_bh) {
 744                 *(__le32 *)((struct allocDescImpUse *)iter.fi.icb.impUse)->impUse =
 745                         cpu_to_le32(lvid_get_unique_id(inode->i_sb));
 746         }
 747         udf_fiiter_write_fi(&iter, NULL);
 748         udf_fiiter_release(&iter);
 749
 750         inc_nlink(inode);
 751         udf_add_fid_counter(dir->i_sb, false, 1);
 752         inode_set_ctime_current(inode);
 753         mark_inode_dirty(inode);
 754         inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
 755         mark_inode_dirty(dir);
 756         ihold(inode);
 757         d_instantiate(dentry, inode);
 758
 759         return 0;
 760 }
 761
 762 /* Anybody can rename anything with this: the permission checks are left to the
 763  * higher-level routines.
 764  */
 765 static int udf_rename(struct mnt_idmap *idmap, struct inode *old_dir,
 766                       struct dentry *old_dentry, struct inode *new_dir,
 767                       struct dentry *new_dentry, unsigned int flags)
 768 {
 769         struct inode *old_inode = d_inode(old_dentry);
 770         struct inode *new_inode = d_inode(new_dentry);
 771         struct udf_fileident_iter oiter, niter, diriter;
 772         bool has_diriter = false, is_dir = false;
 773         int retval;
 774         struct kernel_lb_addr tloc;
 775
 776         if (flags & ~RENAME_NOREPLACE)
 777                 return -EINVAL;
 778
 779         retval = udf_fiiter_find_entry(old_dir, &old_dentry->d_name, &oiter);
 780         if (retval)
 781                 return retval;
 782
 783         tloc = lelb_to_cpu(oiter.fi.icb.extLocation);
 784         if (udf_get_lb_pblock(old_dir->i_sb, &tloc, 0) != old_inode->i_ino) {
 785                 retval = -ENOENT;
 786                 goto out_oiter;
 787         }
 788
 789         if (S_ISDIR(old_inode->i_mode)) {
 790                 if (new_inode) {
 791                         retval = -ENOTEMPTY;
 792                         if (!empty_dir(new_inode))
 793                                 goto out_oiter;
 794                         retval = -EFSCORRUPTED;
 795                         if (new_inode->i_nlink != 2)
 796                                 goto out_oiter;
 797                 }
 798                 retval = -EFSCORRUPTED;
 799                 if (old_dir->i_nlink < 3)
 800                         goto out_oiter;
 801                 is_dir = true;
 802         } else if (new_inode) {
 803                 retval = -EFSCORRUPTED;
 804                 if (new_inode->i_nlink < 1)
 805                         goto out_oiter;
 806         }
 807         if (is_dir && old_dir != new_dir) {
 808                 retval = udf_fiiter_find_entry(old_inode, &dotdot_name,
 809                                                &diriter);
 810                 if (retval == -ENOENT) {
 811                         udf_err(old_inode->i_sb,
 812                                 "directory (ino %lu) has no '..' entry\n",
 813                                 old_inode->i_ino);
 814                         retval = -EFSCORRUPTED;
 815                 }
 816                 if (retval)
 817                         goto out_oiter;
 818                 has_diriter = true;
 819                 tloc = lelb_to_cpu(diriter.fi.icb.extLocation);
 820                 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) !=
 821                                 old_dir->i_ino) {
 822                         retval = -EFSCORRUPTED;
 823                         udf_err(old_inode->i_sb,
 824                                 "directory (ino %lu) has parent entry pointing to another inode (%lu != %u)\n",
 825                                 old_inode->i_ino, old_dir->i_ino,
 826                                 udf_get_lb_pblock(old_inode->i_sb, &tloc, 0));
 827                         goto out_oiter;
 828                 }
 829         }
 830
 831         retval = udf_fiiter_find_entry(new_dir, &new_dentry->d_name, &niter);
 832         if (retval && retval != -ENOENT)
 833                 goto out_oiter;
 834         /* Entry found but not passed by VFS? */
 835         if (!retval && !new_inode) {
 836                 retval = -EFSCORRUPTED;
 837                 udf_fiiter_release(&niter);
 838                 goto out_oiter;
 839         }
 840         /* Entry not found? Need to add one... */
 841         if (retval) {
 842                 udf_fiiter_release(&niter);
 843                 retval = udf_fiiter_add_entry(new_dir, new_dentry, &niter);
 844                 if (retval)
 845                         goto out_oiter;
 846         }
 847
 848         /*
 849          * Like most other Unix systems, set the ctime for inodes on a
 850          * rename.
 851          */
 852         inode_set_ctime_current(old_inode);
 853         mark_inode_dirty(old_inode);
 854
 855         /*
 856          * ok, that's it
 857          */
 858         niter.fi.fileVersionNum = oiter.fi.fileVersionNum;
 859         niter.fi.fileCharacteristics = oiter.fi.fileCharacteristics;
 860         memcpy(&(niter.fi.icb), &(oiter.fi.icb), sizeof(oiter.fi.icb));
 861         udf_fiiter_write_fi(&niter, NULL);
 862         udf_fiiter_release(&niter);
 863
 864         /*
 865          * The old entry may have moved due to new entry allocation. Find it
 866          * again.
 867          */
 868         udf_fiiter_release(&oiter);
 869         retval = udf_fiiter_find_entry(old_dir, &old_dentry->d_name, &oiter);
 870         if (retval) {
 871                 udf_err(old_dir->i_sb,
 872                         "failed to find renamed entry again in directory (ino %lu)\n",
 873                         old_dir->i_ino);
 874         } else {
 875                 udf_fiiter_delete_entry(&oiter);
 876                 udf_fiiter_release(&oiter);
 877         }
 878
 879         if (new_inode) {
 880                 inode_set_ctime_current(new_inode);
 881                 inode_dec_link_count(new_inode);
 882                 udf_add_fid_counter(old_dir->i_sb, S_ISDIR(new_inode->i_mode),
 883                                     -1);
 884         }
 885         inode_set_mtime_to_ts(old_dir, inode_set_ctime_current(old_dir));
 886         inode_set_mtime_to_ts(new_dir, inode_set_ctime_current(new_dir));
 887         mark_inode_dirty(old_dir);
 888         mark_inode_dirty(new_dir);
 889
 890         if (has_diriter) {
 891                 diriter.fi.icb.extLocation =
 892                                         cpu_to_lelb(UDF_I(new_dir)->i_location);
 893                 udf_fiiter_write_fi(&diriter, NULL);
 894                 udf_fiiter_release(&diriter);
 895         }
 896
 897         if (is_dir) {
 898                 inode_dec_link_count(old_dir);
 899                 if (new_inode)
 900                         inode_dec_link_count(new_inode);
 901                 else {
 902                         inc_nlink(new_dir);
 903                         mark_inode_dirty(new_dir);
 904                 }
 905         }
 906         return 0;
 907 out_oiter:
 908         if (has_diriter)
 909                 udf_fiiter_release(&diriter);
 910         udf_fiiter_release(&oiter);
 911
 912         return retval;
 913 }
 914
 915 static struct dentry *udf_get_parent(struct dentry *child)
 916 {
 917         struct kernel_lb_addr tloc;
 918         struct udf_fileident_iter iter;
 919         int err;
 920
 921         err = udf_fiiter_find_entry(d_inode(child), &dotdot_name, &iter);
 922         if (err)
 923                 return ERR_PTR(err);
 924
 925         tloc = lelb_to_cpu(iter.fi.icb.extLocation);
 926         udf_fiiter_release(&iter);
 927         return d_obtain_alias(udf_iget(child->d_sb, &tloc));
 928 }
 929
 930
 931 static struct dentry *udf_nfs_get_inode(struct super_block *sb, u32 block,
 932                                         u16 partref, __u32 generation)
 933 {
 934         struct inode *inode;
 935         struct kernel_lb_addr loc;
 936
 937         if (block == 0)
 938                 return ERR_PTR(-ESTALE);
 939
 940         loc.logicalBlockNum = block;
 941         loc.partitionReferenceNum = partref;
 942         inode = udf_iget(sb, &loc);
 943
 944         if (IS_ERR(inode))
 945                 return ERR_CAST(inode);
 946
 947         if (generation && inode->i_generation != generation) {
 948                 iput(inode);
 949                 return ERR_PTR(-ESTALE);
 950         }
 951         return d_obtain_alias(inode);
 952 }
 953
 954 static struct dentry *udf_fh_to_dentry(struct super_block *sb,
 955                                        struct fid *fid, int fh_len, int fh_type)
 956 {
 957         if (fh_len < 3 ||
 958             (fh_type != FILEID_UDF_WITH_PARENT &&
 959              fh_type != FILEID_UDF_WITHOUT_PARENT))
 960                 return NULL;
 961
 962         return udf_nfs_get_inode(sb, fid->udf.block, fid->udf.partref,
 963                         fid->udf.generation);
 964 }
 965
 966 static struct dentry *udf_fh_to_parent(struct super_block *sb,
 967                                        struct fid *fid, int fh_len, int fh_type)
 968 {
 969         if (fh_len < 5 || fh_type != FILEID_UDF_WITH_PARENT)
 970                 return NULL;
 971
 972         return udf_nfs_get_inode(sb, fid->udf.parent_block,
 973                                  fid->udf.parent_partref,
 974                                  fid->udf.parent_generation);
 975 }
 976 static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
 977                          struct inode *parent)
 978 {
 979         int len = *lenp;
 980         struct kernel_lb_addr location = UDF_I(inode)->i_location;
 981         struct fid *fid = (struct fid *)fh;
 982         int type = FILEID_UDF_WITHOUT_PARENT;
 983
 984         if (parent && (len < 5)) {
 985                 *lenp = 5;
 986                 return FILEID_INVALID;
 987         } else if (len < 3) {
 988                 *lenp = 3;
 989                 return FILEID_INVALID;
 990         }
 991
 992         *lenp = 3;
 993         fid->udf.block = location.logicalBlockNum;
 994         fid->udf.partref = location.partitionReferenceNum;
 995         fid->udf.parent_partref = 0;
 996         fid->udf.generation = inode->i_generation;
 997
 998         if (parent) {
 999                 location = UDF_I(parent)->i_location;
1000                 fid->udf.parent_block = location.logicalBlockNum;
1001                 fid->udf.parent_partref = location.partitionReferenceNum;
1002                 fid->udf.parent_generation = inode->i_generation;
1003                 *lenp = 5;
1004                 type = FILEID_UDF_WITH_PARENT;
1005         }
1006
1007         return type;
1008 }
1009
1010 const struct export_operations udf_export_ops = {
1011         .encode_fh      = udf_encode_fh,
1012         .fh_to_dentry   = udf_fh_to_dentry,
1013         .fh_to_parent   = udf_fh_to_parent,
1014         .get_parent     = udf_get_parent,
1015 };
1016
1017 const struct inode_operations udf_dir_inode_operations = {
1018         .lookup                         = udf_lookup,
1019         .create                         = udf_create,
1020         .link                           = udf_link,
1021         .unlink                         = udf_unlink,
1022         .symlink                        = udf_symlink,
1023         .mkdir                          = udf_mkdir,
1024         .rmdir                          = udf_rmdir,
1025         .mknod                          = udf_mknod,
1026         .rename                         = udf_rename,
1027         .tmpfile                        = udf_tmpfile,
1028 };