1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> 4 * Copyright (C) 2018 Samsung Electronics Co., Ltd. 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/fs.h> 9 #include <linux/filelock.h> 10 #include <linux/uaccess.h> 11 #include <linux/backing-dev.h> 12 #include <linux/writeback.h> 13 #include <linux/xattr.h> 14 #include <linux/falloc.h> 15 #include <linux/fsnotify.h> 16 #include <linux/dcache.h> 17 #include <linux/slab.h> 18 #include <linux/vmalloc.h> 19 #include <linux/sched/xacct.h> 20 #include <linux/crc32c.h> 21 #include <linux/namei.h> 22 23 #include "glob.h" 24 #include "oplock.h" 25 #include "connection.h" 26 #include "vfs.h" 27 #include "vfs_cache.h" 28 #include "smbacl.h" 29 #include "ndr.h" 30 #include "auth.h" 31 #include "misc.h" 32 33 #include "smb_common.h" 34 #include "mgmt/share_config.h" 35 #include "mgmt/tree_connect.h" 36 #include "mgmt/user_session.h" 37 #include "mgmt/user_config.h" 38 39 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work, 40 struct inode *parent_inode, 41 struct inode *inode) 42 { 43 if (!test_share_config_flag(work->tcon->share_conf, 44 KSMBD_SHARE_FLAG_INHERIT_OWNER)) 45 return; 46 47 i_uid_write(inode, i_uid_read(parent_inode)); 48 } 49 50 /** 51 * ksmbd_vfs_lock_parent() - lock parent dentry if it is stable 52 * @parent: parent dentry 53 * @child: child dentry 54 * 55 * Returns: %0 on success, %-ENOENT if the parent dentry is not stable 56 */ 57 int ksmbd_vfs_lock_parent(struct dentry *parent, struct dentry *child) 58 { 59 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); 60 if (child->d_parent != parent) { 61 inode_unlock(d_inode(parent)); 62 return -ENOENT; 63 } 64 65 return 0; 66 } 67 68 static int ksmbd_vfs_path_lookup_locked(struct ksmbd_share_config *share_conf, 69 char *pathname, unsigned int flags, 70 struct path *parent_path, 71 struct path *path) 72 { 73 struct qstr last; 74 struct filename *filename; 75 struct path *root_share_path = &share_conf->vfs_path; 76 int err, type; 77 struct dentry *d; 78 79 if (pathname[0] == '\0') { 80 pathname = share_conf->path; 81 root_share_path = NULL; 82 } else { 83 flags |= LOOKUP_BENEATH; 84 } 85 86 filename = getname_kernel(pathname); 87 if (IS_ERR(filename)) 88 return PTR_ERR(filename); 89 90 err = vfs_path_parent_lookup(filename, flags, 91 parent_path, &last, &type, 92 root_share_path); 93 if (err) { 94 putname(filename); 95 return err; 96 } 97 98 if (unlikely(type != LAST_NORM)) { 99 path_put(parent_path); 100 putname(filename); 101 return -ENOENT; 102 } 103 104 err = mnt_want_write(parent_path->mnt); 105 if (err) { 106 path_put(parent_path); 107 putname(filename); 108 return -ENOENT; 109 } 110 111 inode_lock_nested(parent_path->dentry->d_inode, I_MUTEX_PARENT); 112 d = lookup_one_qstr_excl(&last, parent_path->dentry, 0); 113 if (IS_ERR(d)) 114 goto err_out; 115 116 if (d_is_negative(d)) { 117 dput(d); 118 goto err_out; 119 } 120 121 path->dentry = d; 122 path->mnt = mntget(parent_path->mnt); 123 124 if (test_share_config_flag(share_conf, KSMBD_SHARE_FLAG_CROSSMNT)) { 125 err = follow_down(path, 0); 126 if (err < 0) { 127 path_put(path); 128 goto err_out; 129 } 130 } 131 132 putname(filename); 133 return 0; 134 135 err_out: 136 inode_unlock(d_inode(parent_path->dentry)); 137 mnt_drop_write(parent_path->mnt); 138 path_put(parent_path); 139 putname(filename); 140 return -ENOENT; 141 } 142 143 void ksmbd_vfs_query_maximal_access(struct mnt_idmap *idmap, 144 struct dentry *dentry, __le32 *daccess) 145 { 146 *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL); 147 148 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_WRITE)) 149 *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE | 150 FILE_WRITE_DATA | FILE_APPEND_DATA | 151 FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES | 152 FILE_DELETE_CHILD); 153 154 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_READ)) 155 *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE; 156 157 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_EXEC)) 158 *daccess |= FILE_EXECUTE_LE; 159 160 if (!inode_permission(idmap, d_inode(dentry->d_parent), MAY_EXEC | MAY_WRITE)) 161 *daccess |= FILE_DELETE_LE; 162 } 163 164 /** 165 * ksmbd_vfs_create() - vfs helper for smb create file 166 * @work: work 167 * @name: file name that is relative to share 168 * @mode: file create mode 169 * 170 * Return: 0 on success, otherwise error 171 */ 172 int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode) 173 { 174 struct path path; 175 struct dentry *dentry; 176 int err; 177 178 dentry = ksmbd_vfs_kern_path_create(work, name, 179 LOOKUP_NO_SYMLINKS, &path); 180 if (IS_ERR(dentry)) { 181 err = PTR_ERR(dentry); 182 if (err != -ENOENT) 183 pr_err("path create failed for %s, err %d\n", 184 name, err); 185 return err; 186 } 187 188 mode |= S_IFREG; 189 err = vfs_create(mnt_idmap(path.mnt), d_inode(path.dentry), 190 dentry, mode, true); 191 if (!err) { 192 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), 193 d_inode(dentry)); 194 } else { 195 pr_err("File(%s): creation failed (err:%d)\n", name, err); 196 } 197 198 done_path_create(&path, dentry); 199 return err; 200 } 201 202 /** 203 * ksmbd_vfs_mkdir() - vfs helper for smb create directory 204 * @work: work 205 * @name: directory name that is relative to share 206 * @mode: directory create mode 207 * 208 * Return: 0 on success, otherwise error 209 */ 210 int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode) 211 { 212 struct mnt_idmap *idmap; 213 struct path path; 214 struct dentry *dentry; 215 int err; 216 217 dentry = ksmbd_vfs_kern_path_create(work, name, 218 LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY, 219 &path); 220 if (IS_ERR(dentry)) { 221 err = PTR_ERR(dentry); 222 if (err != -EEXIST) 223 ksmbd_debug(VFS, "path create failed for %s, err %d\n", 224 name, err); 225 return err; 226 } 227 228 idmap = mnt_idmap(path.mnt); 229 mode |= S_IFDIR; 230 err = vfs_mkdir(idmap, d_inode(path.dentry), dentry, mode); 231 if (!err && d_unhashed(dentry)) { 232 struct dentry *d; 233 234 d = lookup_one(idmap, dentry->d_name.name, dentry->d_parent, 235 dentry->d_name.len); 236 if (IS_ERR(d)) { 237 err = PTR_ERR(d); 238 goto out_err; 239 } 240 if (unlikely(d_is_negative(d))) { 241 dput(d); 242 err = -ENOENT; 243 goto out_err; 244 } 245 246 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(d)); 247 dput(d); 248 } 249 250 out_err: 251 done_path_create(&path, dentry); 252 if (err) 253 pr_err("mkdir(%s): creation failed (err:%d)\n", name, err); 254 return err; 255 } 256 257 static ssize_t ksmbd_vfs_getcasexattr(struct mnt_idmap *idmap, 258 struct dentry *dentry, char *attr_name, 259 int attr_name_len, char **attr_value) 260 { 261 char *name, *xattr_list = NULL; 262 ssize_t value_len = -ENOENT, xattr_list_len; 263 264 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 265 if (xattr_list_len <= 0) 266 goto out; 267 268 for (name = xattr_list; name - xattr_list < xattr_list_len; 269 name += strlen(name) + 1) { 270 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); 271 if (strncasecmp(attr_name, name, attr_name_len)) 272 continue; 273 274 value_len = ksmbd_vfs_getxattr(idmap, 275 dentry, 276 name, 277 attr_value); 278 if (value_len < 0) 279 pr_err("failed to get xattr in file\n"); 280 break; 281 } 282 283 out: 284 kvfree(xattr_list); 285 return value_len; 286 } 287 288 static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos, 289 size_t count) 290 { 291 ssize_t v_len; 292 char *stream_buf = NULL; 293 294 ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n", 295 *pos, count); 296 297 v_len = ksmbd_vfs_getcasexattr(file_mnt_idmap(fp->filp), 298 fp->filp->f_path.dentry, 299 fp->stream.name, 300 fp->stream.size, 301 &stream_buf); 302 if ((int)v_len <= 0) 303 return (int)v_len; 304 305 if (v_len <= *pos) { 306 count = -EINVAL; 307 goto free_buf; 308 } 309 310 if (v_len - *pos < count) 311 count = v_len - *pos; 312 313 memcpy(buf, &stream_buf[*pos], count); 314 315 free_buf: 316 kvfree(stream_buf); 317 return count; 318 } 319 320 /** 321 * check_lock_range() - vfs helper for smb byte range file locking 322 * @filp: the file to apply the lock to 323 * @start: lock start byte offset 324 * @end: lock end byte offset 325 * @type: byte range type read/write 326 * 327 * Return: 0 on success, otherwise error 328 */ 329 static int check_lock_range(struct file *filp, loff_t start, loff_t end, 330 unsigned char type) 331 { 332 struct file_lock *flock; 333 struct file_lock_context *ctx = locks_inode_context(file_inode(filp)); 334 int error = 0; 335 336 if (!ctx || list_empty_careful(&ctx->flc_posix)) 337 return 0; 338 339 spin_lock(&ctx->flc_lock); 340 for_each_file_lock(flock, &ctx->flc_posix) { 341 /* check conflict locks */ 342 if (flock->fl_end >= start && end >= flock->fl_start) { 343 if (lock_is_read(flock)) { 344 if (type == WRITE) { 345 pr_err("not allow write by shared lock\n"); 346 error = 1; 347 goto out; 348 } 349 } else if (lock_is_write(flock)) { 350 /* check owner in lock */ 351 if (flock->c.flc_file != filp) { 352 error = 1; 353 pr_err("not allow rw access by exclusive lock from other opens\n"); 354 goto out; 355 } 356 } 357 } 358 } 359 out: 360 spin_unlock(&ctx->flc_lock); 361 return error; 362 } 363 364 /** 365 * ksmbd_vfs_read() - vfs helper for smb file read 366 * @work: smb work 367 * @fp: ksmbd file pointer 368 * @count: read byte count 369 * @pos: file pos 370 * @rbuf: read data buffer 371 * 372 * Return: number of read bytes on success, otherwise error 373 */ 374 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count, 375 loff_t *pos, char *rbuf) 376 { 377 struct file *filp = fp->filp; 378 ssize_t nbytes = 0; 379 struct inode *inode = file_inode(filp); 380 381 if (S_ISDIR(inode->i_mode)) 382 return -EISDIR; 383 384 if (unlikely(count == 0)) 385 return 0; 386 387 if (work->conn->connection_type) { 388 if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 389 pr_err("no right to read(%pD)\n", fp->filp); 390 return -EACCES; 391 } 392 } 393 394 if (ksmbd_stream_fd(fp)) 395 return ksmbd_vfs_stream_read(fp, rbuf, pos, count); 396 397 if (!work->tcon->posix_extensions) { 398 int ret; 399 400 ret = check_lock_range(filp, *pos, *pos + count - 1, READ); 401 if (ret) { 402 pr_err("unable to read due to lock\n"); 403 return -EAGAIN; 404 } 405 } 406 407 nbytes = kernel_read(filp, rbuf, count, pos); 408 if (nbytes < 0) { 409 pr_err("smb read failed, err = %zd\n", nbytes); 410 return nbytes; 411 } 412 413 filp->f_pos = *pos; 414 return nbytes; 415 } 416 417 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos, 418 size_t count) 419 { 420 char *stream_buf = NULL, *wbuf; 421 struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 422 size_t size; 423 ssize_t v_len; 424 int err = 0; 425 426 ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n", 427 *pos, count); 428 429 size = *pos + count; 430 if (size > XATTR_SIZE_MAX) { 431 size = XATTR_SIZE_MAX; 432 count = (*pos + count) - XATTR_SIZE_MAX; 433 } 434 435 v_len = ksmbd_vfs_getcasexattr(idmap, 436 fp->filp->f_path.dentry, 437 fp->stream.name, 438 fp->stream.size, 439 &stream_buf); 440 if (v_len < 0) { 441 pr_err("not found stream in xattr : %zd\n", v_len); 442 err = v_len; 443 goto out; 444 } 445 446 if (v_len < size) { 447 wbuf = kvzalloc(size, GFP_KERNEL); 448 if (!wbuf) { 449 err = -ENOMEM; 450 goto out; 451 } 452 453 if (v_len > 0) 454 memcpy(wbuf, stream_buf, v_len); 455 kvfree(stream_buf); 456 stream_buf = wbuf; 457 } 458 459 memcpy(&stream_buf[*pos], buf, count); 460 461 err = ksmbd_vfs_setxattr(idmap, 462 &fp->filp->f_path, 463 fp->stream.name, 464 (void *)stream_buf, 465 size, 466 0, 467 true); 468 if (err < 0) 469 goto out; 470 471 fp->filp->f_pos = *pos; 472 err = 0; 473 out: 474 kvfree(stream_buf); 475 return err; 476 } 477 478 /** 479 * ksmbd_vfs_write() - vfs helper for smb file write 480 * @work: work 481 * @fp: ksmbd file pointer 482 * @buf: buf containing data for writing 483 * @count: read byte count 484 * @pos: file pos 485 * @sync: fsync after write 486 * @written: number of bytes written 487 * 488 * Return: 0 on success, otherwise error 489 */ 490 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp, 491 char *buf, size_t count, loff_t *pos, bool sync, 492 ssize_t *written) 493 { 494 struct file *filp; 495 loff_t offset = *pos; 496 int err = 0; 497 498 if (work->conn->connection_type) { 499 if (!(fp->daccess & FILE_WRITE_DATA_LE)) { 500 pr_err("no right to write(%pD)\n", fp->filp); 501 err = -EACCES; 502 goto out; 503 } 504 } 505 506 filp = fp->filp; 507 508 if (ksmbd_stream_fd(fp)) { 509 err = ksmbd_vfs_stream_write(fp, buf, pos, count); 510 if (!err) 511 *written = count; 512 goto out; 513 } 514 515 if (!work->tcon->posix_extensions) { 516 err = check_lock_range(filp, *pos, *pos + count - 1, WRITE); 517 if (err) { 518 pr_err("unable to write due to lock\n"); 519 err = -EAGAIN; 520 goto out; 521 } 522 } 523 524 /* Reserve lease break for parent dir at closing time */ 525 fp->reserve_lease_break = true; 526 527 /* Do we need to break any of a levelII oplock? */ 528 smb_break_all_levII_oplock(work, fp, 1); 529 530 err = kernel_write(filp, buf, count, pos); 531 if (err < 0) { 532 ksmbd_debug(VFS, "smb write failed, err = %d\n", err); 533 goto out; 534 } 535 536 filp->f_pos = *pos; 537 *written = err; 538 err = 0; 539 if (sync) { 540 err = vfs_fsync_range(filp, offset, offset + *written, 0); 541 if (err < 0) 542 pr_err("fsync failed for filename = %pD, err = %d\n", 543 fp->filp, err); 544 } 545 546 out: 547 return err; 548 } 549 550 /** 551 * ksmbd_vfs_getattr() - vfs helper for smb getattr 552 * @path: path of dentry 553 * @stat: pointer to returned kernel stat structure 554 * Return: 0 on success, otherwise error 555 */ 556 int ksmbd_vfs_getattr(const struct path *path, struct kstat *stat) 557 { 558 int err; 559 560 err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT); 561 if (err) 562 pr_err("getattr failed, err %d\n", err); 563 return err; 564 } 565 566 /** 567 * ksmbd_vfs_fsync() - vfs helper for smb fsync 568 * @work: work 569 * @fid: file id of open file 570 * @p_id: persistent file id 571 * 572 * Return: 0 on success, otherwise error 573 */ 574 int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id) 575 { 576 struct ksmbd_file *fp; 577 int err; 578 579 fp = ksmbd_lookup_fd_slow(work, fid, p_id); 580 if (!fp) { 581 pr_err("failed to get filp for fid %llu\n", fid); 582 return -ENOENT; 583 } 584 err = vfs_fsync(fp->filp, 0); 585 if (err < 0) 586 pr_err("smb fsync failed, err = %d\n", err); 587 ksmbd_fd_put(work, fp); 588 return err; 589 } 590 591 /** 592 * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink 593 * @work: work 594 * @path: path of dentry 595 * 596 * Return: 0 on success, otherwise error 597 */ 598 int ksmbd_vfs_remove_file(struct ksmbd_work *work, const struct path *path) 599 { 600 struct mnt_idmap *idmap; 601 struct dentry *parent = path->dentry->d_parent; 602 int err; 603 604 if (ksmbd_override_fsids(work)) 605 return -ENOMEM; 606 607 if (!d_inode(path->dentry)->i_nlink) { 608 err = -ENOENT; 609 goto out_err; 610 } 611 612 idmap = mnt_idmap(path->mnt); 613 if (S_ISDIR(d_inode(path->dentry)->i_mode)) { 614 err = vfs_rmdir(idmap, d_inode(parent), path->dentry); 615 if (err && err != -ENOTEMPTY) 616 ksmbd_debug(VFS, "rmdir failed, err %d\n", err); 617 } else { 618 err = vfs_unlink(idmap, d_inode(parent), path->dentry, NULL); 619 if (err) 620 ksmbd_debug(VFS, "unlink failed, err %d\n", err); 621 } 622 623 out_err: 624 ksmbd_revert_fsids(work); 625 return err; 626 } 627 628 /** 629 * ksmbd_vfs_link() - vfs helper for creating smb hardlink 630 * @work: work 631 * @oldname: source file name 632 * @newname: hardlink name that is relative to share 633 * 634 * Return: 0 on success, otherwise error 635 */ 636 int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname, 637 const char *newname) 638 { 639 struct path oldpath, newpath; 640 struct dentry *dentry; 641 int err; 642 643 if (ksmbd_override_fsids(work)) 644 return -ENOMEM; 645 646 err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath); 647 if (err) { 648 pr_err("cannot get linux path for %s, err = %d\n", 649 oldname, err); 650 goto out1; 651 } 652 653 dentry = ksmbd_vfs_kern_path_create(work, newname, 654 LOOKUP_NO_SYMLINKS | LOOKUP_REVAL, 655 &newpath); 656 if (IS_ERR(dentry)) { 657 err = PTR_ERR(dentry); 658 pr_err("path create err for %s, err %d\n", newname, err); 659 goto out2; 660 } 661 662 err = -EXDEV; 663 if (oldpath.mnt != newpath.mnt) { 664 pr_err("vfs_link failed err %d\n", err); 665 goto out3; 666 } 667 668 err = vfs_link(oldpath.dentry, mnt_idmap(newpath.mnt), 669 d_inode(newpath.dentry), 670 dentry, NULL); 671 if (err) 672 ksmbd_debug(VFS, "vfs_link failed err %d\n", err); 673 674 out3: 675 done_path_create(&newpath, dentry); 676 out2: 677 path_put(&oldpath); 678 out1: 679 ksmbd_revert_fsids(work); 680 return err; 681 } 682 683 int ksmbd_vfs_rename(struct ksmbd_work *work, const struct path *old_path, 684 char *newname, int flags) 685 { 686 struct dentry *old_parent, *new_dentry, *trap; 687 struct dentry *old_child = old_path->dentry; 688 struct path new_path; 689 struct qstr new_last; 690 struct renamedata rd; 691 struct filename *to; 692 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 693 struct ksmbd_file *parent_fp; 694 int new_type; 695 int err, lookup_flags = LOOKUP_NO_SYMLINKS; 696 697 if (ksmbd_override_fsids(work)) 698 return -ENOMEM; 699 700 to = getname_kernel(newname); 701 if (IS_ERR(to)) { 702 err = PTR_ERR(to); 703 goto revert_fsids; 704 } 705 706 retry: 707 err = vfs_path_parent_lookup(to, lookup_flags | LOOKUP_BENEATH, 708 &new_path, &new_last, &new_type, 709 &share_conf->vfs_path); 710 if (err) 711 goto out1; 712 713 if (old_path->mnt != new_path.mnt) { 714 err = -EXDEV; 715 goto out2; 716 } 717 718 err = mnt_want_write(old_path->mnt); 719 if (err) 720 goto out2; 721 722 trap = lock_rename_child(old_child, new_path.dentry); 723 if (IS_ERR(trap)) { 724 err = PTR_ERR(trap); 725 goto out_drop_write; 726 } 727 728 old_parent = dget(old_child->d_parent); 729 if (d_unhashed(old_child)) { 730 err = -EINVAL; 731 goto out3; 732 } 733 734 parent_fp = ksmbd_lookup_fd_inode(old_child->d_parent); 735 if (parent_fp) { 736 if (parent_fp->daccess & FILE_DELETE_LE) { 737 pr_err("parent dir is opened with delete access\n"); 738 err = -ESHARE; 739 ksmbd_fd_put(work, parent_fp); 740 goto out3; 741 } 742 ksmbd_fd_put(work, parent_fp); 743 } 744 745 new_dentry = lookup_one_qstr_excl(&new_last, new_path.dentry, 746 lookup_flags | LOOKUP_RENAME_TARGET); 747 if (IS_ERR(new_dentry)) { 748 err = PTR_ERR(new_dentry); 749 goto out3; 750 } 751 752 if (d_is_symlink(new_dentry)) { 753 err = -EACCES; 754 goto out4; 755 } 756 757 /* 758 * explicitly handle file overwrite case, for compatibility with 759 * filesystems that may not support rename flags (e.g: fuse) 760 */ 761 if ((flags & RENAME_NOREPLACE) && d_is_positive(new_dentry)) { 762 err = -EEXIST; 763 goto out4; 764 } 765 flags &= ~(RENAME_NOREPLACE); 766 767 if (old_child == trap) { 768 err = -EINVAL; 769 goto out4; 770 } 771 772 if (new_dentry == trap) { 773 err = -ENOTEMPTY; 774 goto out4; 775 } 776 777 rd.old_mnt_idmap = mnt_idmap(old_path->mnt), 778 rd.old_dir = d_inode(old_parent), 779 rd.old_dentry = old_child, 780 rd.new_mnt_idmap = mnt_idmap(new_path.mnt), 781 rd.new_dir = new_path.dentry->d_inode, 782 rd.new_dentry = new_dentry, 783 rd.flags = flags, 784 rd.delegated_inode = NULL, 785 err = vfs_rename(&rd); 786 if (err) 787 ksmbd_debug(VFS, "vfs_rename failed err %d\n", err); 788 789 out4: 790 dput(new_dentry); 791 out3: 792 dput(old_parent); 793 unlock_rename(old_parent, new_path.dentry); 794 out_drop_write: 795 mnt_drop_write(old_path->mnt); 796 out2: 797 path_put(&new_path); 798 799 if (retry_estale(err, lookup_flags)) { 800 lookup_flags |= LOOKUP_REVAL; 801 goto retry; 802 } 803 out1: 804 putname(to); 805 revert_fsids: 806 ksmbd_revert_fsids(work); 807 return err; 808 } 809 810 /** 811 * ksmbd_vfs_truncate() - vfs helper for smb file truncate 812 * @work: work 813 * @fp: ksmbd file pointer 814 * @size: truncate to given size 815 * 816 * Return: 0 on success, otherwise error 817 */ 818 int ksmbd_vfs_truncate(struct ksmbd_work *work, 819 struct ksmbd_file *fp, loff_t size) 820 { 821 int err = 0; 822 struct file *filp; 823 824 filp = fp->filp; 825 826 /* Do we need to break any of a levelII oplock? */ 827 smb_break_all_levII_oplock(work, fp, 1); 828 829 if (!work->tcon->posix_extensions) { 830 struct inode *inode = file_inode(filp); 831 832 if (size < inode->i_size) { 833 err = check_lock_range(filp, size, 834 inode->i_size - 1, WRITE); 835 } else { 836 err = check_lock_range(filp, inode->i_size, 837 size - 1, WRITE); 838 } 839 840 if (err) { 841 pr_err("failed due to lock\n"); 842 return -EAGAIN; 843 } 844 } 845 846 err = vfs_truncate(&filp->f_path, size); 847 if (err) 848 pr_err("truncate failed, err %d\n", err); 849 return err; 850 } 851 852 /** 853 * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes 854 * @dentry: dentry of file for listing xattrs 855 * @list: destination buffer 856 * 857 * Return: xattr list length on success, otherwise error 858 */ 859 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list) 860 { 861 ssize_t size; 862 char *vlist = NULL; 863 864 size = vfs_listxattr(dentry, NULL, 0); 865 if (size <= 0) 866 return size; 867 868 vlist = kvzalloc(size, GFP_KERNEL); 869 if (!vlist) 870 return -ENOMEM; 871 872 *list = vlist; 873 size = vfs_listxattr(dentry, vlist, size); 874 if (size < 0) { 875 ksmbd_debug(VFS, "listxattr failed\n"); 876 kvfree(vlist); 877 *list = NULL; 878 } 879 880 return size; 881 } 882 883 static ssize_t ksmbd_vfs_xattr_len(struct mnt_idmap *idmap, 884 struct dentry *dentry, char *xattr_name) 885 { 886 return vfs_getxattr(idmap, dentry, xattr_name, NULL, 0); 887 } 888 889 /** 890 * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value 891 * @idmap: idmap 892 * @dentry: dentry of file for getting xattrs 893 * @xattr_name: name of xattr name to query 894 * @xattr_buf: destination buffer xattr value 895 * 896 * Return: read xattr value length on success, otherwise error 897 */ 898 ssize_t ksmbd_vfs_getxattr(struct mnt_idmap *idmap, 899 struct dentry *dentry, 900 char *xattr_name, char **xattr_buf) 901 { 902 ssize_t xattr_len; 903 char *buf; 904 905 *xattr_buf = NULL; 906 xattr_len = ksmbd_vfs_xattr_len(idmap, dentry, xattr_name); 907 if (xattr_len < 0) 908 return xattr_len; 909 910 buf = kmalloc(xattr_len + 1, GFP_KERNEL); 911 if (!buf) 912 return -ENOMEM; 913 914 xattr_len = vfs_getxattr(idmap, dentry, xattr_name, 915 (void *)buf, xattr_len); 916 if (xattr_len > 0) 917 *xattr_buf = buf; 918 else 919 kfree(buf); 920 return xattr_len; 921 } 922 923 /** 924 * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value 925 * @idmap: idmap of the relevant mount 926 * @path: path of dentry to set XATTR at 927 * @attr_name: xattr name for setxattr 928 * @attr_value: xattr value to set 929 * @attr_size: size of xattr value 930 * @flags: destination buffer length 931 * @get_write: get write access to a mount 932 * 933 * Return: 0 on success, otherwise error 934 */ 935 int ksmbd_vfs_setxattr(struct mnt_idmap *idmap, 936 const struct path *path, const char *attr_name, 937 void *attr_value, size_t attr_size, int flags, 938 bool get_write) 939 { 940 int err; 941 942 if (get_write == true) { 943 err = mnt_want_write(path->mnt); 944 if (err) 945 return err; 946 } 947 948 err = vfs_setxattr(idmap, 949 path->dentry, 950 attr_name, 951 attr_value, 952 attr_size, 953 flags); 954 if (err) 955 ksmbd_debug(VFS, "setxattr failed, err %d\n", err); 956 if (get_write == true) 957 mnt_drop_write(path->mnt); 958 return err; 959 } 960 961 /** 962 * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options 963 * @filp: file pointer for IO 964 * @option: smb IO options 965 */ 966 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option) 967 { 968 struct address_space *mapping; 969 970 mapping = filp->f_mapping; 971 972 if (!option || !mapping) 973 return; 974 975 if (option & FILE_WRITE_THROUGH_LE) { 976 filp->f_flags |= O_SYNC; 977 } else if (option & FILE_SEQUENTIAL_ONLY_LE) { 978 filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2; 979 spin_lock(&filp->f_lock); 980 filp->f_mode &= ~FMODE_RANDOM; 981 spin_unlock(&filp->f_lock); 982 } else if (option & FILE_RANDOM_ACCESS_LE) { 983 spin_lock(&filp->f_lock); 984 filp->f_mode |= FMODE_RANDOM; 985 spin_unlock(&filp->f_lock); 986 } 987 } 988 989 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp, 990 loff_t off, loff_t len) 991 { 992 smb_break_all_levII_oplock(work, fp, 1); 993 if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE) 994 return vfs_fallocate(fp->filp, 995 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 996 off, len); 997 998 return vfs_fallocate(fp->filp, 999 FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE, 1000 off, len); 1001 } 1002 1003 int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length, 1004 struct file_allocated_range_buffer *ranges, 1005 unsigned int in_count, unsigned int *out_count) 1006 { 1007 struct file *f = fp->filp; 1008 struct inode *inode = file_inode(fp->filp); 1009 loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end; 1010 loff_t extent_start, extent_end; 1011 int ret = 0; 1012 1013 if (start > maxbytes) 1014 return -EFBIG; 1015 1016 if (!in_count) 1017 return 0; 1018 1019 /* 1020 * Shrink request scope to what the fs can actually handle. 1021 */ 1022 if (length > maxbytes || (maxbytes - length) < start) 1023 length = maxbytes - start; 1024 1025 if (start + length > inode->i_size) 1026 length = inode->i_size - start; 1027 1028 *out_count = 0; 1029 end = start + length; 1030 while (start < end && *out_count < in_count) { 1031 extent_start = vfs_llseek(f, start, SEEK_DATA); 1032 if (extent_start < 0) { 1033 if (extent_start != -ENXIO) 1034 ret = (int)extent_start; 1035 break; 1036 } 1037 1038 if (extent_start >= end) 1039 break; 1040 1041 extent_end = vfs_llseek(f, extent_start, SEEK_HOLE); 1042 if (extent_end < 0) { 1043 if (extent_end != -ENXIO) 1044 ret = (int)extent_end; 1045 break; 1046 } else if (extent_start >= extent_end) { 1047 break; 1048 } 1049 1050 ranges[*out_count].file_offset = cpu_to_le64(extent_start); 1051 ranges[(*out_count)++].length = 1052 cpu_to_le64(min(extent_end, end) - extent_start); 1053 1054 start = extent_end; 1055 } 1056 1057 return ret; 1058 } 1059 1060 int ksmbd_vfs_remove_xattr(struct mnt_idmap *idmap, 1061 const struct path *path, char *attr_name, 1062 bool get_write) 1063 { 1064 int err; 1065 1066 if (get_write == true) { 1067 err = mnt_want_write(path->mnt); 1068 if (err) 1069 return err; 1070 } 1071 1072 err = vfs_removexattr(idmap, path->dentry, attr_name); 1073 1074 if (get_write == true) 1075 mnt_drop_write(path->mnt); 1076 1077 return err; 1078 } 1079 1080 int ksmbd_vfs_unlink(struct file *filp) 1081 { 1082 int err = 0; 1083 struct dentry *dir, *dentry = filp->f_path.dentry; 1084 struct mnt_idmap *idmap = file_mnt_idmap(filp); 1085 1086 err = mnt_want_write(filp->f_path.mnt); 1087 if (err) 1088 return err; 1089 1090 dir = dget_parent(dentry); 1091 err = ksmbd_vfs_lock_parent(dir, dentry); 1092 if (err) 1093 goto out; 1094 dget(dentry); 1095 1096 if (S_ISDIR(d_inode(dentry)->i_mode)) 1097 err = vfs_rmdir(idmap, d_inode(dir), dentry); 1098 else 1099 err = vfs_unlink(idmap, d_inode(dir), dentry, NULL); 1100 1101 dput(dentry); 1102 inode_unlock(d_inode(dir)); 1103 if (err) 1104 ksmbd_debug(VFS, "failed to delete, err %d\n", err); 1105 out: 1106 dput(dir); 1107 mnt_drop_write(filp->f_path.mnt); 1108 1109 return err; 1110 } 1111 1112 static bool __dir_empty(struct dir_context *ctx, const char *name, int namlen, 1113 loff_t offset, u64 ino, unsigned int d_type) 1114 { 1115 struct ksmbd_readdir_data *buf; 1116 1117 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1118 buf->dirent_count++; 1119 1120 return buf->dirent_count <= 2; 1121 } 1122 1123 /** 1124 * ksmbd_vfs_empty_dir() - check for empty directory 1125 * @fp: ksmbd file pointer 1126 * 1127 * Return: true if directory empty, otherwise false 1128 */ 1129 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp) 1130 { 1131 int err; 1132 struct ksmbd_readdir_data readdir_data; 1133 1134 memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data)); 1135 1136 set_ctx_actor(&readdir_data.ctx, __dir_empty); 1137 readdir_data.dirent_count = 0; 1138 1139 err = iterate_dir(fp->filp, &readdir_data.ctx); 1140 if (readdir_data.dirent_count > 2) 1141 err = -ENOTEMPTY; 1142 else 1143 err = 0; 1144 return err; 1145 } 1146 1147 static bool __caseless_lookup(struct dir_context *ctx, const char *name, 1148 int namlen, loff_t offset, u64 ino, 1149 unsigned int d_type) 1150 { 1151 struct ksmbd_readdir_data *buf; 1152 int cmp = -EINVAL; 1153 1154 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1155 1156 if (buf->used != namlen) 1157 return true; 1158 if (IS_ENABLED(CONFIG_UNICODE) && buf->um) { 1159 const struct qstr q_buf = {.name = buf->private, 1160 .len = buf->used}; 1161 const struct qstr q_name = {.name = name, 1162 .len = namlen}; 1163 1164 cmp = utf8_strncasecmp(buf->um, &q_buf, &q_name); 1165 } 1166 if (cmp < 0) 1167 cmp = strncasecmp((char *)buf->private, name, namlen); 1168 if (!cmp) { 1169 memcpy((char *)buf->private, name, namlen); 1170 buf->dirent_count = 1; 1171 return false; 1172 } 1173 return true; 1174 } 1175 1176 /** 1177 * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory 1178 * @dir: path info 1179 * @name: filename to lookup 1180 * @namelen: filename length 1181 * @um: &struct unicode_map to use 1182 * 1183 * Return: 0 on success, otherwise error 1184 */ 1185 static int ksmbd_vfs_lookup_in_dir(const struct path *dir, char *name, 1186 size_t namelen, struct unicode_map *um) 1187 { 1188 int ret; 1189 struct file *dfilp; 1190 int flags = O_RDONLY | O_LARGEFILE; 1191 struct ksmbd_readdir_data readdir_data = { 1192 .ctx.actor = __caseless_lookup, 1193 .private = name, 1194 .used = namelen, 1195 .dirent_count = 0, 1196 .um = um, 1197 }; 1198 1199 dfilp = dentry_open(dir, flags, current_cred()); 1200 if (IS_ERR(dfilp)) 1201 return PTR_ERR(dfilp); 1202 1203 ret = iterate_dir(dfilp, &readdir_data.ctx); 1204 if (readdir_data.dirent_count > 0) 1205 ret = 0; 1206 fput(dfilp); 1207 return ret; 1208 } 1209 1210 /** 1211 * ksmbd_vfs_kern_path_locked() - lookup a file and get path info 1212 * @work: work 1213 * @name: file path that is relative to share 1214 * @flags: lookup flags 1215 * @parent_path: if lookup succeed, return parent_path info 1216 * @path: if lookup succeed, return path info 1217 * @caseless: caseless filename lookup 1218 * 1219 * Return: 0 on success, otherwise error 1220 */ 1221 int ksmbd_vfs_kern_path_locked(struct ksmbd_work *work, char *name, 1222 unsigned int flags, struct path *parent_path, 1223 struct path *path, bool caseless) 1224 { 1225 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1226 int err; 1227 1228 err = ksmbd_vfs_path_lookup_locked(share_conf, name, flags, parent_path, 1229 path); 1230 if (!err) 1231 return 0; 1232 1233 if (caseless) { 1234 char *filepath; 1235 size_t path_len, remain_len; 1236 1237 filepath = kstrdup(name, GFP_KERNEL); 1238 if (!filepath) 1239 return -ENOMEM; 1240 1241 path_len = strlen(filepath); 1242 remain_len = path_len; 1243 1244 *parent_path = share_conf->vfs_path; 1245 path_get(parent_path); 1246 1247 while (d_can_lookup(parent_path->dentry)) { 1248 char *filename = filepath + path_len - remain_len; 1249 char *next = strchrnul(filename, '/'); 1250 size_t filename_len = next - filename; 1251 bool is_last = !next[0]; 1252 1253 if (filename_len == 0) 1254 break; 1255 1256 err = ksmbd_vfs_lookup_in_dir(parent_path, filename, 1257 filename_len, 1258 work->conn->um); 1259 if (err) 1260 goto out2; 1261 1262 next[0] = '\0'; 1263 1264 err = vfs_path_lookup(share_conf->vfs_path.dentry, 1265 share_conf->vfs_path.mnt, 1266 filepath, 1267 flags, 1268 path); 1269 if (err) 1270 goto out2; 1271 else if (is_last) 1272 goto out1; 1273 path_put(parent_path); 1274 *parent_path = *path; 1275 1276 next[0] = '/'; 1277 remain_len -= filename_len + 1; 1278 } 1279 1280 err = -EINVAL; 1281 out2: 1282 path_put(parent_path); 1283 out1: 1284 kfree(filepath); 1285 } 1286 1287 if (!err) { 1288 err = mnt_want_write(parent_path->mnt); 1289 if (err) { 1290 path_put(path); 1291 path_put(parent_path); 1292 return err; 1293 } 1294 1295 err = ksmbd_vfs_lock_parent(parent_path->dentry, path->dentry); 1296 if (err) { 1297 path_put(path); 1298 path_put(parent_path); 1299 } 1300 } 1301 return err; 1302 } 1303 1304 void ksmbd_vfs_kern_path_unlock(struct path *parent_path, struct path *path) 1305 { 1306 inode_unlock(d_inode(parent_path->dentry)); 1307 mnt_drop_write(parent_path->mnt); 1308 path_put(path); 1309 path_put(parent_path); 1310 } 1311 1312 struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work, 1313 const char *name, 1314 unsigned int flags, 1315 struct path *path) 1316 { 1317 char *abs_name; 1318 struct dentry *dent; 1319 1320 abs_name = convert_to_unix_name(work->tcon->share_conf, name); 1321 if (!abs_name) 1322 return ERR_PTR(-ENOMEM); 1323 1324 dent = kern_path_create(AT_FDCWD, abs_name, path, flags); 1325 kfree(abs_name); 1326 return dent; 1327 } 1328 1329 int ksmbd_vfs_remove_acl_xattrs(struct mnt_idmap *idmap, 1330 const struct path *path) 1331 { 1332 char *name, *xattr_list = NULL; 1333 ssize_t xattr_list_len; 1334 int err = 0; 1335 1336 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1337 if (xattr_list_len < 0) { 1338 goto out; 1339 } else if (!xattr_list_len) { 1340 ksmbd_debug(SMB, "empty xattr in the file\n"); 1341 goto out; 1342 } 1343 1344 err = mnt_want_write(path->mnt); 1345 if (err) 1346 goto out; 1347 1348 for (name = xattr_list; name - xattr_list < xattr_list_len; 1349 name += strlen(name) + 1) { 1350 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1351 1352 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, 1353 sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) || 1354 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, 1355 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) { 1356 err = vfs_remove_acl(idmap, path->dentry, name); 1357 if (err) 1358 ksmbd_debug(SMB, 1359 "remove acl xattr failed : %s\n", name); 1360 } 1361 } 1362 mnt_drop_write(path->mnt); 1363 1364 out: 1365 kvfree(xattr_list); 1366 return err; 1367 } 1368 1369 int ksmbd_vfs_remove_sd_xattrs(struct mnt_idmap *idmap, const struct path *path) 1370 { 1371 char *name, *xattr_list = NULL; 1372 ssize_t xattr_list_len; 1373 int err = 0; 1374 1375 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1376 if (xattr_list_len < 0) { 1377 goto out; 1378 } else if (!xattr_list_len) { 1379 ksmbd_debug(SMB, "empty xattr in the file\n"); 1380 goto out; 1381 } 1382 1383 for (name = xattr_list; name - xattr_list < xattr_list_len; 1384 name += strlen(name) + 1) { 1385 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1386 1387 if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) { 1388 err = ksmbd_vfs_remove_xattr(idmap, path, name, true); 1389 if (err) 1390 ksmbd_debug(SMB, "remove xattr failed : %s\n", name); 1391 } 1392 } 1393 out: 1394 kvfree(xattr_list); 1395 return err; 1396 } 1397 1398 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct mnt_idmap *idmap, 1399 struct inode *inode, 1400 int acl_type) 1401 { 1402 struct xattr_smb_acl *smb_acl = NULL; 1403 struct posix_acl *posix_acls; 1404 struct posix_acl_entry *pa_entry; 1405 struct xattr_acl_entry *xa_entry; 1406 int i; 1407 1408 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1409 return NULL; 1410 1411 posix_acls = get_inode_acl(inode, acl_type); 1412 if (IS_ERR_OR_NULL(posix_acls)) 1413 return NULL; 1414 1415 smb_acl = kzalloc(sizeof(struct xattr_smb_acl) + 1416 sizeof(struct xattr_acl_entry) * posix_acls->a_count, 1417 GFP_KERNEL); 1418 if (!smb_acl) 1419 goto out; 1420 1421 smb_acl->count = posix_acls->a_count; 1422 pa_entry = posix_acls->a_entries; 1423 xa_entry = smb_acl->entries; 1424 for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) { 1425 switch (pa_entry->e_tag) { 1426 case ACL_USER: 1427 xa_entry->type = SMB_ACL_USER; 1428 xa_entry->uid = posix_acl_uid_translate(idmap, pa_entry); 1429 break; 1430 case ACL_USER_OBJ: 1431 xa_entry->type = SMB_ACL_USER_OBJ; 1432 break; 1433 case ACL_GROUP: 1434 xa_entry->type = SMB_ACL_GROUP; 1435 xa_entry->gid = posix_acl_gid_translate(idmap, pa_entry); 1436 break; 1437 case ACL_GROUP_OBJ: 1438 xa_entry->type = SMB_ACL_GROUP_OBJ; 1439 break; 1440 case ACL_OTHER: 1441 xa_entry->type = SMB_ACL_OTHER; 1442 break; 1443 case ACL_MASK: 1444 xa_entry->type = SMB_ACL_MASK; 1445 break; 1446 default: 1447 pr_err("unknown type : 0x%x\n", pa_entry->e_tag); 1448 goto out; 1449 } 1450 1451 if (pa_entry->e_perm & ACL_READ) 1452 xa_entry->perm |= SMB_ACL_READ; 1453 if (pa_entry->e_perm & ACL_WRITE) 1454 xa_entry->perm |= SMB_ACL_WRITE; 1455 if (pa_entry->e_perm & ACL_EXECUTE) 1456 xa_entry->perm |= SMB_ACL_EXECUTE; 1457 } 1458 out: 1459 posix_acl_release(posix_acls); 1460 return smb_acl; 1461 } 1462 1463 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, 1464 struct mnt_idmap *idmap, 1465 const struct path *path, 1466 struct smb_ntsd *pntsd, int len, 1467 bool get_write) 1468 { 1469 int rc; 1470 struct ndr sd_ndr = {0}, acl_ndr = {0}; 1471 struct xattr_ntacl acl = {0}; 1472 struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL; 1473 struct dentry *dentry = path->dentry; 1474 struct inode *inode = d_inode(dentry); 1475 1476 acl.version = 4; 1477 acl.hash_type = XATTR_SD_HASH_TYPE_SHA256; 1478 acl.current_time = ksmbd_UnixTimeToNT(current_time(inode)); 1479 1480 memcpy(acl.desc, "posix_acl", 9); 1481 acl.desc_len = 10; 1482 1483 pntsd->osidoffset = 1484 cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF); 1485 pntsd->gsidoffset = 1486 cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF); 1487 pntsd->dacloffset = 1488 cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF); 1489 1490 acl.sd_buf = (char *)pntsd; 1491 acl.sd_size = len; 1492 1493 rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash); 1494 if (rc) { 1495 pr_err("failed to generate hash for ndr acl\n"); 1496 return rc; 1497 } 1498 1499 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1500 ACL_TYPE_ACCESS); 1501 if (S_ISDIR(inode->i_mode)) 1502 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1503 ACL_TYPE_DEFAULT); 1504 1505 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, 1506 smb_acl, def_smb_acl); 1507 if (rc) { 1508 pr_err("failed to encode ndr to posix acl\n"); 1509 goto out; 1510 } 1511 1512 rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, 1513 acl.posix_acl_hash); 1514 if (rc) { 1515 pr_err("failed to generate hash for ndr acl\n"); 1516 goto out; 1517 } 1518 1519 rc = ndr_encode_v4_ntacl(&sd_ndr, &acl); 1520 if (rc) { 1521 pr_err("failed to encode ndr to posix acl\n"); 1522 goto out; 1523 } 1524 1525 rc = ksmbd_vfs_setxattr(idmap, path, 1526 XATTR_NAME_SD, sd_ndr.data, 1527 sd_ndr.offset, 0, get_write); 1528 if (rc < 0) 1529 pr_err("Failed to store XATTR ntacl :%d\n", rc); 1530 1531 kfree(sd_ndr.data); 1532 out: 1533 kfree(acl_ndr.data); 1534 kfree(smb_acl); 1535 kfree(def_smb_acl); 1536 return rc; 1537 } 1538 1539 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, 1540 struct mnt_idmap *idmap, 1541 struct dentry *dentry, 1542 struct smb_ntsd **pntsd) 1543 { 1544 int rc; 1545 struct ndr n; 1546 struct inode *inode = d_inode(dentry); 1547 struct ndr acl_ndr = {0}; 1548 struct xattr_ntacl acl; 1549 struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL; 1550 __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0}; 1551 1552 rc = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_SD, &n.data); 1553 if (rc <= 0) 1554 return rc; 1555 1556 n.length = rc; 1557 rc = ndr_decode_v4_ntacl(&n, &acl); 1558 if (rc) 1559 goto free_n_data; 1560 1561 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1562 ACL_TYPE_ACCESS); 1563 if (S_ISDIR(inode->i_mode)) 1564 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1565 ACL_TYPE_DEFAULT); 1566 1567 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, smb_acl, 1568 def_smb_acl); 1569 if (rc) { 1570 pr_err("failed to encode ndr to posix acl\n"); 1571 goto out_free; 1572 } 1573 1574 rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset, cmp_hash); 1575 if (rc) { 1576 pr_err("failed to generate hash for ndr acl\n"); 1577 goto out_free; 1578 } 1579 1580 if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) { 1581 pr_err("hash value diff\n"); 1582 rc = -EINVAL; 1583 goto out_free; 1584 } 1585 1586 *pntsd = acl.sd_buf; 1587 if (acl.sd_size < sizeof(struct smb_ntsd)) { 1588 pr_err("sd size is invalid\n"); 1589 goto out_free; 1590 } 1591 1592 (*pntsd)->osidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) - 1593 NDR_NTSD_OFFSETOF); 1594 (*pntsd)->gsidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) - 1595 NDR_NTSD_OFFSETOF); 1596 (*pntsd)->dacloffset = cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) - 1597 NDR_NTSD_OFFSETOF); 1598 1599 rc = acl.sd_size; 1600 out_free: 1601 kfree(acl_ndr.data); 1602 kfree(smb_acl); 1603 kfree(def_smb_acl); 1604 if (rc < 0) { 1605 kfree(acl.sd_buf); 1606 *pntsd = NULL; 1607 } 1608 1609 free_n_data: 1610 kfree(n.data); 1611 return rc; 1612 } 1613 1614 int ksmbd_vfs_set_dos_attrib_xattr(struct mnt_idmap *idmap, 1615 const struct path *path, 1616 struct xattr_dos_attrib *da, 1617 bool get_write) 1618 { 1619 struct ndr n; 1620 int err; 1621 1622 err = ndr_encode_dos_attr(&n, da); 1623 if (err) 1624 return err; 1625 1626 err = ksmbd_vfs_setxattr(idmap, path, XATTR_NAME_DOS_ATTRIBUTE, 1627 (void *)n.data, n.offset, 0, get_write); 1628 if (err) 1629 ksmbd_debug(SMB, "failed to store dos attribute in xattr\n"); 1630 kfree(n.data); 1631 1632 return err; 1633 } 1634 1635 int ksmbd_vfs_get_dos_attrib_xattr(struct mnt_idmap *idmap, 1636 struct dentry *dentry, 1637 struct xattr_dos_attrib *da) 1638 { 1639 struct ndr n; 1640 int err; 1641 1642 err = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_DOS_ATTRIBUTE, 1643 (char **)&n.data); 1644 if (err > 0) { 1645 n.length = err; 1646 if (ndr_decode_dos_attr(&n, da)) 1647 err = -EINVAL; 1648 kfree(n.data); 1649 } else { 1650 ksmbd_debug(SMB, "failed to load dos attribute in xattr\n"); 1651 } 1652 1653 return err; 1654 } 1655 1656 /** 1657 * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format 1658 * @p: destination buffer 1659 * @ksmbd_kstat: ksmbd kstat wrapper 1660 * 1661 * Returns: pointer to the converted &struct file_directory_info 1662 */ 1663 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat) 1664 { 1665 struct file_directory_info *info = (struct file_directory_info *)(*p); 1666 struct kstat *kstat = ksmbd_kstat->kstat; 1667 u64 time; 1668 1669 info->FileIndex = 0; 1670 info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time); 1671 time = ksmbd_UnixTimeToNT(kstat->atime); 1672 info->LastAccessTime = cpu_to_le64(time); 1673 time = ksmbd_UnixTimeToNT(kstat->mtime); 1674 info->LastWriteTime = cpu_to_le64(time); 1675 time = ksmbd_UnixTimeToNT(kstat->ctime); 1676 info->ChangeTime = cpu_to_le64(time); 1677 1678 if (ksmbd_kstat->file_attributes & FILE_ATTRIBUTE_DIRECTORY_LE) { 1679 info->EndOfFile = 0; 1680 info->AllocationSize = 0; 1681 } else { 1682 info->EndOfFile = cpu_to_le64(kstat->size); 1683 info->AllocationSize = cpu_to_le64(kstat->blocks << 9); 1684 } 1685 info->ExtFileAttributes = ksmbd_kstat->file_attributes; 1686 1687 return info; 1688 } 1689 1690 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, 1691 struct mnt_idmap *idmap, 1692 struct dentry *dentry, 1693 struct ksmbd_kstat *ksmbd_kstat) 1694 { 1695 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1696 u64 time; 1697 int rc; 1698 struct path path = { 1699 .mnt = share_conf->vfs_path.mnt, 1700 .dentry = dentry, 1701 }; 1702 1703 rc = vfs_getattr(&path, ksmbd_kstat->kstat, 1704 STATX_BASIC_STATS | STATX_BTIME, 1705 AT_STATX_SYNC_AS_STAT); 1706 if (rc) 1707 return rc; 1708 1709 time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime); 1710 ksmbd_kstat->create_time = time; 1711 1712 /* 1713 * set default value for the case that store dos attributes is not yes 1714 * or that acl is disable in server's filesystem and the config is yes. 1715 */ 1716 if (S_ISDIR(ksmbd_kstat->kstat->mode)) 1717 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_DIRECTORY_LE; 1718 else 1719 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_ARCHIVE_LE; 1720 1721 if (test_share_config_flag(work->tcon->share_conf, 1722 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { 1723 struct xattr_dos_attrib da; 1724 1725 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da); 1726 if (rc > 0) { 1727 ksmbd_kstat->file_attributes = cpu_to_le32(da.attr); 1728 ksmbd_kstat->create_time = da.create_time; 1729 } else { 1730 ksmbd_debug(VFS, "fail to load dos attribute.\n"); 1731 } 1732 } 1733 1734 return 0; 1735 } 1736 1737 ssize_t ksmbd_vfs_casexattr_len(struct mnt_idmap *idmap, 1738 struct dentry *dentry, char *attr_name, 1739 int attr_name_len) 1740 { 1741 char *name, *xattr_list = NULL; 1742 ssize_t value_len = -ENOENT, xattr_list_len; 1743 1744 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 1745 if (xattr_list_len <= 0) 1746 goto out; 1747 1748 for (name = xattr_list; name - xattr_list < xattr_list_len; 1749 name += strlen(name) + 1) { 1750 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); 1751 if (strncasecmp(attr_name, name, attr_name_len)) 1752 continue; 1753 1754 value_len = ksmbd_vfs_xattr_len(idmap, dentry, name); 1755 break; 1756 } 1757 1758 out: 1759 kvfree(xattr_list); 1760 return value_len; 1761 } 1762 1763 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name, 1764 size_t *xattr_stream_name_size, int s_type) 1765 { 1766 char *type, *buf; 1767 1768 if (s_type == DIR_STREAM) 1769 type = ":$INDEX_ALLOCATION"; 1770 else 1771 type = ":$DATA"; 1772 1773 buf = kasprintf(GFP_KERNEL, "%s%s%s", 1774 XATTR_NAME_STREAM, stream_name, type); 1775 if (!buf) 1776 return -ENOMEM; 1777 1778 *xattr_stream_name = buf; 1779 *xattr_stream_name_size = strlen(buf) + 1; 1780 1781 return 0; 1782 } 1783 1784 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, 1785 struct ksmbd_file *src_fp, 1786 struct ksmbd_file *dst_fp, 1787 struct srv_copychunk *chunks, 1788 unsigned int chunk_count, 1789 unsigned int *chunk_count_written, 1790 unsigned int *chunk_size_written, 1791 loff_t *total_size_written) 1792 { 1793 unsigned int i; 1794 loff_t src_off, dst_off, src_file_size; 1795 size_t len; 1796 int ret; 1797 1798 *chunk_count_written = 0; 1799 *chunk_size_written = 0; 1800 *total_size_written = 0; 1801 1802 if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 1803 pr_err("no right to read(%pD)\n", src_fp->filp); 1804 return -EACCES; 1805 } 1806 if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) { 1807 pr_err("no right to write(%pD)\n", dst_fp->filp); 1808 return -EACCES; 1809 } 1810 1811 if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp)) 1812 return -EBADF; 1813 1814 smb_break_all_levII_oplock(work, dst_fp, 1); 1815 1816 if (!work->tcon->posix_extensions) { 1817 for (i = 0; i < chunk_count; i++) { 1818 src_off = le64_to_cpu(chunks[i].SourceOffset); 1819 dst_off = le64_to_cpu(chunks[i].TargetOffset); 1820 len = le32_to_cpu(chunks[i].Length); 1821 1822 if (check_lock_range(src_fp->filp, src_off, 1823 src_off + len - 1, READ)) 1824 return -EAGAIN; 1825 if (check_lock_range(dst_fp->filp, dst_off, 1826 dst_off + len - 1, WRITE)) 1827 return -EAGAIN; 1828 } 1829 } 1830 1831 src_file_size = i_size_read(file_inode(src_fp->filp)); 1832 1833 for (i = 0; i < chunk_count; i++) { 1834 src_off = le64_to_cpu(chunks[i].SourceOffset); 1835 dst_off = le64_to_cpu(chunks[i].TargetOffset); 1836 len = le32_to_cpu(chunks[i].Length); 1837 1838 if (src_off + len > src_file_size) 1839 return -E2BIG; 1840 1841 ret = vfs_copy_file_range(src_fp->filp, src_off, 1842 dst_fp->filp, dst_off, len, 0); 1843 if (ret == -EOPNOTSUPP || ret == -EXDEV) 1844 ret = vfs_copy_file_range(src_fp->filp, src_off, 1845 dst_fp->filp, dst_off, len, 1846 COPY_FILE_SPLICE); 1847 if (ret < 0) 1848 return ret; 1849 1850 *chunk_count_written += 1; 1851 *total_size_written += ret; 1852 } 1853 return 0; 1854 } 1855 1856 void ksmbd_vfs_posix_lock_wait(struct file_lock *flock) 1857 { 1858 wait_event(flock->c.flc_wait, !flock->c.flc_blocker); 1859 } 1860 1861 int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout) 1862 { 1863 return wait_event_interruptible_timeout(flock->c.flc_wait, 1864 !flock->c.flc_blocker, 1865 timeout); 1866 } 1867 1868 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock) 1869 { 1870 locks_delete_block(flock); 1871 } 1872 1873 int ksmbd_vfs_set_init_posix_acl(struct mnt_idmap *idmap, 1874 struct path *path) 1875 { 1876 struct posix_acl_state acl_state; 1877 struct posix_acl *acls; 1878 struct dentry *dentry = path->dentry; 1879 struct inode *inode = d_inode(dentry); 1880 int rc; 1881 1882 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1883 return -EOPNOTSUPP; 1884 1885 ksmbd_debug(SMB, "Set posix acls\n"); 1886 rc = init_acl_state(&acl_state, 1); 1887 if (rc) 1888 return rc; 1889 1890 /* Set default owner group */ 1891 acl_state.owner.allow = (inode->i_mode & 0700) >> 6; 1892 acl_state.group.allow = (inode->i_mode & 0070) >> 3; 1893 acl_state.other.allow = inode->i_mode & 0007; 1894 acl_state.users->aces[acl_state.users->n].uid = inode->i_uid; 1895 acl_state.users->aces[acl_state.users->n++].perms.allow = 1896 acl_state.owner.allow; 1897 acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid; 1898 acl_state.groups->aces[acl_state.groups->n++].perms.allow = 1899 acl_state.group.allow; 1900 acl_state.mask.allow = 0x07; 1901 1902 acls = posix_acl_alloc(6, GFP_KERNEL); 1903 if (!acls) { 1904 free_acl_state(&acl_state); 1905 return -ENOMEM; 1906 } 1907 posix_state_to_acl(&acl_state, acls->a_entries); 1908 1909 rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls); 1910 if (rc < 0) 1911 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 1912 rc); 1913 else if (S_ISDIR(inode->i_mode)) { 1914 posix_state_to_acl(&acl_state, acls->a_entries); 1915 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, acls); 1916 if (rc < 0) 1917 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 1918 rc); 1919 } 1920 1921 free_acl_state(&acl_state); 1922 posix_acl_release(acls); 1923 return rc; 1924 } 1925 1926 int ksmbd_vfs_inherit_posix_acl(struct mnt_idmap *idmap, 1927 struct path *path, struct inode *parent_inode) 1928 { 1929 struct posix_acl *acls; 1930 struct posix_acl_entry *pace; 1931 struct dentry *dentry = path->dentry; 1932 struct inode *inode = d_inode(dentry); 1933 int rc, i; 1934 1935 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1936 return -EOPNOTSUPP; 1937 1938 acls = get_inode_acl(parent_inode, ACL_TYPE_DEFAULT); 1939 if (IS_ERR_OR_NULL(acls)) 1940 return -ENOENT; 1941 pace = acls->a_entries; 1942 1943 for (i = 0; i < acls->a_count; i++, pace++) { 1944 if (pace->e_tag == ACL_MASK) { 1945 pace->e_perm = 0x07; 1946 break; 1947 } 1948 } 1949 1950 rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls); 1951 if (rc < 0) 1952 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 1953 rc); 1954 if (S_ISDIR(inode->i_mode)) { 1955 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, 1956 acls); 1957 if (rc < 0) 1958 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 1959 rc); 1960 } 1961 1962 posix_acl_release(acls); 1963 return rc; 1964 } 1965