module/os/linux/zfs/zpl_inode.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or https://opensource.org/licenses/CDDL-1.0.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
  23  * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
  24  */
  25
  26
  27 #include <sys/sysmacros.h>
  28 #include <sys/zfs_ctldir.h>
  29 #include <sys/zfs_vfsops.h>
  30 #include <sys/zfs_vnops.h>
  31 #include <sys/zfs_znode.h>
  32 #include <sys/dmu_objset.h>
  33 #include <sys/vfs.h>
  34 #include <sys/zpl.h>
  35 #include <sys/file.h>
  36
  37 static struct dentry *
  38 zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
  39 {
  40         cred_t *cr = CRED();
  41         struct inode *ip;
  42         znode_t *zp;
  43         int error;
  44         fstrans_cookie_t cookie;
  45         pathname_t *ppn = NULL;
  46         pathname_t pn;
  47         int zfs_flags = 0;
  48         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
  49
  50         if (dlen(dentry) >= ZAP_MAXNAMELEN)
  51                 return (ERR_PTR(-ENAMETOOLONG));
  52
  53         crhold(cr);
  54         cookie = spl_fstrans_mark();
  55
  56         /* If we are a case insensitive fs, we need the real name */
  57         if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
  58                 zfs_flags = FIGNORECASE;
  59                 pn_alloc(&pn);
  60                 ppn = &pn;
  61         }
  62
  63         error = -zfs_lookup(ITOZ(dir), dname(dentry), &zp,
  64             zfs_flags, cr, NULL, ppn);
  65         spl_fstrans_unmark(cookie);
  66         ASSERT3S(error, <=, 0);
  67         crfree(cr);
  68
  69         spin_lock(&dentry->d_lock);
  70         dentry->d_time = jiffies;
  71         spin_unlock(&dentry->d_lock);
  72
  73         if (error) {
  74                 /*
  75                  * If we have a case sensitive fs, we do not want to
  76                  * insert negative entries, so return NULL for ENOENT.
  77                  * Fall through if the error is not ENOENT. Also free memory.
  78                  */
  79                 if (ppn) {
  80                         pn_free(ppn);
  81                         if (error == -ENOENT)
  82                                 return (NULL);
  83                 }
  84
  85                 if (error == -ENOENT)
  86                         return (d_splice_alias(NULL, dentry));
  87                 else
  88                         return (ERR_PTR(error));
  89         }
  90         ip = ZTOI(zp);
  91
  92         /*
  93          * If we are case insensitive, call the correct function
  94          * to install the name.
  95          */
  96         if (ppn) {
  97                 struct dentry *new_dentry;
  98                 struct qstr ci_name;
  99
 100                 if (strcmp(dname(dentry), pn.pn_buf) == 0) {
 101                         new_dentry = d_splice_alias(ip,  dentry);
 102                 } else {
 103                         ci_name.name = pn.pn_buf;
 104                         ci_name.len = strlen(pn.pn_buf);
 105                         new_dentry = d_add_ci(dentry, ip, &ci_name);
 106                 }
 107                 pn_free(ppn);
 108                 return (new_dentry);
 109         } else {
 110                 return (d_splice_alias(ip, dentry));
 111         }
 112 }
 113
 114 void
 115 zpl_vap_init(vattr_t *vap, struct inode *dir, umode_t mode, cred_t *cr,
 116     zidmap_t *mnt_ns)
 117 {
 118         vap->va_mask = ATTR_MODE;
 119         vap->va_mode = mode;
 120
 121         vap->va_uid = zfs_vfsuid_to_uid(mnt_ns,
 122             zfs_i_user_ns(dir), crgetuid(cr));
 123
 124         if (dir->i_mode & S_ISGID) {
 125                 vap->va_gid = KGID_TO_SGID(dir->i_gid);
 126                 if (S_ISDIR(mode))
 127                         vap->va_mode |= S_ISGID;
 128         } else {
 129                 vap->va_gid = zfs_vfsgid_to_gid(mnt_ns,
 130                     zfs_i_user_ns(dir), crgetgid(cr));
 131         }
 132 }
 133
 134 static int
 135 #ifdef HAVE_IOPS_CREATE_USERNS
 136 zpl_create(struct user_namespace *user_ns, struct inode *dir,
 137     struct dentry *dentry, umode_t mode, bool flag)
 138 #elif defined(HAVE_IOPS_CREATE_IDMAP)
 139 zpl_create(struct mnt_idmap *user_ns, struct inode *dir,
 140     struct dentry *dentry, umode_t mode, bool flag)
 141 #else
 142 zpl_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool flag)
 143 #endif
 144 {
 145         cred_t *cr = CRED();
 146         znode_t *zp;
 147         vattr_t *vap;
 148         int error;
 149         fstrans_cookie_t cookie;
 150 #if !(defined(HAVE_IOPS_CREATE_USERNS) || defined(HAVE_IOPS_CREATE_IDMAP))
 151         zidmap_t *user_ns = kcred->user_ns;
 152 #endif
 153
 154         crhold(cr);
 155         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 156         zpl_vap_init(vap, dir, mode, cr, user_ns);
 157
 158         cookie = spl_fstrans_mark();
 159         error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
 160             mode, &zp, cr, 0, NULL, user_ns);
 161         if (error == 0) {
 162                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 163                 if (error == 0)
 164                         error = zpl_init_acl(ZTOI(zp), dir);
 165
 166                 if (error) {
 167                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 168                         remove_inode_hash(ZTOI(zp));
 169                         iput(ZTOI(zp));
 170                 } else {
 171                         d_instantiate(dentry, ZTOI(zp));
 172                 }
 173         }
 174
 175         spl_fstrans_unmark(cookie);
 176         kmem_free(vap, sizeof (vattr_t));
 177         crfree(cr);
 178         ASSERT3S(error, <=, 0);
 179
 180         return (error);
 181 }
 182
 183 static int
 184 #ifdef HAVE_IOPS_MKNOD_USERNS
 185 zpl_mknod(struct user_namespace *user_ns, struct inode *dir,
 186     struct dentry *dentry, umode_t mode,
 187 #elif defined(HAVE_IOPS_MKNOD_IDMAP)
 188 zpl_mknod(struct mnt_idmap *user_ns, struct inode *dir,
 189     struct dentry *dentry, umode_t mode,
 190 #else
 191 zpl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 192 #endif
 193     dev_t rdev)
 194 {
 195         cred_t *cr = CRED();
 196         znode_t *zp;
 197         vattr_t *vap;
 198         int error;
 199         fstrans_cookie_t cookie;
 200 #if !(defined(HAVE_IOPS_MKNOD_USERNS) || defined(HAVE_IOPS_MKNOD_IDMAP))
 201         zidmap_t *user_ns = kcred->user_ns;
 202 #endif
 203
 204         /*
 205          * We currently expect Linux to supply rdev=0 for all sockets
 206          * and fifos, but we want to know if this behavior ever changes.
 207          */
 208         if (S_ISSOCK(mode) || S_ISFIFO(mode))
 209                 ASSERT(rdev == 0);
 210
 211         crhold(cr);
 212         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 213         zpl_vap_init(vap, dir, mode, cr, user_ns);
 214         vap->va_rdev = rdev;
 215
 216         cookie = spl_fstrans_mark();
 217         error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
 218             mode, &zp, cr, 0, NULL, user_ns);
 219         if (error == 0) {
 220                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 221                 if (error == 0)
 222                         error = zpl_init_acl(ZTOI(zp), dir);
 223
 224                 if (error) {
 225                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 226                         remove_inode_hash(ZTOI(zp));
 227                         iput(ZTOI(zp));
 228                 } else {
 229                         d_instantiate(dentry, ZTOI(zp));
 230                 }
 231         }
 232
 233         spl_fstrans_unmark(cookie);
 234         kmem_free(vap, sizeof (vattr_t));
 235         crfree(cr);
 236         ASSERT3S(error, <=, 0);
 237
 238         return (error);
 239 }
 240
 241 #ifdef HAVE_TMPFILE
 242 static int
 243 #ifdef HAVE_TMPFILE_IDMAP
 244 zpl_tmpfile(struct mnt_idmap *userns, struct inode *dir,
 245     struct file *file, umode_t mode)
 246 #elif !defined(HAVE_TMPFILE_DENTRY)
 247 zpl_tmpfile(struct user_namespace *userns, struct inode *dir,
 248     struct file *file, umode_t mode)
 249 #else
 250 #ifdef HAVE_TMPFILE_USERNS
 251 zpl_tmpfile(struct user_namespace *userns, struct inode *dir,
 252     struct dentry *dentry, umode_t mode)
 253 #else
 254 zpl_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
 255 #endif
 256 #endif
 257 {
 258         cred_t *cr = CRED();
 259         struct inode *ip;
 260         vattr_t *vap;
 261         int error;
 262         fstrans_cookie_t cookie;
 263 #if !(defined(HAVE_TMPFILE_USERNS) || defined(HAVE_TMPFILE_IDMAP))
 264         zidmap_t *userns = kcred->user_ns;
 265 #endif
 266
 267         crhold(cr);
 268         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 269         /*
 270          * The VFS does not apply the umask, therefore it is applied here
 271          * when POSIX ACLs are not enabled.
 272          */
 273         if (!IS_POSIXACL(dir))
 274                 mode &= ~current_umask();
 275         zpl_vap_init(vap, dir, mode, cr, userns);
 276
 277         cookie = spl_fstrans_mark();
 278         error = -zfs_tmpfile(dir, vap, 0, mode, &ip, cr, 0, NULL, userns);
 279         if (error == 0) {
 280                 /* d_tmpfile will do drop_nlink, so we should set it first */
 281                 set_nlink(ip, 1);
 282 #ifndef HAVE_TMPFILE_DENTRY
 283                 d_tmpfile(file, ip);
 284
 285                 error = zpl_xattr_security_init(ip, dir,
 286                     &file->f_path.dentry->d_name);
 287 #else
 288                 d_tmpfile(dentry, ip);
 289
 290                 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
 291 #endif
 292                 if (error == 0)
 293                         error = zpl_init_acl(ip, dir);
 294 #ifndef HAVE_TMPFILE_DENTRY
 295                 error = finish_open_simple(file, error);
 296 #endif
 297                 /*
 298                  * don't need to handle error here, file is already in
 299                  * unlinked set.
 300                  */
 301         }
 302
 303         spl_fstrans_unmark(cookie);
 304         kmem_free(vap, sizeof (vattr_t));
 305         crfree(cr);
 306         ASSERT3S(error, <=, 0);
 307
 308         return (error);
 309 }
 310 #endif
 311
 312 static int
 313 zpl_unlink(struct inode *dir, struct dentry *dentry)
 314 {
 315         cred_t *cr = CRED();
 316         int error;
 317         fstrans_cookie_t cookie;
 318         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 319
 320         crhold(cr);
 321         cookie = spl_fstrans_mark();
 322         error = -zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 323
 324         /*
 325          * For a CI FS we must invalidate the dentry to prevent the
 326          * creation of negative entries.
 327          */
 328         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 329                 d_invalidate(dentry);
 330
 331         spl_fstrans_unmark(cookie);
 332         crfree(cr);
 333         ASSERT3S(error, <=, 0);
 334
 335         return (error);
 336 }
 337
 338 static int
 339 #ifdef HAVE_IOPS_MKDIR_USERNS
 340 zpl_mkdir(struct user_namespace *user_ns, struct inode *dir,
 341     struct dentry *dentry, umode_t mode)
 342 #elif defined(HAVE_IOPS_MKDIR_IDMAP)
 343 zpl_mkdir(struct mnt_idmap *user_ns, struct inode *dir,
 344     struct dentry *dentry, umode_t mode)
 345 #else
 346 zpl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 347 #endif
 348 {
 349         cred_t *cr = CRED();
 350         vattr_t *vap;
 351         znode_t *zp;
 352         int error;
 353         fstrans_cookie_t cookie;
 354 #if !(defined(HAVE_IOPS_MKDIR_USERNS) || defined(HAVE_IOPS_MKDIR_IDMAP))
 355         zidmap_t *user_ns = kcred->user_ns;
 356 #endif
 357
 358         crhold(cr);
 359         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 360         zpl_vap_init(vap, dir, mode | S_IFDIR, cr, user_ns);
 361
 362         cookie = spl_fstrans_mark();
 363         error = -zfs_mkdir(ITOZ(dir), dname(dentry), vap, &zp, cr, 0, NULL,
 364             user_ns);
 365         if (error == 0) {
 366                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 367                 if (error == 0)
 368                         error = zpl_init_acl(ZTOI(zp), dir);
 369
 370                 if (error) {
 371                         (void) zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);
 372                         remove_inode_hash(ZTOI(zp));
 373                         iput(ZTOI(zp));
 374                 } else {
 375                         d_instantiate(dentry, ZTOI(zp));
 376                 }
 377         }
 378
 379         spl_fstrans_unmark(cookie);
 380         kmem_free(vap, sizeof (vattr_t));
 381         crfree(cr);
 382         ASSERT3S(error, <=, 0);
 383
 384         return (error);
 385 }
 386
 387 static int
 388 zpl_rmdir(struct inode *dir, struct dentry *dentry)
 389 {
 390         cred_t *cr = CRED();
 391         int error;
 392         fstrans_cookie_t cookie;
 393         zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
 394
 395         crhold(cr);
 396         cookie = spl_fstrans_mark();
 397         error = -zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);
 398
 399         /*
 400          * For a CI FS we must invalidate the dentry to prevent the
 401          * creation of negative entries.
 402          */
 403         if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
 404                 d_invalidate(dentry);
 405
 406         spl_fstrans_unmark(cookie);
 407         crfree(cr);
 408         ASSERT3S(error, <=, 0);
 409
 410         return (error);
 411 }
 412
 413 static int
 414 #ifdef HAVE_USERNS_IOPS_GETATTR
 415 zpl_getattr_impl(struct user_namespace *user_ns,
 416     const struct path *path, struct kstat *stat, u32 request_mask,
 417     unsigned int query_flags)
 418 #elif defined(HAVE_IDMAP_IOPS_GETATTR)
 419 zpl_getattr_impl(struct mnt_idmap *user_ns,
 420     const struct path *path, struct kstat *stat, u32 request_mask,
 421     unsigned int query_flags)
 422 #else
 423 zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
 424     unsigned int query_flags)
 425 #endif
 426 {
 427         int error;
 428         fstrans_cookie_t cookie;
 429         struct inode *ip = path->dentry->d_inode;
 430         znode_t *zp __maybe_unused = ITOZ(ip);
 431
 432         cookie = spl_fstrans_mark();
 433
 434         /*
 435          * XXX query_flags currently ignored.
 436          */
 437
 438 #ifdef HAVE_GENERIC_FILLATTR_IDMAP_REQMASK
 439         error = -zfs_getattr_fast(user_ns, request_mask, ip, stat);
 440 #elif (defined(HAVE_USERNS_IOPS_GETATTR) || defined(HAVE_IDMAP_IOPS_GETATTR))
 441         error = -zfs_getattr_fast(user_ns, ip, stat);
 442 #else
 443         error = -zfs_getattr_fast(kcred->user_ns, ip, stat);
 444 #endif
 445
 446 #ifdef STATX_BTIME
 447         if (request_mask & STATX_BTIME) {
 448                 stat->btime = zp->z_btime;
 449                 stat->result_mask |= STATX_BTIME;
 450         }
 451 #endif
 452
 453 #ifdef STATX_ATTR_IMMUTABLE
 454         if (zp->z_pflags & ZFS_IMMUTABLE)
 455                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 456         stat->attributes_mask |= STATX_ATTR_IMMUTABLE;
 457 #endif
 458
 459 #ifdef STATX_ATTR_APPEND
 460         if (zp->z_pflags & ZFS_APPENDONLY)
 461                 stat->attributes |= STATX_ATTR_APPEND;
 462         stat->attributes_mask |= STATX_ATTR_APPEND;
 463 #endif
 464
 465 #ifdef STATX_ATTR_NODUMP
 466         if (zp->z_pflags & ZFS_NODUMP)
 467                 stat->attributes |= STATX_ATTR_NODUMP;
 468         stat->attributes_mask |= STATX_ATTR_NODUMP;
 469 #endif
 470
 471         spl_fstrans_unmark(cookie);
 472         ASSERT3S(error, <=, 0);
 473
 474         return (error);
 475 }
 476 ZPL_GETATTR_WRAPPER(zpl_getattr);
 477
 478 static int
 479 #ifdef HAVE_USERNS_IOPS_SETATTR
 480 zpl_setattr(struct user_namespace *user_ns, struct dentry *dentry,
 481     struct iattr *ia)
 482 #elif defined(HAVE_IDMAP_IOPS_SETATTR)
 483 zpl_setattr(struct mnt_idmap *user_ns, struct dentry *dentry,
 484     struct iattr *ia)
 485 #else
 486 zpl_setattr(struct dentry *dentry, struct iattr *ia)
 487 #endif
 488 {
 489         struct inode *ip = dentry->d_inode;
 490         cred_t *cr = CRED();
 491         vattr_t *vap;
 492         int error;
 493         fstrans_cookie_t cookie;
 494
 495 #ifdef HAVE_SETATTR_PREPARE_USERNS
 496         error = zpl_setattr_prepare(user_ns, dentry, ia);
 497 #elif defined(HAVE_SETATTR_PREPARE_IDMAP)
 498         error = zpl_setattr_prepare(user_ns, dentry, ia);
 499 #else
 500         error = zpl_setattr_prepare(zfs_init_idmap, dentry, ia);
 501 #endif
 502         if (error)
 503                 return (error);
 504
 505         crhold(cr);
 506         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 507         vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
 508         vap->va_mode = ia->ia_mode;
 509         if (ia->ia_valid & ATTR_UID)
 510 #ifdef HAVE_IATTR_VFSID
 511                 vap->va_uid = zfs_vfsuid_to_uid(user_ns, zfs_i_user_ns(ip),
 512                     __vfsuid_val(ia->ia_vfsuid));
 513 #else
 514                 vap->va_uid = KUID_TO_SUID(ia->ia_uid);
 515 #endif
 516         if (ia->ia_valid & ATTR_GID)
 517 #ifdef HAVE_IATTR_VFSID
 518                 vap->va_gid = zfs_vfsgid_to_gid(user_ns, zfs_i_user_ns(ip),
 519                     __vfsgid_val(ia->ia_vfsgid));
 520 #else
 521                 vap->va_gid = KGID_TO_SGID(ia->ia_gid);
 522 #endif
 523         vap->va_size = ia->ia_size;
 524         vap->va_atime = ia->ia_atime;
 525         vap->va_mtime = ia->ia_mtime;
 526         vap->va_ctime = ia->ia_ctime;
 527
 528         if (vap->va_mask & ATTR_ATIME)
 529                 ip->i_atime = zpl_inode_timestamp_truncate(ia->ia_atime, ip);
 530
 531         cookie = spl_fstrans_mark();
 532 #ifdef HAVE_USERNS_IOPS_SETATTR
 533         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns);
 534 #elif defined(HAVE_IDMAP_IOPS_SETATTR)
 535         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns);
 536 #else
 537         error = -zfs_setattr(ITOZ(ip), vap, 0, cr, zfs_init_idmap);
 538 #endif
 539         if (!error && (ia->ia_valid & ATTR_MODE))
 540                 error = zpl_chmod_acl(ip);
 541
 542         spl_fstrans_unmark(cookie);
 543         kmem_free(vap, sizeof (vattr_t));
 544         crfree(cr);
 545         ASSERT3S(error, <=, 0);
 546
 547         return (error);
 548 }
 549
 550 static int
 551 #ifdef HAVE_IOPS_RENAME_USERNS
 552 zpl_rename2(struct user_namespace *user_ns, struct inode *sdip,
 553     struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 554     unsigned int rflags)
 555 #elif defined(HAVE_IOPS_RENAME_IDMAP)
 556 zpl_rename2(struct mnt_idmap *user_ns, struct inode *sdip,
 557     struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 558     unsigned int rflags)
 559 #else
 560 zpl_rename2(struct inode *sdip, struct dentry *sdentry,
 561     struct inode *tdip, struct dentry *tdentry, unsigned int rflags)
 562 #endif
 563 {
 564         cred_t *cr = CRED();
 565         vattr_t *wo_vap = NULL;
 566         int error;
 567         fstrans_cookie_t cookie;
 568 #if !(defined(HAVE_IOPS_RENAME_USERNS) || defined(HAVE_IOPS_RENAME_IDMAP))
 569         zidmap_t *user_ns = kcred->user_ns;
 570 #endif
 571
 572         crhold(cr);
 573         if (rflags & RENAME_WHITEOUT) {
 574                 wo_vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 575                 zpl_vap_init(wo_vap, sdip, S_IFCHR, cr, user_ns);
 576                 wo_vap->va_rdev = makedevice(0, 0);
 577         }
 578
 579         cookie = spl_fstrans_mark();
 580         error = -zfs_rename(ITOZ(sdip), dname(sdentry), ITOZ(tdip),
 581             dname(tdentry), cr, 0, rflags, wo_vap, user_ns);
 582         spl_fstrans_unmark(cookie);
 583         if (wo_vap)
 584                 kmem_free(wo_vap, sizeof (vattr_t));
 585         crfree(cr);
 586         ASSERT3S(error, <=, 0);
 587
 588         return (error);
 589 }
 590
 591 #if !defined(HAVE_IOPS_RENAME_USERNS) && \
 592         !defined(HAVE_RENAME_WANTS_FLAGS) && \
 593         !defined(HAVE_RENAME2) && \
 594         !defined(HAVE_IOPS_RENAME_IDMAP)
 595 static int
 596 zpl_rename(struct inode *sdip, struct dentry *sdentry,
 597     struct inode *tdip, struct dentry *tdentry)
 598 {
 599         return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
 600 }
 601 #endif
 602
 603 static int
 604 #ifdef HAVE_IOPS_SYMLINK_USERNS
 605 zpl_symlink(struct user_namespace *user_ns, struct inode *dir,
 606     struct dentry *dentry, const char *name)
 607 #elif defined(HAVE_IOPS_SYMLINK_IDMAP)
 608 zpl_symlink(struct mnt_idmap *user_ns, struct inode *dir,
 609     struct dentry *dentry, const char *name)
 610 #else
 611 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
 612 #endif
 613 {
 614         cred_t *cr = CRED();
 615         vattr_t *vap;
 616         znode_t *zp;
 617         int error;
 618         fstrans_cookie_t cookie;
 619 #if !(defined(HAVE_IOPS_SYMLINK_USERNS) || defined(HAVE_IOPS_SYMLINK_IDMAP))
 620         zidmap_t *user_ns = kcred->user_ns;
 621 #endif
 622
 623         crhold(cr);
 624         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 625         zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr, user_ns);
 626
 627         cookie = spl_fstrans_mark();
 628         error = -zfs_symlink(ITOZ(dir), dname(dentry), vap,
 629             (char *)name, &zp, cr, 0, user_ns);
 630         if (error == 0) {
 631                 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
 632                 if (error) {
 633                         (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
 634                         remove_inode_hash(ZTOI(zp));
 635                         iput(ZTOI(zp));
 636                 } else {
 637                         d_instantiate(dentry, ZTOI(zp));
 638                 }
 639         }
 640
 641         spl_fstrans_unmark(cookie);
 642         kmem_free(vap, sizeof (vattr_t));
 643         crfree(cr);
 644         ASSERT3S(error, <=, 0);
 645
 646         return (error);
 647 }
 648
 649 #if defined(HAVE_PUT_LINK_COOKIE)
 650 static void
 651 zpl_put_link(struct inode *unused, void *cookie)
 652 {
 653         kmem_free(cookie, MAXPATHLEN);
 654 }
 655 #elif defined(HAVE_PUT_LINK_NAMEIDATA)
 656 static void
 657 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
 658 {
 659         const char *link = nd_get_link(nd);
 660
 661         if (!IS_ERR(link))
 662                 kmem_free(link, MAXPATHLEN);
 663 }
 664 #elif defined(HAVE_PUT_LINK_DELAYED)
 665 static void
 666 zpl_put_link(void *ptr)
 667 {
 668         kmem_free(ptr, MAXPATHLEN);
 669 }
 670 #endif
 671
 672 static int
 673 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link)
 674 {
 675         fstrans_cookie_t cookie;
 676         cred_t *cr = CRED();
 677         int error;
 678
 679         crhold(cr);
 680         *link = NULL;
 681
 682         struct iovec iov;
 683         iov.iov_len = MAXPATHLEN;
 684         iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
 685
 686         zfs_uio_t uio;
 687         zfs_uio_iovec_init(&uio, &iov, 1, 0, UIO_SYSSPACE, MAXPATHLEN - 1, 0);
 688
 689         cookie = spl_fstrans_mark();
 690         error = -zfs_readlink(ip, &uio, cr);
 691         spl_fstrans_unmark(cookie);
 692         crfree(cr);
 693
 694         if (error)
 695                 kmem_free(iov.iov_base, MAXPATHLEN);
 696         else
 697                 *link = iov.iov_base;
 698
 699         return (error);
 700 }
 701
 702 #if defined(HAVE_GET_LINK_DELAYED)
 703 static const char *
 704 zpl_get_link(struct dentry *dentry, struct inode *inode,
 705     struct delayed_call *done)
 706 {
 707         char *link = NULL;
 708         int error;
 709
 710         if (!dentry)
 711                 return (ERR_PTR(-ECHILD));
 712
 713         error = zpl_get_link_common(dentry, inode, &link);
 714         if (error)
 715                 return (ERR_PTR(error));
 716
 717         set_delayed_call(done, zpl_put_link, link);
 718
 719         return (link);
 720 }
 721 #elif defined(HAVE_GET_LINK_COOKIE)
 722 static const char *
 723 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie)
 724 {
 725         char *link = NULL;
 726         int error;
 727
 728         if (!dentry)
 729                 return (ERR_PTR(-ECHILD));
 730
 731         error = zpl_get_link_common(dentry, inode, &link);
 732         if (error)
 733                 return (ERR_PTR(error));
 734
 735         return (*cookie = link);
 736 }
 737 #elif defined(HAVE_FOLLOW_LINK_COOKIE)
 738 static const char *
 739 zpl_follow_link(struct dentry *dentry, void **cookie)
 740 {
 741         char *link = NULL;
 742         int error;
 743
 744         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 745         if (error)
 746                 return (ERR_PTR(error));
 747
 748         return (*cookie = link);
 749 }
 750 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 751 static void *
 752 zpl_follow_link(struct dentry *dentry, struct nameidata *nd)
 753 {
 754         char *link = NULL;
 755         int error;
 756
 757         error = zpl_get_link_common(dentry, dentry->d_inode, &link);
 758         if (error)
 759                 nd_set_link(nd, ERR_PTR(error));
 760         else
 761                 nd_set_link(nd, link);
 762
 763         return (NULL);
 764 }
 765 #endif
 766
 767 static int
 768 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 769 {
 770         cred_t *cr = CRED();
 771         struct inode *ip = old_dentry->d_inode;
 772         int error;
 773         fstrans_cookie_t cookie;
 774
 775         if (ip->i_nlink >= ZFS_LINK_MAX)
 776                 return (-EMLINK);
 777
 778         crhold(cr);
 779         zpl_inode_set_ctime_to_ts(ip, current_time(ip));
 780         /* Must have an existing ref, so igrab() cannot return NULL */
 781         VERIFY3P(igrab(ip), !=, NULL);
 782
 783         cookie = spl_fstrans_mark();
 784         error = -zfs_link(ITOZ(dir), ITOZ(ip), dname(dentry), cr, 0);
 785         if (error) {
 786                 iput(ip);
 787                 goto out;
 788         }
 789
 790         d_instantiate(dentry, ip);
 791 out:
 792         spl_fstrans_unmark(cookie);
 793         crfree(cr);
 794         ASSERT3S(error, <=, 0);
 795
 796         return (error);
 797 }
 798
 799 const struct inode_operations zpl_inode_operations = {
 800         .setattr        = zpl_setattr,
 801         .getattr        = zpl_getattr,
 802 #ifdef HAVE_GENERIC_SETXATTR
 803         .setxattr       = generic_setxattr,
 804         .getxattr       = generic_getxattr,
 805         .removexattr    = generic_removexattr,
 806 #endif
 807         .listxattr      = zpl_xattr_list,
 808 #if defined(CONFIG_FS_POSIX_ACL)
 809 #if defined(HAVE_SET_ACL)
 810         .set_acl        = zpl_set_acl,
 811 #endif /* HAVE_SET_ACL */
 812 #if defined(HAVE_GET_INODE_ACL)
 813         .get_inode_acl  = zpl_get_acl,
 814 #else
 815         .get_acl        = zpl_get_acl,
 816 #endif /* HAVE_GET_INODE_ACL */
 817 #endif /* CONFIG_FS_POSIX_ACL */
 818 };
 819
 820 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER
 821 const struct inode_operations_wrapper zpl_dir_inode_operations = {
 822         .ops = {
 823 #else
 824 const struct inode_operations zpl_dir_inode_operations = {
 825 #endif
 826         .create         = zpl_create,
 827         .lookup         = zpl_lookup,
 828         .link           = zpl_link,
 829         .unlink         = zpl_unlink,
 830         .symlink        = zpl_symlink,
 831         .mkdir          = zpl_mkdir,
 832         .rmdir          = zpl_rmdir,
 833         .mknod          = zpl_mknod,
 834 #ifdef HAVE_RENAME2
 835         .rename2        = zpl_rename2,
 836 #elif defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS)
 837         .rename         = zpl_rename2,
 838 #elif defined(HAVE_IOPS_RENAME_IDMAP)
 839         .rename         = zpl_rename2,
 840 #else
 841         .rename         = zpl_rename,
 842 #endif
 843 #ifdef HAVE_TMPFILE
 844         .tmpfile        = zpl_tmpfile,
 845 #endif
 846         .setattr        = zpl_setattr,
 847         .getattr        = zpl_getattr,
 848 #ifdef HAVE_GENERIC_SETXATTR
 849         .setxattr       = generic_setxattr,
 850         .getxattr       = generic_getxattr,
 851         .removexattr    = generic_removexattr,
 852 #endif
 853         .listxattr      = zpl_xattr_list,
 854 #if defined(CONFIG_FS_POSIX_ACL)
 855 #if defined(HAVE_SET_ACL)
 856         .set_acl        = zpl_set_acl,
 857 #endif /* HAVE_SET_ACL */
 858 #if defined(HAVE_GET_INODE_ACL)
 859         .get_inode_acl  = zpl_get_acl,
 860 #else
 861         .get_acl        = zpl_get_acl,
 862 #endif /* HAVE_GET_INODE_ACL */
 863 #endif /* CONFIG_FS_POSIX_ACL */
 864 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER
 865         },
 866         .rename2        = zpl_rename2,
 867 #endif
 868 };
 869
 870 const struct inode_operations zpl_symlink_inode_operations = {
 871 #ifdef HAVE_GENERIC_READLINK
 872         .readlink       = generic_readlink,
 873 #endif
 874 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE)
 875         .get_link       = zpl_get_link,
 876 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA)
 877         .follow_link    = zpl_follow_link,
 878 #endif
 879 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA)
 880         .put_link       = zpl_put_link,
 881 #endif
 882         .setattr        = zpl_setattr,
 883         .getattr        = zpl_getattr,
 884 #ifdef HAVE_GENERIC_SETXATTR
 885         .setxattr       = generic_setxattr,
 886         .getxattr       = generic_getxattr,
 887         .removexattr    = generic_removexattr,
 888 #endif
 889         .listxattr      = zpl_xattr_list,
 890 };
 891
 892 const struct inode_operations zpl_special_inode_operations = {
 893         .setattr        = zpl_setattr,
 894         .getattr        = zpl_getattr,
 895 #ifdef HAVE_GENERIC_SETXATTR
 896         .setxattr       = generic_setxattr,
 897         .getxattr       = generic_getxattr,
 898         .removexattr    = generic_removexattr,
 899 #endif
 900         .listxattr      = zpl_xattr_list,
 901 #if defined(CONFIG_FS_POSIX_ACL)
 902 #if defined(HAVE_SET_ACL)
 903         .set_acl        = zpl_set_acl,
 904 #endif /* HAVE_SET_ACL */
 905 #if defined(HAVE_GET_INODE_ACL)
 906         .get_inode_acl  = zpl_get_acl,
 907 #else
 908         .get_acl        = zpl_get_acl,
 909 #endif /* HAVE_GET_INODE_ACL */
 910 #endif /* CONFIG_FS_POSIX_ACL */
 911 };