fs/ntfs3/namei.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *
   4  * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
   5  *
   6  */
   7
   8 #include <linux/fs.h>
   9 #include <linux/nls.h>
  10 #include <linux/ctype.h>
  11 #include <linux/posix_acl.h>
  12
  13 #include "debug.h"
  14 #include "ntfs.h"
  15 #include "ntfs_fs.h"
  16
  17 /*
  18  * fill_name_de - Format NTFS_DE in @buf.
  19  */
  20 int fill_name_de(struct ntfs_sb_info *sbi, void *buf, const struct qstr *name,
  21                  const struct cpu_str *uni)
  22 {
  23         int err;
  24         struct NTFS_DE *e = buf;
  25         u16 data_size;
  26         struct ATTR_FILE_NAME *fname = (struct ATTR_FILE_NAME *)(e + 1);
  27
  28 #ifndef CONFIG_NTFS3_64BIT_CLUSTER
  29         e->ref.high = fname->home.high = 0;
  30 #endif
  31         if (uni) {
  32 #ifdef __BIG_ENDIAN
  33                 int ulen = uni->len;
  34                 __le16 *uname = fname->name;
  35                 const u16 *name_cpu = uni->name;
  36
  37                 while (ulen--)
  38                         *uname++ = cpu_to_le16(*name_cpu++);
  39 #else
  40                 memcpy(fname->name, uni->name, uni->len * sizeof(u16));
  41 #endif
  42                 fname->name_len = uni->len;
  43
  44         } else {
  45                 /* Convert input string to unicode. */
  46                 err = ntfs_nls_to_utf16(sbi, name->name, name->len,
  47                                         (struct cpu_str *)&fname->name_len,
  48                                         NTFS_NAME_LEN, UTF16_LITTLE_ENDIAN);
  49                 if (err < 0)
  50                         return err;
  51         }
  52
  53         fname->type = FILE_NAME_POSIX;
  54         data_size = fname_full_size(fname);
  55
  56         e->size = cpu_to_le16(ALIGN(data_size, 8) + sizeof(struct NTFS_DE));
  57         e->key_size = cpu_to_le16(data_size);
  58         e->flags = 0;
  59         e->res = 0;
  60
  61         return 0;
  62 }
  63
  64 /*
  65  * ntfs_lookup - inode_operations::lookup
  66  */
  67 static struct dentry *ntfs_lookup(struct inode *dir, struct dentry *dentry,
  68                                   u32 flags)
  69 {
  70         struct ntfs_inode *ni = ntfs_i(dir);
  71         struct cpu_str *uni = __getname();
  72         struct inode *inode;
  73         int err;
  74
  75         if (!uni)
  76                 inode = ERR_PTR(-ENOMEM);
  77         else {
  78                 err = ntfs_nls_to_utf16(ni->mi.sbi, dentry->d_name.name,
  79                                         dentry->d_name.len, uni, NTFS_NAME_LEN,
  80                                         UTF16_HOST_ENDIAN);
  81                 if (err < 0)
  82                         inode = ERR_PTR(err);
  83                 else {
  84                         ni_lock_dir(ni);
  85                         inode = dir_search_u(dir, uni, NULL);
  86                         ni_unlock(ni);
  87                 }
  88                 __putname(uni);
  89         }
  90
  91         /*
  92          * Check for a null pointer
  93          * If the MFT record of ntfs inode is not a base record, inode->i_op can be NULL.
  94          * This causes null pointer dereference in d_splice_alias().
  95          */
  96         if (!IS_ERR_OR_NULL(inode) && !inode->i_op) {
  97                 iput(inode);
  98                 inode = ERR_PTR(-EINVAL);
  99         }
 100
 101         return d_splice_alias(inode, dentry);
 102 }
 103
 104 /*
 105  * ntfs_create - inode_operations::create
 106  */
 107 static int ntfs_create(struct mnt_idmap *idmap, struct inode *dir,
 108                        struct dentry *dentry, umode_t mode, bool excl)
 109 {
 110         return ntfs_create_inode(idmap, dir, dentry, NULL, S_IFREG | mode, 0,
 111                                  NULL, 0, NULL);
 112 }
 113
 114 /*
 115  * ntfs_mknod - inode_operations::mknod
 116  */
 117 static int ntfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
 118                       struct dentry *dentry, umode_t mode, dev_t rdev)
 119 {
 120         return ntfs_create_inode(idmap, dir, dentry, NULL, mode, rdev, NULL, 0,
 121                                  NULL);
 122 }
 123
 124 /*
 125  * ntfs_link - inode_operations::link
 126  */
 127 static int ntfs_link(struct dentry *ode, struct inode *dir, struct dentry *de)
 128 {
 129         int err;
 130         struct inode *inode = d_inode(ode);
 131         struct ntfs_inode *ni = ntfs_i(inode);
 132
 133         if (S_ISDIR(inode->i_mode))
 134                 return -EPERM;
 135
 136         if (inode->i_nlink >= NTFS_LINK_MAX)
 137                 return -EMLINK;
 138
 139         ni_lock_dir(ntfs_i(dir));
 140         if (inode != dir)
 141                 ni_lock(ni);
 142
 143         inc_nlink(inode);
 144         ihold(inode);
 145
 146         err = ntfs_link_inode(inode, de);
 147
 148         if (!err) {
 149                 inode_set_ctime_current(inode);
 150                 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
 151                 mark_inode_dirty(inode);
 152                 mark_inode_dirty(dir);
 153                 d_instantiate(de, inode);
 154         } else {
 155                 drop_nlink(inode);
 156                 iput(inode);
 157         }
 158
 159         if (inode != dir)
 160                 ni_unlock(ni);
 161         ni_unlock(ntfs_i(dir));
 162
 163         return err;
 164 }
 165
 166 /*
 167  * ntfs_unlink - inode_operations::unlink
 168  */
 169 static int ntfs_unlink(struct inode *dir, struct dentry *dentry)
 170 {
 171         struct ntfs_inode *ni = ntfs_i(dir);
 172         int err;
 173
 174         if (unlikely(ntfs3_forced_shutdown(dir->i_sb)))
 175                 return -EIO;
 176
 177         ni_lock_dir(ni);
 178
 179         err = ntfs_unlink_inode(dir, dentry);
 180
 181         ni_unlock(ni);
 182
 183         return err;
 184 }
 185
 186 /*
 187  * ntfs_symlink - inode_operations::symlink
 188  */
 189 static int ntfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
 190                         struct dentry *dentry, const char *symname)
 191 {
 192         u32 size = strlen(symname);
 193
 194         if (unlikely(ntfs3_forced_shutdown(dir->i_sb)))
 195                 return -EIO;
 196
 197         return ntfs_create_inode(idmap, dir, dentry, NULL, S_IFLNK | 0777, 0,
 198                                  symname, size, NULL);
 199 }
 200
 201 /*
 202  * ntfs_mkdir- inode_operations::mkdir
 203  */
 204 static int ntfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
 205                       struct dentry *dentry, umode_t mode)
 206 {
 207         return ntfs_create_inode(idmap, dir, dentry, NULL, S_IFDIR | mode, 0,
 208                                  NULL, 0, NULL);
 209 }
 210
 211 /*
 212  * ntfs_rmdir - inode_operations::rmdir
 213  */
 214 static int ntfs_rmdir(struct inode *dir, struct dentry *dentry)
 215 {
 216         struct ntfs_inode *ni = ntfs_i(dir);
 217         int err;
 218
 219         if (unlikely(ntfs3_forced_shutdown(dir->i_sb)))
 220                 return -EIO;
 221
 222         ni_lock_dir(ni);
 223
 224         err = ntfs_unlink_inode(dir, dentry);
 225
 226         ni_unlock(ni);
 227
 228         return err;
 229 }
 230
 231 /*
 232  * ntfs_rename - inode_operations::rename
 233  */
 234 static int ntfs_rename(struct mnt_idmap *idmap, struct inode *dir,
 235                        struct dentry *dentry, struct inode *new_dir,
 236                        struct dentry *new_dentry, u32 flags)
 237 {
 238         int err;
 239         struct super_block *sb = dir->i_sb;
 240         struct ntfs_sb_info *sbi = sb->s_fs_info;
 241         struct ntfs_inode *dir_ni = ntfs_i(dir);
 242         struct ntfs_inode *new_dir_ni = ntfs_i(new_dir);
 243         struct inode *inode = d_inode(dentry);
 244         struct ntfs_inode *ni = ntfs_i(inode);
 245         struct inode *new_inode = d_inode(new_dentry);
 246         struct NTFS_DE *de, *new_de;
 247         bool is_same, is_bad;
 248         /*
 249          * de           - memory of PATH_MAX bytes:
 250          * [0-1024)     - original name (dentry->d_name)
 251          * [1024-2048)  - paired to original name, usually DOS variant of dentry->d_name
 252          * [2048-3072)  - new name (new_dentry->d_name)
 253          */
 254         static_assert(SIZEOF_ATTRIBUTE_FILENAME_MAX + SIZEOF_RESIDENT < 1024);
 255         static_assert(SIZEOF_ATTRIBUTE_FILENAME_MAX + sizeof(struct NTFS_DE) <
 256                       1024);
 257         static_assert(PATH_MAX >= 4 * 1024);
 258
 259         if (unlikely(ntfs3_forced_shutdown(sb)))
 260                 return -EIO;
 261
 262         if (flags & ~RENAME_NOREPLACE)
 263                 return -EINVAL;
 264
 265         is_same = dentry->d_name.len == new_dentry->d_name.len &&
 266                   !memcmp(dentry->d_name.name, new_dentry->d_name.name,
 267                           dentry->d_name.len);
 268
 269         if (is_same && dir == new_dir) {
 270                 /* Nothing to do. */
 271                 return 0;
 272         }
 273
 274         if (ntfs_is_meta_file(sbi, inode->i_ino)) {
 275                 /* Should we print an error? */
 276                 return -EINVAL;
 277         }
 278
 279         if (new_inode) {
 280                 /* Target name exists. Unlink it. */
 281                 dget(new_dentry);
 282                 ni_lock_dir(new_dir_ni);
 283                 err = ntfs_unlink_inode(new_dir, new_dentry);
 284                 ni_unlock(new_dir_ni);
 285                 dput(new_dentry);
 286                 if (err)
 287                         return err;
 288         }
 289
 290         /* Allocate PATH_MAX bytes. */
 291         de = __getname();
 292         if (!de)
 293                 return -ENOMEM;
 294
 295         /* Translate dentry->d_name into unicode form. */
 296         err = fill_name_de(sbi, de, &dentry->d_name, NULL);
 297         if (err < 0)
 298                 goto out;
 299
 300         if (is_same) {
 301                 /* Reuse 'de'. */
 302                 new_de = de;
 303         } else {
 304                 /* Translate new_dentry->d_name into unicode form. */
 305                 new_de = Add2Ptr(de, 2048);
 306                 err = fill_name_de(sbi, new_de, &new_dentry->d_name, NULL);
 307                 if (err < 0)
 308                         goto out;
 309         }
 310
 311         ni_lock_dir(dir_ni);
 312         ni_lock(ni);
 313         if (dir_ni != new_dir_ni)
 314                 ni_lock_dir2(new_dir_ni);
 315
 316         is_bad = false;
 317         err = ni_rename(dir_ni, new_dir_ni, ni, de, new_de, &is_bad);
 318         if (is_bad) {
 319                 /* Restore after failed rename failed too. */
 320                 _ntfs_bad_inode(inode);
 321         } else if (!err) {
 322                 simple_rename_timestamp(dir, dentry, new_dir, new_dentry);
 323                 mark_inode_dirty(inode);
 324                 mark_inode_dirty(dir);
 325                 if (dir != new_dir)
 326                         mark_inode_dirty(new_dir);
 327
 328                 if (IS_DIRSYNC(dir))
 329                         ntfs_sync_inode(dir);
 330
 331                 if (IS_DIRSYNC(new_dir))
 332                         ntfs_sync_inode(inode);
 333         }
 334
 335         if (dir_ni != new_dir_ni)
 336                 ni_unlock(new_dir_ni);
 337         ni_unlock(ni);
 338         ni_unlock(dir_ni);
 339 out:
 340         __putname(de);
 341         return err;
 342 }
 343
 344 struct dentry *ntfs3_get_parent(struct dentry *child)
 345 {
 346         struct inode *inode = d_inode(child);
 347         struct ntfs_inode *ni = ntfs_i(inode);
 348
 349         struct ATTR_LIST_ENTRY *le = NULL;
 350         struct ATTRIB *attr = NULL;
 351         struct ATTR_FILE_NAME *fname;
 352
 353         while ((attr = ni_find_attr(ni, attr, &le, ATTR_NAME, NULL, 0, NULL,
 354                                     NULL))) {
 355                 fname = resident_data_ex(attr, SIZEOF_ATTRIBUTE_FILENAME);
 356                 if (!fname)
 357                         continue;
 358
 359                 return d_obtain_alias(
 360                         ntfs_iget5(inode->i_sb, &fname->home, NULL));
 361         }
 362
 363         return ERR_PTR(-ENOENT);
 364 }
 365
 366 /*
 367  * dentry_operations::d_hash
 368  */
 369 static int ntfs_d_hash(const struct dentry *dentry, struct qstr *name)
 370 {
 371         struct ntfs_sb_info *sbi;
 372         const char *n = name->name;
 373         unsigned int len = name->len;
 374         unsigned long hash;
 375         struct cpu_str *uni;
 376         unsigned int c;
 377         int err;
 378
 379         /* First try fast implementation. */
 380         hash = init_name_hash(dentry);
 381
 382         for (;;) {
 383                 if (!len--) {
 384                         name->hash = end_name_hash(hash);
 385                         return 0;
 386                 }
 387
 388                 c = *n++;
 389                 if (c >= 0x80)
 390                         break;
 391
 392                 hash = partial_name_hash(toupper(c), hash);
 393         }
 394
 395         /*
 396          * Try slow way with current upcase table
 397          */
 398         uni = kmem_cache_alloc(names_cachep, GFP_NOWAIT);
 399         if (!uni)
 400                 return -ENOMEM;
 401
 402         sbi = dentry->d_sb->s_fs_info;
 403
 404         err = ntfs_nls_to_utf16(sbi, name->name, name->len, uni, NTFS_NAME_LEN,
 405                                 UTF16_HOST_ENDIAN);
 406         if (err < 0)
 407                 goto out;
 408
 409         if (!err) {
 410                 err = -EINVAL;
 411                 goto out;
 412         }
 413
 414         hash = ntfs_names_hash(uni->name, uni->len, sbi->upcase,
 415                                init_name_hash(dentry));
 416         name->hash = end_name_hash(hash);
 417         err = 0;
 418
 419 out:
 420         kmem_cache_free(names_cachep, uni);
 421         return err;
 422 }
 423
 424 /*
 425  * dentry_operations::d_compare
 426  */
 427 static int ntfs_d_compare(const struct dentry *dentry, unsigned int len1,
 428                           const char *str, const struct qstr *name)
 429 {
 430         struct ntfs_sb_info *sbi;
 431         int ret;
 432         const char *n1 = str;
 433         const char *n2 = name->name;
 434         unsigned int len2 = name->len;
 435         unsigned int lm = min(len1, len2);
 436         unsigned char c1, c2;
 437         struct cpu_str *uni1;
 438         struct le_str *uni2;
 439
 440         /* First try fast implementation. */
 441         for (;;) {
 442                 if (!lm--)
 443                         return len1 != len2;
 444
 445                 if ((c1 = *n1++) == (c2 = *n2++))
 446                         continue;
 447
 448                 if (c1 >= 0x80 || c2 >= 0x80)
 449                         break;
 450
 451                 if (toupper(c1) != toupper(c2))
 452                         return 1;
 453         }
 454
 455         /*
 456          * Try slow way with current upcase table
 457          */
 458         sbi = dentry->d_sb->s_fs_info;
 459         uni1 = __getname();
 460         if (!uni1)
 461                 return -ENOMEM;
 462
 463         ret = ntfs_nls_to_utf16(sbi, str, len1, uni1, NTFS_NAME_LEN,
 464                                 UTF16_HOST_ENDIAN);
 465         if (ret < 0)
 466                 goto out;
 467
 468         if (!ret) {
 469                 ret = -EINVAL;
 470                 goto out;
 471         }
 472
 473         uni2 = Add2Ptr(uni1, 2048);
 474
 475         ret = ntfs_nls_to_utf16(sbi, name->name, name->len,
 476                                 (struct cpu_str *)uni2, NTFS_NAME_LEN,
 477                                 UTF16_LITTLE_ENDIAN);
 478         if (ret < 0)
 479                 goto out;
 480
 481         if (!ret) {
 482                 ret = -EINVAL;
 483                 goto out;
 484         }
 485
 486         ret = !ntfs_cmp_names_cpu(uni1, uni2, sbi->upcase, false) ? 0 : 1;
 487
 488 out:
 489         __putname(uni1);
 490         return ret;
 491 }
 492
 493 // clang-format off
 494 const struct inode_operations ntfs_dir_inode_operations = {
 495         .lookup         = ntfs_lookup,
 496         .create         = ntfs_create,
 497         .link           = ntfs_link,
 498         .unlink         = ntfs_unlink,
 499         .symlink        = ntfs_symlink,
 500         .mkdir          = ntfs_mkdir,
 501         .rmdir          = ntfs_rmdir,
 502         .mknod          = ntfs_mknod,
 503         .rename         = ntfs_rename,
 504         .get_acl        = ntfs_get_acl,
 505         .set_acl        = ntfs_set_acl,
 506         .setattr        = ntfs_setattr,
 507         .getattr        = ntfs_getattr,
 508         .listxattr      = ntfs_listxattr,
 509         .fiemap         = ntfs_fiemap,
 510         .fileattr_get   = ntfs_fileattr_get,
 511         .fileattr_set   = ntfs_fileattr_set,
 512 };
 513
 514 const struct inode_operations ntfs_special_inode_operations = {
 515         .setattr        = ntfs_setattr,
 516         .getattr        = ntfs_getattr,
 517         .listxattr      = ntfs_listxattr,
 518         .get_acl        = ntfs_get_acl,
 519         .set_acl        = ntfs_set_acl,
 520 };
 521
 522 const struct dentry_operations ntfs_dentry_ops = {
 523         .d_hash         = ntfs_d_hash,
 524         .d_compare      = ntfs_d_compare,
 525 };
 526
 527 // clang-format on