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 }; 912