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 #if (defined(HAVE_USERNS_IOPS_GETATTR) || defined(HAVE_IDMAP_IOPS_GETATTR)) 439 error = -zfs_getattr_fast(user_ns, ip, stat); 440 #else 441 error = -zfs_getattr_fast(kcred->user_ns, ip, stat); 442 #endif 443 444 #ifdef STATX_BTIME 445 if (request_mask & STATX_BTIME) { 446 stat->btime = zp->z_btime; 447 stat->result_mask |= STATX_BTIME; 448 } 449 #endif 450 451 #ifdef STATX_ATTR_IMMUTABLE 452 if (zp->z_pflags & ZFS_IMMUTABLE) 453 stat->attributes |= STATX_ATTR_IMMUTABLE; 454 stat->attributes_mask |= STATX_ATTR_IMMUTABLE; 455 #endif 456 457 #ifdef STATX_ATTR_APPEND 458 if (zp->z_pflags & ZFS_APPENDONLY) 459 stat->attributes |= STATX_ATTR_APPEND; 460 stat->attributes_mask |= STATX_ATTR_APPEND; 461 #endif 462 463 #ifdef STATX_ATTR_NODUMP 464 if (zp->z_pflags & ZFS_NODUMP) 465 stat->attributes |= STATX_ATTR_NODUMP; 466 stat->attributes_mask |= STATX_ATTR_NODUMP; 467 #endif 468 469 spl_fstrans_unmark(cookie); 470 ASSERT3S(error, <=, 0); 471 472 return (error); 473 } 474 ZPL_GETATTR_WRAPPER(zpl_getattr); 475 476 static int 477 #ifdef HAVE_USERNS_IOPS_SETATTR 478 zpl_setattr(struct user_namespace *user_ns, struct dentry *dentry, 479 struct iattr *ia) 480 #elif defined(HAVE_IDMAP_IOPS_SETATTR) 481 zpl_setattr(struct mnt_idmap *user_ns, struct dentry *dentry, 482 struct iattr *ia) 483 #else 484 zpl_setattr(struct dentry *dentry, struct iattr *ia) 485 #endif 486 { 487 struct inode *ip = dentry->d_inode; 488 cred_t *cr = CRED(); 489 vattr_t *vap; 490 int error; 491 fstrans_cookie_t cookie; 492 493 #ifdef HAVE_SETATTR_PREPARE_USERNS 494 error = zpl_setattr_prepare(user_ns, dentry, ia); 495 #elif defined(HAVE_SETATTR_PREPARE_IDMAP) 496 error = zpl_setattr_prepare(user_ns, dentry, ia); 497 #else 498 error = zpl_setattr_prepare(zfs_init_idmap, dentry, ia); 499 #endif 500 if (error) 501 return (error); 502 503 crhold(cr); 504 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP); 505 vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK; 506 vap->va_mode = ia->ia_mode; 507 if (ia->ia_valid & ATTR_UID) 508 #ifdef HAVE_IATTR_VFSID 509 vap->va_uid = zfs_vfsuid_to_uid(user_ns, zfs_i_user_ns(ip), 510 __vfsuid_val(ia->ia_vfsuid)); 511 #else 512 vap->va_uid = KUID_TO_SUID(ia->ia_uid); 513 #endif 514 if (ia->ia_valid & ATTR_GID) 515 #ifdef HAVE_IATTR_VFSID 516 vap->va_gid = zfs_vfsgid_to_gid(user_ns, zfs_i_user_ns(ip), 517 __vfsgid_val(ia->ia_vfsgid)); 518 #else 519 vap->va_gid = KGID_TO_SGID(ia->ia_gid); 520 #endif 521 vap->va_size = ia->ia_size; 522 vap->va_atime = ia->ia_atime; 523 vap->va_mtime = ia->ia_mtime; 524 vap->va_ctime = ia->ia_ctime; 525 526 if (vap->va_mask & ATTR_ATIME) 527 ip->i_atime = zpl_inode_timestamp_truncate(ia->ia_atime, ip); 528 529 cookie = spl_fstrans_mark(); 530 #ifdef HAVE_USERNS_IOPS_SETATTR 531 error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns); 532 #elif defined(HAVE_IDMAP_IOPS_SETATTR) 533 error = -zfs_setattr(ITOZ(ip), vap, 0, cr, user_ns); 534 #else 535 error = -zfs_setattr(ITOZ(ip), vap, 0, cr, zfs_init_idmap); 536 #endif 537 if (!error && (ia->ia_valid & ATTR_MODE)) 538 error = zpl_chmod_acl(ip); 539 540 spl_fstrans_unmark(cookie); 541 kmem_free(vap, sizeof (vattr_t)); 542 crfree(cr); 543 ASSERT3S(error, <=, 0); 544 545 return (error); 546 } 547 548 static int 549 #ifdef HAVE_IOPS_RENAME_USERNS 550 zpl_rename2(struct user_namespace *user_ns, struct inode *sdip, 551 struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry, 552 unsigned int rflags) 553 #elif defined(HAVE_IOPS_RENAME_IDMAP) 554 zpl_rename2(struct mnt_idmap *user_ns, struct inode *sdip, 555 struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry, 556 unsigned int rflags) 557 #else 558 zpl_rename2(struct inode *sdip, struct dentry *sdentry, 559 struct inode *tdip, struct dentry *tdentry, unsigned int rflags) 560 #endif 561 { 562 cred_t *cr = CRED(); 563 vattr_t *wo_vap = NULL; 564 int error; 565 fstrans_cookie_t cookie; 566 #if !(defined(HAVE_IOPS_RENAME_USERNS) || defined(HAVE_IOPS_RENAME_IDMAP)) 567 zidmap_t *user_ns = kcred->user_ns; 568 #endif 569 570 crhold(cr); 571 if (rflags & RENAME_WHITEOUT) { 572 wo_vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP); 573 zpl_vap_init(wo_vap, sdip, S_IFCHR, cr, user_ns); 574 wo_vap->va_rdev = makedevice(0, 0); 575 } 576 577 cookie = spl_fstrans_mark(); 578 error = -zfs_rename(ITOZ(sdip), dname(sdentry), ITOZ(tdip), 579 dname(tdentry), cr, 0, rflags, wo_vap, user_ns); 580 spl_fstrans_unmark(cookie); 581 if (wo_vap) 582 kmem_free(wo_vap, sizeof (vattr_t)); 583 crfree(cr); 584 ASSERT3S(error, <=, 0); 585 586 return (error); 587 } 588 589 #if !defined(HAVE_IOPS_RENAME_USERNS) && \ 590 !defined(HAVE_RENAME_WANTS_FLAGS) && \ 591 !defined(HAVE_RENAME2) && \ 592 !defined(HAVE_IOPS_RENAME_IDMAP) 593 static int 594 zpl_rename(struct inode *sdip, struct dentry *sdentry, 595 struct inode *tdip, struct dentry *tdentry) 596 { 597 return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0)); 598 } 599 #endif 600 601 static int 602 #ifdef HAVE_IOPS_SYMLINK_USERNS 603 zpl_symlink(struct user_namespace *user_ns, struct inode *dir, 604 struct dentry *dentry, const char *name) 605 #elif defined(HAVE_IOPS_SYMLINK_IDMAP) 606 zpl_symlink(struct mnt_idmap *user_ns, struct inode *dir, 607 struct dentry *dentry, const char *name) 608 #else 609 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name) 610 #endif 611 { 612 cred_t *cr = CRED(); 613 vattr_t *vap; 614 znode_t *zp; 615 int error; 616 fstrans_cookie_t cookie; 617 #if !(defined(HAVE_IOPS_SYMLINK_USERNS) || defined(HAVE_IOPS_SYMLINK_IDMAP)) 618 zidmap_t *user_ns = kcred->user_ns; 619 #endif 620 621 crhold(cr); 622 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP); 623 zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr, user_ns); 624 625 cookie = spl_fstrans_mark(); 626 error = -zfs_symlink(ITOZ(dir), dname(dentry), vap, 627 (char *)name, &zp, cr, 0, user_ns); 628 if (error == 0) { 629 error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name); 630 if (error) { 631 (void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0); 632 remove_inode_hash(ZTOI(zp)); 633 iput(ZTOI(zp)); 634 } else { 635 d_instantiate(dentry, ZTOI(zp)); 636 } 637 } 638 639 spl_fstrans_unmark(cookie); 640 kmem_free(vap, sizeof (vattr_t)); 641 crfree(cr); 642 ASSERT3S(error, <=, 0); 643 644 return (error); 645 } 646 647 #if defined(HAVE_PUT_LINK_COOKIE) 648 static void 649 zpl_put_link(struct inode *unused, void *cookie) 650 { 651 kmem_free(cookie, MAXPATHLEN); 652 } 653 #elif defined(HAVE_PUT_LINK_NAMEIDATA) 654 static void 655 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr) 656 { 657 const char *link = nd_get_link(nd); 658 659 if (!IS_ERR(link)) 660 kmem_free(link, MAXPATHLEN); 661 } 662 #elif defined(HAVE_PUT_LINK_DELAYED) 663 static void 664 zpl_put_link(void *ptr) 665 { 666 kmem_free(ptr, MAXPATHLEN); 667 } 668 #endif 669 670 static int 671 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link) 672 { 673 fstrans_cookie_t cookie; 674 cred_t *cr = CRED(); 675 int error; 676 677 crhold(cr); 678 *link = NULL; 679 680 struct iovec iov; 681 iov.iov_len = MAXPATHLEN; 682 iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 683 684 zfs_uio_t uio; 685 zfs_uio_iovec_init(&uio, &iov, 1, 0, UIO_SYSSPACE, MAXPATHLEN - 1, 0); 686 687 cookie = spl_fstrans_mark(); 688 error = -zfs_readlink(ip, &uio, cr); 689 spl_fstrans_unmark(cookie); 690 crfree(cr); 691 692 if (error) 693 kmem_free(iov.iov_base, MAXPATHLEN); 694 else 695 *link = iov.iov_base; 696 697 return (error); 698 } 699 700 #if defined(HAVE_GET_LINK_DELAYED) 701 static const char * 702 zpl_get_link(struct dentry *dentry, struct inode *inode, 703 struct delayed_call *done) 704 { 705 char *link = NULL; 706 int error; 707 708 if (!dentry) 709 return (ERR_PTR(-ECHILD)); 710 711 error = zpl_get_link_common(dentry, inode, &link); 712 if (error) 713 return (ERR_PTR(error)); 714 715 set_delayed_call(done, zpl_put_link, link); 716 717 return (link); 718 } 719 #elif defined(HAVE_GET_LINK_COOKIE) 720 static const char * 721 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie) 722 { 723 char *link = NULL; 724 int error; 725 726 if (!dentry) 727 return (ERR_PTR(-ECHILD)); 728 729 error = zpl_get_link_common(dentry, inode, &link); 730 if (error) 731 return (ERR_PTR(error)); 732 733 return (*cookie = link); 734 } 735 #elif defined(HAVE_FOLLOW_LINK_COOKIE) 736 static const char * 737 zpl_follow_link(struct dentry *dentry, void **cookie) 738 { 739 char *link = NULL; 740 int error; 741 742 error = zpl_get_link_common(dentry, dentry->d_inode, &link); 743 if (error) 744 return (ERR_PTR(error)); 745 746 return (*cookie = link); 747 } 748 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA) 749 static void * 750 zpl_follow_link(struct dentry *dentry, struct nameidata *nd) 751 { 752 char *link = NULL; 753 int error; 754 755 error = zpl_get_link_common(dentry, dentry->d_inode, &link); 756 if (error) 757 nd_set_link(nd, ERR_PTR(error)); 758 else 759 nd_set_link(nd, link); 760 761 return (NULL); 762 } 763 #endif 764 765 static int 766 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 767 { 768 cred_t *cr = CRED(); 769 struct inode *ip = old_dentry->d_inode; 770 int error; 771 fstrans_cookie_t cookie; 772 773 if (ip->i_nlink >= ZFS_LINK_MAX) 774 return (-EMLINK); 775 776 crhold(cr); 777 ip->i_ctime = current_time(ip); 778 /* Must have an existing ref, so igrab() cannot return NULL */ 779 VERIFY3P(igrab(ip), !=, NULL); 780 781 cookie = spl_fstrans_mark(); 782 error = -zfs_link(ITOZ(dir), ITOZ(ip), dname(dentry), cr, 0); 783 if (error) { 784 iput(ip); 785 goto out; 786 } 787 788 d_instantiate(dentry, ip); 789 out: 790 spl_fstrans_unmark(cookie); 791 crfree(cr); 792 ASSERT3S(error, <=, 0); 793 794 return (error); 795 } 796 797 const struct inode_operations zpl_inode_operations = { 798 .setattr = zpl_setattr, 799 .getattr = zpl_getattr, 800 #ifdef HAVE_GENERIC_SETXATTR 801 .setxattr = generic_setxattr, 802 .getxattr = generic_getxattr, 803 .removexattr = generic_removexattr, 804 #endif 805 .listxattr = zpl_xattr_list, 806 #if defined(CONFIG_FS_POSIX_ACL) 807 #if defined(HAVE_SET_ACL) 808 .set_acl = zpl_set_acl, 809 #endif /* HAVE_SET_ACL */ 810 #if defined(HAVE_GET_INODE_ACL) 811 .get_inode_acl = zpl_get_acl, 812 #else 813 .get_acl = zpl_get_acl, 814 #endif /* HAVE_GET_INODE_ACL */ 815 #endif /* CONFIG_FS_POSIX_ACL */ 816 }; 817 818 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER 819 const struct inode_operations_wrapper zpl_dir_inode_operations = { 820 .ops = { 821 #else 822 const struct inode_operations zpl_dir_inode_operations = { 823 #endif 824 .create = zpl_create, 825 .lookup = zpl_lookup, 826 .link = zpl_link, 827 .unlink = zpl_unlink, 828 .symlink = zpl_symlink, 829 .mkdir = zpl_mkdir, 830 .rmdir = zpl_rmdir, 831 .mknod = zpl_mknod, 832 #ifdef HAVE_RENAME2 833 .rename2 = zpl_rename2, 834 #elif defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS) 835 .rename = zpl_rename2, 836 #elif defined(HAVE_IOPS_RENAME_IDMAP) 837 .rename = zpl_rename2, 838 #else 839 .rename = zpl_rename, 840 #endif 841 #ifdef HAVE_TMPFILE 842 .tmpfile = zpl_tmpfile, 843 #endif 844 .setattr = zpl_setattr, 845 .getattr = zpl_getattr, 846 #ifdef HAVE_GENERIC_SETXATTR 847 .setxattr = generic_setxattr, 848 .getxattr = generic_getxattr, 849 .removexattr = generic_removexattr, 850 #endif 851 .listxattr = zpl_xattr_list, 852 #if defined(CONFIG_FS_POSIX_ACL) 853 #if defined(HAVE_SET_ACL) 854 .set_acl = zpl_set_acl, 855 #endif /* HAVE_SET_ACL */ 856 #if defined(HAVE_GET_INODE_ACL) 857 .get_inode_acl = zpl_get_acl, 858 #else 859 .get_acl = zpl_get_acl, 860 #endif /* HAVE_GET_INODE_ACL */ 861 #endif /* CONFIG_FS_POSIX_ACL */ 862 #ifdef HAVE_RENAME2_OPERATIONS_WRAPPER 863 }, 864 .rename2 = zpl_rename2, 865 #endif 866 }; 867 868 const struct inode_operations zpl_symlink_inode_operations = { 869 #ifdef HAVE_GENERIC_READLINK 870 .readlink = generic_readlink, 871 #endif 872 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE) 873 .get_link = zpl_get_link, 874 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA) 875 .follow_link = zpl_follow_link, 876 #endif 877 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA) 878 .put_link = zpl_put_link, 879 #endif 880 .setattr = zpl_setattr, 881 .getattr = zpl_getattr, 882 #ifdef HAVE_GENERIC_SETXATTR 883 .setxattr = generic_setxattr, 884 .getxattr = generic_getxattr, 885 .removexattr = generic_removexattr, 886 #endif 887 .listxattr = zpl_xattr_list, 888 }; 889 890 const struct inode_operations zpl_special_inode_operations = { 891 .setattr = zpl_setattr, 892 .getattr = zpl_getattr, 893 #ifdef HAVE_GENERIC_SETXATTR 894 .setxattr = generic_setxattr, 895 .getxattr = generic_getxattr, 896 .removexattr = generic_removexattr, 897 #endif 898 .listxattr = zpl_xattr_list, 899 #if defined(CONFIG_FS_POSIX_ACL) 900 #if defined(HAVE_SET_ACL) 901 .set_acl = zpl_set_acl, 902 #endif /* HAVE_SET_ACL */ 903 #if defined(HAVE_GET_INODE_ACL) 904 .get_inode_acl = zpl_get_acl, 905 #else 906 .get_acl = zpl_get_acl, 907 #endif /* HAVE_GET_INODE_ACL */ 908 #endif /* CONFIG_FS_POSIX_ACL */ 909 }; 910