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 <crypto/sha2.h> 8 #include <linux/kernel.h> 9 #include <linux/fs.h> 10 #include <linux/filelock.h> 11 #include <linux/uaccess.h> 12 #include <linux/backing-dev.h> 13 #include <linux/writeback.h> 14 #include <linux/xattr.h> 15 #include <linux/falloc.h> 16 #include <linux/fsnotify.h> 17 #include <linux/dcache.h> 18 #include <linux/slab.h> 19 #include <linux/sizes.h> 20 #include <linux/vmalloc.h> 21 #include <linux/sched/xacct.h> 22 #include <linux/crc32c.h> 23 #include <linux/fileattr.h> 24 25 #include "glob.h" 26 #include "oplock.h" 27 #include "connection.h" 28 #include "vfs.h" 29 #include "vfs_cache.h" 30 #include "smbacl.h" 31 #include "ndr.h" 32 #include "auth.h" 33 #include "misc.h" 34 #include "stats.h" 35 36 #include "smb_common.h" 37 #include "mgmt/share_config.h" 38 #include "mgmt/tree_connect.h" 39 #include "mgmt/user_session.h" 40 #include "mgmt/user_config.h" 41 42 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work, 43 struct inode *parent_inode, 44 struct inode *inode) 45 { 46 if (!test_share_config_flag(work->tcon->share_conf, 47 KSMBD_SHARE_FLAG_INHERIT_OWNER)) 48 return; 49 50 i_uid_write(inode, i_uid_read(parent_inode)); 51 } 52 53 static int ksmbd_vfs_path_lookup(struct ksmbd_share_config *share_conf, 54 char *pathname, unsigned int flags, 55 struct path *path, bool for_remove) 56 { 57 struct qstr last; 58 const struct path *root_share_path = &share_conf->vfs_path; 59 int err; 60 struct dentry *d; 61 62 if (pathname[0] == '\0') { 63 pathname = share_conf->path; 64 root_share_path = NULL; 65 } else { 66 flags |= LOOKUP_BENEATH; 67 } 68 69 CLASS(filename_kernel, filename)(pathname); 70 err = vfs_path_parent_lookup(filename, flags, path, &last, 71 root_share_path); 72 if (err) 73 return err; 74 75 if (for_remove) { 76 err = mnt_want_write(path->mnt); 77 if (err) { 78 path_put(path); 79 return -ENOENT; 80 } 81 82 d = start_removing_noperm(path->dentry, &last); 83 84 if (!IS_ERR(d)) { 85 dput(path->dentry); 86 path->dentry = d; 87 return 0; 88 } 89 mnt_drop_write(path->mnt); 90 path_put(path); 91 return -ENOENT; 92 } 93 94 d = lookup_noperm_unlocked(&last, path->dentry); 95 if (!IS_ERR(d) && d_is_negative(d)) { 96 dput(d); 97 d = ERR_PTR(-ENOENT); 98 } 99 if (IS_ERR(d)) { 100 path_put(path); 101 return -ENOENT; 102 } 103 dput(path->dentry); 104 path->dentry = d; 105 106 if (test_share_config_flag(share_conf, KSMBD_SHARE_FLAG_CROSSMNT)) { 107 err = follow_down(path, 0); 108 if (err < 0) { 109 path_put(path); 110 return -ENOENT; 111 } 112 } 113 return 0; 114 } 115 116 void ksmbd_vfs_query_maximal_access(struct mnt_idmap *idmap, 117 struct dentry *dentry, __le32 *daccess) 118 { 119 *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL); 120 121 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_WRITE)) 122 *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE | 123 FILE_WRITE_DATA | FILE_APPEND_DATA | 124 FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES | 125 FILE_DELETE_CHILD); 126 127 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_READ)) 128 *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE; 129 130 if (!inode_permission(idmap, d_inode(dentry), MAY_OPEN | MAY_EXEC)) 131 *daccess |= FILE_EXECUTE_LE; 132 133 if (!inode_permission(idmap, d_inode(dentry->d_parent), MAY_EXEC | MAY_WRITE)) 134 *daccess |= FILE_DELETE_LE; 135 } 136 137 /** 138 * ksmbd_vfs_create() - vfs helper for smb create file 139 * @work: work 140 * @name: file name that is relative to share 141 * @mode: file create mode 142 * 143 * Return: 0 on success, otherwise error 144 */ 145 int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode) 146 { 147 struct path path; 148 struct dentry *dentry; 149 int err; 150 151 dentry = ksmbd_vfs_kern_path_create(work, name, 152 LOOKUP_NO_SYMLINKS, &path); 153 if (IS_ERR(dentry)) { 154 err = PTR_ERR(dentry); 155 if (err != -ENOENT) 156 pr_err("path create failed for %s, err %d\n", 157 name, err); 158 return err; 159 } 160 161 mode |= S_IFREG; 162 err = vfs_create(mnt_idmap(path.mnt), dentry, mode, NULL); 163 if (!err) { 164 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), 165 d_inode(dentry)); 166 } else { 167 pr_err("File(%s): creation failed (err:%d)\n", name, err); 168 } 169 170 end_creating_path(&path, dentry); 171 return err; 172 } 173 174 /** 175 * ksmbd_vfs_mkdir() - vfs helper for smb create directory 176 * @work: work 177 * @name: directory name that is relative to share 178 * @mode: directory create mode 179 * 180 * Return: 0 on success, otherwise error 181 */ 182 int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode) 183 { 184 struct mnt_idmap *idmap; 185 struct path path; 186 struct dentry *dentry, *d; 187 int err = 0; 188 189 dentry = ksmbd_vfs_kern_path_create(work, name, 190 LOOKUP_NO_SYMLINKS | LOOKUP_DIRECTORY, 191 &path); 192 if (IS_ERR(dentry)) { 193 err = PTR_ERR(dentry); 194 if (err != -EEXIST) 195 ksmbd_debug(VFS, "path create failed for %s, err %d\n", 196 name, err); 197 return err; 198 } 199 200 idmap = mnt_idmap(path.mnt); 201 mode |= S_IFDIR; 202 d = dentry; 203 dentry = vfs_mkdir(idmap, d_inode(path.dentry), dentry, mode, NULL); 204 if (IS_ERR(dentry)) 205 err = PTR_ERR(dentry); 206 else if (d_is_negative(dentry)) 207 err = -ENOENT; 208 if (!err && dentry != d) 209 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(dentry)); 210 211 end_creating_path(&path, dentry); 212 if (err) 213 pr_err("mkdir(%s): creation failed (err:%d)\n", name, err); 214 return err; 215 } 216 217 static ssize_t ksmbd_vfs_getcasexattr(struct mnt_idmap *idmap, 218 struct dentry *dentry, char *attr_name, 219 int attr_name_len, char **attr_value) 220 { 221 char *name, *xattr_list = NULL; 222 ssize_t value_len = -ENOENT, xattr_list_len; 223 224 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 225 if (xattr_list_len <= 0) 226 goto out; 227 228 for (name = xattr_list; name - xattr_list < xattr_list_len; 229 name += strlen(name) + 1) { 230 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); 231 if (strncasecmp(attr_name, name, attr_name_len)) 232 continue; 233 234 value_len = ksmbd_vfs_getxattr(idmap, 235 dentry, 236 name, 237 attr_value); 238 if (value_len < 0) 239 pr_err("failed to get xattr in file\n"); 240 break; 241 } 242 243 out: 244 kvfree(xattr_list); 245 return value_len; 246 } 247 248 static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos, 249 size_t count) 250 { 251 const struct cred *saved_cred; 252 ssize_t v_len; 253 char *stream_buf = NULL; 254 255 ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n", 256 *pos, count); 257 258 saved_cred = override_creds(fp->filp->f_cred); 259 v_len = ksmbd_vfs_getcasexattr(file_mnt_idmap(fp->filp), 260 fp->filp->f_path.dentry, 261 fp->stream.name, 262 fp->stream.size, 263 &stream_buf); 264 revert_creds(saved_cred); 265 if ((int)v_len <= 0) 266 return (int)v_len; 267 268 if (v_len <= *pos) { 269 count = -EINVAL; 270 goto free_buf; 271 } 272 273 if (v_len - *pos < count) 274 count = v_len - *pos; 275 fp->stream.pos = v_len; 276 277 memcpy(buf, &stream_buf[*pos], count); 278 279 free_buf: 280 kvfree(stream_buf); 281 return count; 282 } 283 284 /** 285 * check_lock_range() - vfs helper for smb byte range file locking 286 * @filp: the file to apply the lock to 287 * @start: lock start byte offset 288 * @end: lock end byte offset 289 * @type: byte range type read/write 290 * 291 * Return: 0 on success, otherwise error 292 */ 293 static int check_lock_range(struct file *filp, loff_t start, loff_t end, 294 unsigned char type) 295 { 296 struct file_lock *flock; 297 struct file_lock_context *ctx = locks_inode_context(file_inode(filp)); 298 int error = 0; 299 300 if (!ctx || list_empty_careful(&ctx->flc_posix)) 301 return 0; 302 303 spin_lock(&ctx->flc_lock); 304 for_each_file_lock(flock, &ctx->flc_posix) { 305 /* check conflict locks */ 306 if (flock->fl_end >= start && end >= flock->fl_start) { 307 if (lock_is_read(flock)) { 308 if (type == WRITE) { 309 pr_err("not allow write by shared lock\n"); 310 error = 1; 311 goto out; 312 } 313 } else if (lock_is_write(flock)) { 314 /* check owner in lock */ 315 if (flock->c.flc_file != filp) { 316 error = 1; 317 pr_err("not allow rw access by exclusive lock from other opens\n"); 318 goto out; 319 } 320 } 321 } 322 } 323 out: 324 spin_unlock(&ctx->flc_lock); 325 return error; 326 } 327 328 /** 329 * ksmbd_vfs_read() - vfs helper for smb file read 330 * @work: smb work 331 * @fp: ksmbd file pointer 332 * @count: read byte count 333 * @pos: file pos 334 * @rbuf: read data buffer 335 * 336 * Return: number of read bytes on success, otherwise error 337 */ 338 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count, 339 loff_t *pos, char *rbuf) 340 { 341 struct file *filp = fp->filp; 342 ssize_t nbytes = 0; 343 struct inode *inode = file_inode(filp); 344 345 if (S_ISDIR(inode->i_mode) && !ksmbd_stream_fd(fp)) 346 return -EISDIR; 347 348 if (unlikely(count == 0)) 349 return 0; 350 351 if (work->conn->connection_type) { 352 if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 353 pr_err("no right to read(%pD)\n", fp->filp); 354 return -EACCES; 355 } 356 } 357 358 if (ksmbd_stream_fd(fp)) 359 return ksmbd_vfs_stream_read(fp, rbuf, pos, count); 360 361 if (!work->tcon->posix_extensions) { 362 int ret; 363 364 ret = check_lock_range(filp, *pos, *pos + count - 1, READ); 365 if (ret) { 366 pr_err("unable to read due to lock\n"); 367 return -EAGAIN; 368 } 369 } 370 371 nbytes = kernel_read(filp, rbuf, count, pos); 372 if (nbytes < 0) { 373 pr_err("smb read failed, err = %zd\n", nbytes); 374 return nbytes; 375 } 376 377 filp->f_pos = *pos; 378 ksmbd_counter_add(KSMBD_COUNTER_READ_BYTES, (s64)nbytes); 379 return nbytes; 380 } 381 382 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos, 383 size_t count) 384 { 385 const struct cred *saved_cred; 386 char *stream_buf = NULL, *wbuf; 387 struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 388 size_t size; 389 ssize_t v_len; 390 int err = 0; 391 392 ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n", 393 *pos, count); 394 395 if (*pos >= XATTR_SIZE_MAX) { 396 pr_err("stream write position %lld is out of bounds\n", *pos); 397 return -EINVAL; 398 } 399 400 size = *pos + count; 401 if (size > XATTR_SIZE_MAX) { 402 size = XATTR_SIZE_MAX; 403 count = XATTR_SIZE_MAX - *pos; 404 } 405 406 saved_cred = override_creds(fp->filp->f_cred); 407 v_len = ksmbd_vfs_getcasexattr(idmap, 408 fp->filp->f_path.dentry, 409 fp->stream.name, 410 fp->stream.size, 411 &stream_buf); 412 if (v_len < 0) { 413 pr_err("not found stream in xattr : %zd\n", v_len); 414 err = v_len; 415 goto out_revert; 416 } 417 418 if (v_len < size) { 419 wbuf = kvzalloc(size, KSMBD_DEFAULT_GFP); 420 if (!wbuf) { 421 err = -ENOMEM; 422 goto out_revert; 423 } 424 425 if (v_len > 0) 426 memcpy(wbuf, stream_buf, v_len); 427 kvfree(stream_buf); 428 stream_buf = wbuf; 429 } 430 431 memcpy(&stream_buf[*pos], buf, count); 432 433 err = ksmbd_vfs_setxattr(idmap, 434 &fp->filp->f_path, 435 fp->stream.name, 436 (void *)stream_buf, 437 size, 438 0, 439 true); 440 out_revert: 441 revert_creds(saved_cred); 442 if (err < 0) 443 goto out; 444 else 445 fp->stream.pos = size; 446 err = 0; 447 out: 448 kvfree(stream_buf); 449 return err; 450 } 451 452 /** 453 * ksmbd_vfs_write() - vfs helper for smb file write 454 * @work: work 455 * @fp: ksmbd file pointer 456 * @buf: buf containing data for writing 457 * @count: read byte count 458 * @pos: file pos 459 * @sync: fsync after write 460 * @written: number of bytes written 461 * 462 * Return: 0 on success, otherwise error 463 */ 464 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp, 465 char *buf, size_t count, loff_t *pos, bool sync, 466 ssize_t *written) 467 { 468 struct file *filp; 469 loff_t offset = *pos; 470 int err = 0; 471 472 if (work->conn->connection_type) { 473 if (!(fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) || 474 (S_ISDIR(file_inode(fp->filp)->i_mode) && 475 !ksmbd_stream_fd(fp))) { 476 pr_err("no right to write(%pD)\n", fp->filp); 477 err = -EACCES; 478 goto out; 479 } 480 } 481 482 filp = fp->filp; 483 484 if (ksmbd_stream_fd(fp)) { 485 err = ksmbd_vfs_stream_write(fp, buf, pos, count); 486 if (!err) 487 *written = count; 488 goto out; 489 } 490 491 if (!work->tcon->posix_extensions) { 492 err = check_lock_range(filp, *pos, *pos + count - 1, WRITE); 493 if (err) { 494 pr_err("unable to write due to lock\n"); 495 err = -EAGAIN; 496 goto out; 497 } 498 } 499 500 /* Reserve lease break for parent dir at closing time */ 501 fp->reserve_lease_break = true; 502 503 /* Do we need to break any of a levelII oplock? */ 504 smb_break_all_levII_oplock(work, fp, 1); 505 506 err = kernel_write(filp, buf, count, pos); 507 if (err < 0) { 508 ksmbd_debug(VFS, "smb write failed, err = %d\n", err); 509 goto out; 510 } 511 512 filp->f_pos = *pos; 513 *written = err; 514 err = 0; 515 if (sync) { 516 err = vfs_fsync_range(filp, offset, offset + *written, 0); 517 if (err < 0) 518 pr_err("fsync failed for filename = %pD, err = %d\n", 519 fp->filp, err); 520 } 521 ksmbd_counter_add(KSMBD_COUNTER_WRITE_BYTES, (s64)*written); 522 523 out: 524 return err; 525 } 526 527 /** 528 * ksmbd_vfs_getattr() - vfs helper for smb getattr 529 * @path: path of dentry 530 * @stat: pointer to returned kernel stat structure 531 * Return: 0 on success, otherwise error 532 */ 533 int ksmbd_vfs_getattr(const struct path *path, struct kstat *stat) 534 { 535 int err; 536 537 err = vfs_getattr(path, stat, STATX_BASIC_STATS | STATX_BTIME, 538 AT_STATX_SYNC_AS_STAT); 539 if (err) 540 pr_err("getattr failed, err %d\n", err); 541 return err; 542 } 543 544 /** 545 * ksmbd_vfs_fsync() - vfs helper for smb fsync 546 * @work: work 547 * @fid: file id of open file 548 * @p_id: persistent file id 549 * 550 * Return: 0 on success, otherwise error 551 */ 552 int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id) 553 { 554 struct ksmbd_file *fp; 555 int err; 556 557 fp = ksmbd_lookup_fd_slow(work, fid, p_id); 558 if (!fp) { 559 pr_err("failed to get filp for fid %llu\n", fid); 560 return -ENOENT; 561 } 562 err = vfs_fsync(fp->filp, 0); 563 if (err < 0) 564 pr_err("smb fsync failed, err = %d\n", err); 565 ksmbd_fd_put(work, fp); 566 return err; 567 } 568 569 /** 570 * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink 571 * @work: work 572 * @path: path of dentry 573 * 574 * Return: 0 on success, otherwise error 575 */ 576 int ksmbd_vfs_remove_file(struct ksmbd_work *work, const struct path *path) 577 { 578 struct mnt_idmap *idmap; 579 struct dentry *parent = path->dentry->d_parent; 580 int err; 581 582 if (ksmbd_override_fsids(work)) 583 return -ENOMEM; 584 585 if (!d_inode(path->dentry)->i_nlink) { 586 err = -ENOENT; 587 goto out_err; 588 } 589 590 idmap = mnt_idmap(path->mnt); 591 if (S_ISDIR(d_inode(path->dentry)->i_mode)) { 592 err = vfs_rmdir(idmap, d_inode(parent), path->dentry, NULL); 593 if (err && err != -ENOTEMPTY) 594 ksmbd_debug(VFS, "rmdir failed, err %d\n", err); 595 } else { 596 err = vfs_unlink(idmap, d_inode(parent), path->dentry, NULL); 597 if (err) 598 ksmbd_debug(VFS, "unlink failed, err %d\n", err); 599 } 600 601 out_err: 602 ksmbd_revert_fsids(work); 603 return err; 604 } 605 606 /** 607 * ksmbd_vfs_link() - vfs helper for creating smb hardlink 608 * @work: work 609 * @oldname: source file name 610 * @newname: hardlink name that is relative to share 611 * 612 * Return: 0 on success, otherwise error 613 */ 614 int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname, 615 const char *newname) 616 { 617 struct path oldpath, newpath; 618 struct dentry *dentry; 619 int err; 620 621 if (ksmbd_override_fsids(work)) 622 return -ENOMEM; 623 624 err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath); 625 if (err) { 626 pr_err("cannot get linux path for %s, err = %d\n", 627 oldname, err); 628 goto out1; 629 } 630 631 dentry = ksmbd_vfs_kern_path_create(work, newname, 632 LOOKUP_NO_SYMLINKS | LOOKUP_REVAL, 633 &newpath); 634 if (IS_ERR(dentry)) { 635 err = PTR_ERR(dentry); 636 pr_err("path create err for %s, err %d\n", newname, err); 637 goto out2; 638 } 639 640 err = -EXDEV; 641 if (oldpath.mnt != newpath.mnt) { 642 pr_err("vfs_link failed err %d\n", err); 643 goto out3; 644 } 645 646 err = vfs_link(oldpath.dentry, mnt_idmap(newpath.mnt), 647 d_inode(newpath.dentry), 648 dentry, NULL); 649 if (err) 650 ksmbd_debug(VFS, "vfs_link failed err %d\n", err); 651 652 out3: 653 end_creating_path(&newpath, dentry); 654 out2: 655 path_put(&oldpath); 656 out1: 657 ksmbd_revert_fsids(work); 658 return err; 659 } 660 661 int ksmbd_vfs_check_rename_share(struct ksmbd_work *work, 662 const struct path *old_path) 663 { 664 struct ksmbd_file *parent_fp; 665 int err = 0; 666 667 parent_fp = ksmbd_lookup_fd_inode(old_path->dentry->d_parent); 668 if (!parent_fp) 669 return 0; 670 671 if ((parent_fp->daccess & FILE_DELETE_LE) || 672 (!parent_fp->attrib_only && 673 !(parent_fp->saccess & FILE_SHARE_DELETE_LE))) { 674 ksmbd_debug(VFS, "parent dir blocks delete sharing\n"); 675 err = -ESHARE; 676 } 677 ksmbd_fd_put(work, parent_fp); 678 return err; 679 } 680 681 int ksmbd_vfs_rename(struct ksmbd_work *work, struct ksmbd_file *old_fp, 682 char *newname, int flags) 683 { 684 const struct path *old_path = &old_fp->filp->f_path; 685 struct dentry *old_child = old_path->dentry; 686 struct path new_path; 687 struct qstr new_last; 688 struct renamedata rd; 689 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 690 int err, lookup_flags = LOOKUP_NO_SYMLINKS; 691 692 if (ksmbd_override_fsids(work)) 693 return -ENOMEM; 694 695 CLASS(filename_kernel, to)(newname); 696 697 retry: 698 err = vfs_path_parent_lookup(to, lookup_flags | LOOKUP_BENEATH, 699 &new_path, &new_last, &share_conf->vfs_path); 700 if (err) 701 goto out1; 702 703 if (old_path->mnt != new_path.mnt) { 704 err = -EXDEV; 705 goto out2; 706 } 707 708 err = mnt_want_write(old_path->mnt); 709 if (err) 710 goto out2; 711 712 rd.mnt_idmap = mnt_idmap(old_path->mnt); 713 rd.old_parent = NULL; 714 rd.new_parent = new_path.dentry; 715 rd.flags = flags; 716 rd.delegated_inode = NULL; 717 err = start_renaming_dentry(&rd, lookup_flags, old_child, &new_last); 718 if (err) 719 goto out_drop_write; 720 721 if (d_is_dir(old_child) && ksmbd_has_nonposix_open_child(old_fp)) { 722 err = -EACCES; 723 goto out3; 724 } 725 726 /* 727 * See MS-FSA 2.1.5.15.12. 728 * An overwrite rename must fail with STATUS_ACCESS_DENIED if the 729 * existing target still has a non-POSIX open. 730 */ 731 if (!(flags & (RENAME_NOREPLACE | RENAME_EXCHANGE)) && 732 d_inode(rd.new_dentry) && 733 d_inode(rd.new_dentry) != d_inode(old_child) && 734 ksmbd_has_other_nonposix_open(rd.new_dentry)) { 735 err = -EACCES; 736 goto out3; 737 } 738 739 err = ksmbd_vfs_check_rename_share(work, old_path); 740 if (err) 741 goto out3; 742 743 if (d_is_symlink(rd.new_dentry)) { 744 err = -EACCES; 745 goto out3; 746 } 747 748 err = vfs_rename(&rd); 749 if (err) 750 ksmbd_debug(VFS, "vfs_rename failed err %d\n", err); 751 752 out3: 753 end_renaming(&rd); 754 out_drop_write: 755 mnt_drop_write(old_path->mnt); 756 out2: 757 path_put(&new_path); 758 759 if (retry_estale(err, lookup_flags)) { 760 lookup_flags |= LOOKUP_REVAL; 761 goto retry; 762 } 763 out1: 764 ksmbd_revert_fsids(work); 765 return err; 766 } 767 768 /** 769 * ksmbd_vfs_truncate() - vfs helper for smb file truncate 770 * @work: work 771 * @fp: ksmbd file pointer 772 * @size: truncate to given size 773 * 774 * Return: 0 on success, otherwise error 775 */ 776 int ksmbd_vfs_truncate(struct ksmbd_work *work, 777 struct ksmbd_file *fp, loff_t size) 778 { 779 int err = 0; 780 struct file *filp; 781 782 filp = fp->filp; 783 784 /* Do we need to break any of a levelII oplock? */ 785 smb_break_all_levII_oplock(work, fp, 1); 786 787 if (!work->tcon->posix_extensions) { 788 struct inode *inode = file_inode(filp); 789 790 if (size < inode->i_size) { 791 err = check_lock_range(filp, size, 792 inode->i_size - 1, WRITE); 793 } else if (size > inode->i_size) { 794 err = check_lock_range(filp, inode->i_size, 795 size - 1, WRITE); 796 } 797 798 if (err) { 799 pr_err("failed due to lock\n"); 800 return -EAGAIN; 801 } 802 } 803 804 err = vfs_truncate(&filp->f_path, size); 805 if (err) 806 pr_err("truncate failed, err %d\n", err); 807 return err; 808 } 809 810 /** 811 * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes 812 * @dentry: dentry of file for listing xattrs 813 * @list: destination buffer 814 * 815 * Return: xattr list length on success, otherwise error 816 */ 817 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list) 818 { 819 ssize_t size; 820 char *vlist = NULL; 821 822 size = vfs_listxattr(dentry, NULL, 0); 823 if (size <= 0) 824 return size; 825 826 vlist = kvzalloc(size, KSMBD_DEFAULT_GFP); 827 if (!vlist) 828 return -ENOMEM; 829 830 *list = vlist; 831 size = vfs_listxattr(dentry, vlist, size); 832 if (size < 0) { 833 ksmbd_debug(VFS, "listxattr failed\n"); 834 kvfree(vlist); 835 *list = NULL; 836 } 837 838 return size; 839 } 840 841 static ssize_t ksmbd_vfs_xattr_len(struct mnt_idmap *idmap, 842 struct dentry *dentry, char *xattr_name) 843 { 844 return vfs_getxattr(idmap, dentry, xattr_name, NULL, 0); 845 } 846 847 /** 848 * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value 849 * @idmap: idmap 850 * @dentry: dentry of file for getting xattrs 851 * @xattr_name: name of xattr name to query 852 * @xattr_buf: destination buffer xattr value 853 * 854 * Return: read xattr value length on success, otherwise error 855 */ 856 ssize_t ksmbd_vfs_getxattr(struct mnt_idmap *idmap, 857 struct dentry *dentry, 858 char *xattr_name, char **xattr_buf) 859 { 860 ssize_t xattr_len; 861 char *buf; 862 863 *xattr_buf = NULL; 864 xattr_len = ksmbd_vfs_xattr_len(idmap, dentry, xattr_name); 865 if (xattr_len < 0) 866 return xattr_len; 867 868 buf = kmalloc(xattr_len + 1, KSMBD_DEFAULT_GFP); 869 if (!buf) 870 return -ENOMEM; 871 872 xattr_len = vfs_getxattr(idmap, dentry, xattr_name, 873 (void *)buf, xattr_len); 874 if (xattr_len > 0) 875 *xattr_buf = buf; 876 else 877 kfree(buf); 878 return xattr_len; 879 } 880 881 /** 882 * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value 883 * @idmap: idmap of the relevant mount 884 * @path: path of dentry to set XATTR at 885 * @attr_name: xattr name for setxattr 886 * @attr_value: xattr value to set 887 * @attr_size: size of xattr value 888 * @flags: destination buffer length 889 * @get_write: get write access to a mount 890 * 891 * Return: 0 on success, otherwise error 892 */ 893 int ksmbd_vfs_setxattr(struct mnt_idmap *idmap, 894 const struct path *path, const char *attr_name, 895 void *attr_value, size_t attr_size, int flags, 896 bool get_write) 897 { 898 int err; 899 900 if (get_write == true) { 901 err = mnt_want_write(path->mnt); 902 if (err) 903 return err; 904 } 905 906 err = vfs_setxattr(idmap, 907 path->dentry, 908 attr_name, 909 attr_value, 910 attr_size, 911 flags); 912 if (err) 913 ksmbd_debug(VFS, "setxattr failed, err %d\n", err); 914 if (get_write == true) 915 mnt_drop_write(path->mnt); 916 return err; 917 } 918 919 /** 920 * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options 921 * @filp: file pointer for IO 922 * @option: smb IO options 923 */ 924 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option) 925 { 926 struct address_space *mapping; 927 928 mapping = filp->f_mapping; 929 930 if (!option || !mapping) 931 return; 932 933 if (option & FILE_WRITE_THROUGH_LE) { 934 filp->f_flags |= O_SYNC; 935 } else if (option & FILE_SEQUENTIAL_ONLY_LE) { 936 filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2; 937 spin_lock(&filp->f_lock); 938 filp->f_mode &= ~FMODE_RANDOM; 939 spin_unlock(&filp->f_lock); 940 } else if (option & FILE_RANDOM_ACCESS_LE) { 941 spin_lock(&filp->f_lock); 942 filp->f_mode |= FMODE_RANDOM; 943 spin_unlock(&filp->f_lock); 944 } 945 } 946 947 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp, 948 loff_t off, loff_t len) 949 { 950 const struct cred *saved_cred; 951 loff_t pos = off, size; 952 char *zero_buf = NULL; 953 int err; 954 955 smb_break_all_levII_oplock(work, fp, 1); 956 if (!work->tcon->posix_extensions) { 957 loff_t size = i_size_read(file_inode(fp->filp)); 958 959 if (off < size) { 960 err = check_lock_range(fp->filp, off, 961 min(off + len, size) - 1, 962 WRITE); 963 if (err) 964 return -EAGAIN; 965 } 966 } 967 968 saved_cred = override_creds(fp->filp->f_cred); 969 if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE) { 970 err = vfs_fallocate(fp->filp, 971 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 972 off, len); 973 } else { 974 size = i_size_read(file_inode(fp->filp)); 975 if (off >= size) { 976 err = 0; 977 goto out; 978 } 979 980 len = min(len, size - off); 981 zero_buf = kvzalloc(SZ_64K, GFP_KERNEL); 982 if (!zero_buf) { 983 err = -ENOMEM; 984 goto out; 985 } 986 987 while (len) { 988 ssize_t written; 989 size_t count = min_t(loff_t, len, SZ_64K); 990 991 written = kernel_write(fp->filp, zero_buf, count, &pos); 992 if (written < 0) { 993 err = written; 994 goto out; 995 } 996 if (!written) { 997 err = -EIO; 998 goto out; 999 } 1000 len -= written; 1001 } 1002 err = 0; 1003 } 1004 out: 1005 revert_creds(saved_cred); 1006 kvfree(zero_buf); 1007 return err; 1008 } 1009 1010 int ksmbd_vfs_zero_holes(struct ksmbd_file *fp) 1011 { 1012 struct file *f = fp->filp; 1013 const struct cred *saved_cred; 1014 loff_t size, pos = 0; 1015 char *zero_buf; 1016 int err; 1017 1018 err = file_write_and_wait(f); 1019 if (err) 1020 return err; 1021 1022 size = i_size_read(file_inode(f)); 1023 if (!size) 1024 return 0; 1025 1026 /* 1027 * FALLOC_FL_ZERO_RANGE may leave unwritten extents, which SEEK_DATA 1028 * reports as holes. Write zeroes into each hole so that clearing the 1029 * sparse attribute leaves the file fully allocated. 1030 */ 1031 zero_buf = kvzalloc(SZ_64K, GFP_KERNEL); 1032 if (!zero_buf) 1033 return -ENOMEM; 1034 1035 saved_cred = override_creds(f->f_cred); 1036 while (pos < size) { 1037 loff_t data, hole; 1038 1039 hole = vfs_llseek(f, pos, SEEK_HOLE); 1040 if (hole == -ENXIO || hole >= size) 1041 break; 1042 if (hole < 0) { 1043 err = hole; 1044 goto out; 1045 } 1046 1047 data = vfs_llseek(f, hole, SEEK_DATA); 1048 if (data == -ENXIO) { 1049 data = size; 1050 } else if (data < 0) { 1051 err = data; 1052 goto out; 1053 } 1054 data = min(data, size); 1055 if (data <= hole) { 1056 err = -EIO; 1057 goto out; 1058 } 1059 1060 pos = hole; 1061 while (pos < data) { 1062 ssize_t written; 1063 size_t count = min_t(loff_t, data - pos, SZ_64K); 1064 1065 written = kernel_write(f, zero_buf, count, &pos); 1066 if (written < 0) { 1067 err = written; 1068 goto out; 1069 } 1070 if (!written) { 1071 err = -EIO; 1072 goto out; 1073 } 1074 } 1075 } 1076 err = file_write_and_wait(f); 1077 out: 1078 revert_creds(saved_cred); 1079 kvfree(zero_buf); 1080 return err; 1081 } 1082 1083 int ksmbd_vfs_trim_data(struct ksmbd_work *work, struct ksmbd_file *fp, 1084 loff_t off, loff_t len) 1085 { 1086 const struct cred *saved_cred; 1087 int err; 1088 1089 smb_break_all_levII_oplock(work, fp, 1); 1090 if (!work->tcon->posix_extensions) { 1091 loff_t size = i_size_read(file_inode(fp->filp)); 1092 1093 if (off < size) { 1094 err = check_lock_range(fp->filp, off, 1095 min(off + len, size) - 1, 1096 WRITE); 1097 if (err) 1098 return -EAGAIN; 1099 } 1100 } 1101 1102 saved_cred = override_creds(fp->filp->f_cred); 1103 err = vfs_fallocate(fp->filp, 1104 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 1105 off, len); 1106 revert_creds(saved_cred); 1107 return err; 1108 } 1109 1110 int ksmbd_vfs_query_allocated_ranges(struct ksmbd_file *fp, loff_t start, 1111 loff_t length, 1112 struct file_allocated_range_buffer *ranges, 1113 unsigned int in_count, 1114 unsigned int *out_count) 1115 { 1116 struct file *f = fp->filp; 1117 struct inode *inode = file_inode(fp->filp); 1118 loff_t maxbytes = inode->i_sb->s_maxbytes, size; 1119 loff_t extent_start, extent_end, end; 1120 int ret = 0; 1121 1122 *out_count = 0; 1123 if (start < 0 || length < 0) 1124 return -EINVAL; 1125 if (start > maxbytes) 1126 return -EFBIG; 1127 if (!in_count) 1128 return 0; 1129 if (length > maxbytes || maxbytes - length < start) 1130 length = maxbytes - start; 1131 size = i_size_read(inode); 1132 if (!length || start >= size) 1133 return 0; 1134 if (length > size - start) 1135 length = size - start; 1136 1137 end = start + length; 1138 if ((fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE) && 1139 start < end) { 1140 ret = file_write_and_wait_range(f, start, end - 1); 1141 if (ret) 1142 return ret; 1143 } 1144 1145 while (start < end && *out_count < in_count) { 1146 extent_start = vfs_llseek(f, start, SEEK_DATA); 1147 if (extent_start < 0) { 1148 if (extent_start != -ENXIO) 1149 ret = extent_start; 1150 break; 1151 } 1152 1153 if (extent_start >= end) 1154 break; 1155 1156 extent_end = vfs_llseek(f, extent_start, SEEK_HOLE); 1157 if (extent_end < 0) { 1158 if (extent_end != -ENXIO) 1159 ret = extent_end; 1160 break; 1161 } else if (extent_start >= extent_end) { 1162 break; 1163 } 1164 1165 ranges[*out_count].file_offset = cpu_to_le64(extent_start); 1166 ranges[(*out_count)++].length = 1167 cpu_to_le64(min(extent_end, end) - extent_start); 1168 start = extent_end; 1169 } 1170 1171 if (!ret && start < end && *out_count == in_count) 1172 ret = -E2BIG; 1173 1174 return ret; 1175 } 1176 1177 int ksmbd_vfs_remove_xattr(struct mnt_idmap *idmap, 1178 const struct path *path, char *attr_name, 1179 bool get_write) 1180 { 1181 int err; 1182 1183 if (get_write == true) { 1184 err = mnt_want_write(path->mnt); 1185 if (err) 1186 return err; 1187 } 1188 1189 err = vfs_removexattr(idmap, path->dentry, attr_name); 1190 1191 if (get_write == true) 1192 mnt_drop_write(path->mnt); 1193 1194 return err; 1195 } 1196 1197 int ksmbd_vfs_unlink(struct file *filp) 1198 { 1199 const struct cred *saved_cred; 1200 int err = 0; 1201 struct dentry *dir, *dentry = filp->f_path.dentry; 1202 struct mnt_idmap *idmap = file_mnt_idmap(filp); 1203 1204 saved_cred = override_creds(filp->f_cred); 1205 err = mnt_want_write(filp->f_path.mnt); 1206 if (err) 1207 goto out_revert; 1208 1209 dir = dget_parent(dentry); 1210 dentry = start_removing_dentry(dir, dentry); 1211 err = PTR_ERR(dentry); 1212 if (IS_ERR(dentry)) 1213 goto out; 1214 1215 if (S_ISDIR(d_inode(dentry)->i_mode)) 1216 err = vfs_rmdir(idmap, d_inode(dir), dentry, NULL); 1217 else 1218 err = vfs_unlink(idmap, d_inode(dir), dentry, NULL); 1219 1220 end_removing(dentry); 1221 if (err) 1222 ksmbd_debug(VFS, "failed to delete, err %d\n", err); 1223 out: 1224 dput(dir); 1225 mnt_drop_write(filp->f_path.mnt); 1226 out_revert: 1227 revert_creds(saved_cred); 1228 return err; 1229 } 1230 1231 static bool __dir_empty(struct dir_context *ctx, const char *name, int namlen, 1232 loff_t offset, u64 ino, unsigned int d_type) 1233 { 1234 struct ksmbd_readdir_data *buf; 1235 1236 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1237 if (!name_is_dot_dotdot(name, namlen)) 1238 buf->dirent_count++; 1239 1240 return !buf->dirent_count; 1241 } 1242 1243 /** 1244 * ksmbd_vfs_empty_dir() - check for empty directory 1245 * @fp: ksmbd file pointer 1246 * 1247 * Return: true if directory empty, otherwise false 1248 */ 1249 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp) 1250 { 1251 int err; 1252 struct ksmbd_readdir_data readdir_data; 1253 1254 memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data)); 1255 1256 set_ctx_actor(&readdir_data.ctx, __dir_empty); 1257 readdir_data.dirent_count = 0; 1258 1259 err = iterate_dir(fp->filp, &readdir_data.ctx); 1260 if (readdir_data.dirent_count) 1261 err = -ENOTEMPTY; 1262 else 1263 err = 0; 1264 return err; 1265 } 1266 1267 static bool __caseless_lookup(struct dir_context *ctx, const char *name, 1268 int namlen, loff_t offset, u64 ino, 1269 unsigned int d_type) 1270 { 1271 struct ksmbd_readdir_data *buf; 1272 int cmp = -EINVAL; 1273 1274 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1275 1276 if (buf->used != namlen) 1277 return true; 1278 if (IS_ENABLED(CONFIG_UNICODE) && buf->um) { 1279 const struct qstr q_buf = {.name = buf->private, 1280 .len = buf->used}; 1281 const struct qstr q_name = {.name = name, 1282 .len = namlen}; 1283 1284 cmp = utf8_strncasecmp(buf->um, &q_buf, &q_name); 1285 } 1286 if (cmp < 0) 1287 cmp = strncasecmp((char *)buf->private, name, namlen); 1288 if (!cmp) { 1289 memcpy((char *)buf->private, name, buf->used); 1290 buf->dirent_count = 1; 1291 return false; 1292 } 1293 return true; 1294 } 1295 1296 /** 1297 * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory 1298 * @dir: path info 1299 * @name: filename to lookup 1300 * @namelen: filename length 1301 * @um: &struct unicode_map to use 1302 * 1303 * Return: 0 on success, otherwise error 1304 */ 1305 static int ksmbd_vfs_lookup_in_dir(const struct path *dir, char *name, 1306 size_t namelen, struct unicode_map *um) 1307 { 1308 int ret; 1309 struct file *dfilp; 1310 int flags = O_RDONLY | O_LARGEFILE; 1311 struct ksmbd_readdir_data readdir_data = { 1312 .ctx.actor = __caseless_lookup, 1313 .private = name, 1314 .used = namelen, 1315 .dirent_count = 0, 1316 .um = um, 1317 }; 1318 1319 dfilp = dentry_open(dir, flags, current_cred()); 1320 if (IS_ERR(dfilp)) 1321 return PTR_ERR(dfilp); 1322 1323 ret = iterate_dir(dfilp, &readdir_data.ctx); 1324 if (readdir_data.dirent_count > 0) 1325 ret = 0; 1326 fput(dfilp); 1327 return ret; 1328 } 1329 1330 static 1331 int __ksmbd_vfs_kern_path(struct ksmbd_work *work, char *filepath, 1332 unsigned int flags, 1333 struct path *path, bool caseless, bool for_remove) 1334 { 1335 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1336 struct path parent_path; 1337 size_t path_len, remain_len; 1338 int err; 1339 1340 retry: 1341 err = ksmbd_vfs_path_lookup(share_conf, filepath, flags, path, for_remove); 1342 if (!err || err != -ENOENT || !caseless) 1343 return err; 1344 1345 path_len = strlen(filepath); 1346 remain_len = path_len; 1347 1348 parent_path = share_conf->vfs_path; 1349 path_get(&parent_path); 1350 1351 while (d_can_lookup(parent_path.dentry)) { 1352 char *filename = filepath + path_len - remain_len; 1353 char *next = strchrnul(filename, '/'); 1354 size_t filename_len = next - filename; 1355 bool is_last = !next[0]; 1356 1357 if (filename_len == 0) 1358 break; 1359 1360 err = ksmbd_vfs_lookup_in_dir(&parent_path, filename, 1361 filename_len, 1362 work->conn->um); 1363 path_put(&parent_path); 1364 if (err) 1365 goto out; 1366 if (is_last) { 1367 caseless = false; 1368 goto retry; 1369 } 1370 next[0] = '\0'; 1371 1372 err = vfs_path_lookup(share_conf->vfs_path.dentry, 1373 share_conf->vfs_path.mnt, 1374 filepath, 1375 flags, 1376 &parent_path); 1377 next[0] = '/'; 1378 if (err) 1379 goto out; 1380 1381 remain_len -= filename_len + 1; 1382 } 1383 1384 err = -EINVAL; 1385 path_put(&parent_path); 1386 out: 1387 return err; 1388 } 1389 1390 /** 1391 * ksmbd_vfs_kern_path() - lookup a file and get path info 1392 * @work: work 1393 * @filepath: file path that is relative to share 1394 * @flags: lookup flags 1395 * @path: if lookup succeed, return path info 1396 * @caseless: caseless filename lookup 1397 * 1398 * Perform the lookup, possibly crossing over any mount point. 1399 * On return no locks will be held and write-access to filesystem 1400 * won't have been checked. 1401 * Return: 0 if file was found, otherwise error 1402 */ 1403 int ksmbd_vfs_kern_path(struct ksmbd_work *work, char *filepath, 1404 unsigned int flags, 1405 struct path *path, bool caseless) 1406 { 1407 return __ksmbd_vfs_kern_path(work, filepath, flags, path, 1408 caseless, false); 1409 } 1410 1411 /** 1412 * ksmbd_vfs_kern_path_start_removing() - lookup a file and get path info prior to removal 1413 * @work: work 1414 * @filepath: file path that is relative to share 1415 * @flags: lookup flags 1416 * @path: if lookup succeed, return path info 1417 * @caseless: caseless filename lookup 1418 * 1419 * Perform the lookup, but don't cross over any mount point. 1420 * On return the parent of path->dentry will be locked and write-access to 1421 * filesystem will have been gained. 1422 * Return: 0 on if file was found, otherwise error 1423 */ 1424 int ksmbd_vfs_kern_path_start_removing(struct ksmbd_work *work, char *filepath, 1425 unsigned int flags, 1426 struct path *path, bool caseless) 1427 { 1428 return __ksmbd_vfs_kern_path(work, filepath, flags, path, 1429 caseless, true); 1430 } 1431 1432 void ksmbd_vfs_kern_path_end_removing(const struct path *path) 1433 { 1434 end_removing(path->dentry); 1435 mnt_drop_write(path->mnt); 1436 mntput(path->mnt); 1437 } 1438 1439 struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work, 1440 const char *name, 1441 unsigned int flags, 1442 struct path *path) 1443 { 1444 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1445 struct qstr last; 1446 struct dentry *dent; 1447 int err; 1448 1449 /* resolve the name beneath the share root so ".." cannot escape */ 1450 CLASS(filename_kernel, filename)(name); 1451 1452 err = vfs_path_parent_lookup(filename, flags | LOOKUP_BENEATH, 1453 path, &last, &share_conf->vfs_path); 1454 if (err) 1455 return ERR_PTR(err); 1456 1457 err = mnt_want_write(path->mnt); 1458 if (err) { 1459 path_put(path); 1460 return ERR_PTR(err); 1461 } 1462 1463 dent = start_creating_noperm(path->dentry, &last); 1464 if (IS_ERR(dent)) { 1465 mnt_drop_write(path->mnt); 1466 path_put(path); 1467 } 1468 return dent; 1469 } 1470 1471 int ksmbd_vfs_remove_acl_xattrs(struct mnt_idmap *idmap, 1472 const struct path *path) 1473 { 1474 char *name, *xattr_list = NULL; 1475 ssize_t xattr_list_len; 1476 int err = 0; 1477 1478 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1479 if (xattr_list_len < 0) { 1480 goto out; 1481 } else if (!xattr_list_len) { 1482 ksmbd_debug(SMB, "empty xattr in the file\n"); 1483 goto out; 1484 } 1485 1486 err = mnt_want_write(path->mnt); 1487 if (err) 1488 goto out; 1489 1490 for (name = xattr_list; name - xattr_list < xattr_list_len; 1491 name += strlen(name) + 1) { 1492 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1493 1494 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, 1495 sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) || 1496 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, 1497 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) { 1498 err = vfs_remove_acl(idmap, path->dentry, name); 1499 if (err) 1500 ksmbd_debug(SMB, 1501 "remove acl xattr failed : %s\n", name); 1502 } 1503 } 1504 mnt_drop_write(path->mnt); 1505 1506 out: 1507 kvfree(xattr_list); 1508 return err; 1509 } 1510 1511 int ksmbd_vfs_remove_sd_xattrs(struct mnt_idmap *idmap, const struct path *path) 1512 { 1513 char *name, *xattr_list = NULL; 1514 ssize_t xattr_list_len; 1515 int err = 0; 1516 1517 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1518 if (xattr_list_len < 0) { 1519 goto out; 1520 } else if (!xattr_list_len) { 1521 ksmbd_debug(SMB, "empty xattr in the file\n"); 1522 goto out; 1523 } 1524 1525 for (name = xattr_list; name - xattr_list < xattr_list_len; 1526 name += strlen(name) + 1) { 1527 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1528 1529 if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) { 1530 err = ksmbd_vfs_remove_xattr(idmap, path, name, true); 1531 if (err) 1532 ksmbd_debug(SMB, "remove xattr failed : %s\n", name); 1533 } 1534 } 1535 out: 1536 kvfree(xattr_list); 1537 return err; 1538 } 1539 1540 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct mnt_idmap *idmap, 1541 struct inode *inode, 1542 int acl_type) 1543 { 1544 struct xattr_smb_acl *smb_acl = NULL; 1545 struct posix_acl *posix_acls; 1546 struct posix_acl_entry *pa_entry; 1547 struct xattr_acl_entry *xa_entry; 1548 int i; 1549 1550 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1551 return NULL; 1552 1553 posix_acls = get_inode_acl(inode, acl_type); 1554 if (IS_ERR_OR_NULL(posix_acls)) 1555 return NULL; 1556 1557 smb_acl = kzalloc(sizeof(struct xattr_smb_acl) + 1558 sizeof(struct xattr_acl_entry) * posix_acls->a_count, 1559 KSMBD_DEFAULT_GFP); 1560 if (!smb_acl) 1561 goto out; 1562 1563 smb_acl->count = posix_acls->a_count; 1564 pa_entry = posix_acls->a_entries; 1565 xa_entry = smb_acl->entries; 1566 for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) { 1567 switch (pa_entry->e_tag) { 1568 case ACL_USER: 1569 xa_entry->type = SMB_ACL_USER; 1570 xa_entry->uid = posix_acl_uid_translate(idmap, pa_entry); 1571 break; 1572 case ACL_USER_OBJ: 1573 xa_entry->type = SMB_ACL_USER_OBJ; 1574 break; 1575 case ACL_GROUP: 1576 xa_entry->type = SMB_ACL_GROUP; 1577 xa_entry->gid = posix_acl_gid_translate(idmap, pa_entry); 1578 break; 1579 case ACL_GROUP_OBJ: 1580 xa_entry->type = SMB_ACL_GROUP_OBJ; 1581 break; 1582 case ACL_OTHER: 1583 xa_entry->type = SMB_ACL_OTHER; 1584 break; 1585 case ACL_MASK: 1586 xa_entry->type = SMB_ACL_MASK; 1587 break; 1588 default: 1589 pr_err("unknown type : 0x%x\n", pa_entry->e_tag); 1590 goto out; 1591 } 1592 1593 if (pa_entry->e_perm & ACL_READ) 1594 xa_entry->perm |= SMB_ACL_READ; 1595 if (pa_entry->e_perm & ACL_WRITE) 1596 xa_entry->perm |= SMB_ACL_WRITE; 1597 if (pa_entry->e_perm & ACL_EXECUTE) 1598 xa_entry->perm |= SMB_ACL_EXECUTE; 1599 } 1600 out: 1601 posix_acl_release(posix_acls); 1602 return smb_acl; 1603 } 1604 1605 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, 1606 struct mnt_idmap *idmap, 1607 const struct path *path, 1608 struct smb_ntsd *pntsd, int len, 1609 bool get_write) 1610 { 1611 int rc; 1612 struct ndr sd_ndr = {0}, acl_ndr = {0}; 1613 struct xattr_ntacl acl = {0}; 1614 struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL; 1615 struct dentry *dentry = path->dentry; 1616 struct inode *inode = d_inode(dentry); 1617 1618 acl.version = 4; 1619 acl.hash_type = XATTR_SD_HASH_TYPE_SHA256; 1620 acl.current_time = ksmbd_UnixTimeToNT(current_time(inode)); 1621 1622 memcpy(acl.desc, "posix_acl", 9); 1623 acl.desc_len = 10; 1624 1625 pntsd->osidoffset = 1626 cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF); 1627 pntsd->gsidoffset = 1628 cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF); 1629 pntsd->dacloffset = 1630 cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF); 1631 1632 acl.sd_buf = (char *)pntsd; 1633 acl.sd_size = len; 1634 1635 sha256(acl.sd_buf, acl.sd_size, acl.hash); 1636 1637 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1638 ACL_TYPE_ACCESS); 1639 if (S_ISDIR(inode->i_mode)) 1640 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1641 ACL_TYPE_DEFAULT); 1642 1643 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, 1644 smb_acl, def_smb_acl); 1645 if (rc) { 1646 pr_err("failed to encode ndr to posix acl\n"); 1647 goto out; 1648 } 1649 1650 sha256(acl_ndr.data, acl_ndr.offset, acl.posix_acl_hash); 1651 1652 rc = ndr_encode_v4_ntacl(&sd_ndr, &acl); 1653 if (rc) { 1654 pr_err("failed to encode ndr to posix acl\n"); 1655 goto out; 1656 } 1657 1658 rc = ksmbd_vfs_setxattr(idmap, path, 1659 XATTR_NAME_SD, sd_ndr.data, 1660 sd_ndr.offset, 0, get_write); 1661 if (rc < 0) 1662 pr_err("Failed to store XATTR ntacl :%d\n", rc); 1663 1664 out: 1665 kfree(sd_ndr.data); 1666 kfree(acl_ndr.data); 1667 kfree(smb_acl); 1668 kfree(def_smb_acl); 1669 return rc; 1670 } 1671 1672 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, 1673 struct mnt_idmap *idmap, 1674 struct dentry *dentry, 1675 struct smb_ntsd **pntsd) 1676 { 1677 int rc; 1678 struct ndr n; 1679 struct inode *inode = d_inode(dentry); 1680 struct ndr acl_ndr = {0}; 1681 struct xattr_ntacl acl = {0}; 1682 struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL; 1683 __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0}; 1684 1685 rc = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_SD, &n.data); 1686 if (rc <= 0) 1687 return rc; 1688 1689 n.length = rc; 1690 rc = ndr_decode_v4_ntacl(&n, &acl); 1691 if (rc) 1692 goto out_free; 1693 1694 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1695 ACL_TYPE_ACCESS); 1696 if (S_ISDIR(inode->i_mode)) 1697 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1698 ACL_TYPE_DEFAULT); 1699 1700 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, smb_acl, 1701 def_smb_acl); 1702 if (rc) { 1703 pr_err("failed to encode ndr to posix acl\n"); 1704 goto out_free; 1705 } 1706 1707 sha256(acl_ndr.data, acl_ndr.offset, cmp_hash); 1708 1709 if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) { 1710 pr_err("hash value diff\n"); 1711 rc = -EINVAL; 1712 goto out_free; 1713 } 1714 1715 *pntsd = acl.sd_buf; 1716 if (acl.sd_size < sizeof(struct smb_ntsd)) { 1717 pr_err("sd size is invalid\n"); 1718 rc = -EINVAL; 1719 goto out_free; 1720 } 1721 1722 (*pntsd)->osidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) - 1723 NDR_NTSD_OFFSETOF); 1724 (*pntsd)->gsidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) - 1725 NDR_NTSD_OFFSETOF); 1726 (*pntsd)->dacloffset = cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) - 1727 NDR_NTSD_OFFSETOF); 1728 1729 rc = acl.sd_size; 1730 out_free: 1731 kfree(acl_ndr.data); 1732 kfree(smb_acl); 1733 kfree(def_smb_acl); 1734 if (rc < 0) { 1735 kfree(acl.sd_buf); 1736 *pntsd = NULL; 1737 } 1738 kfree(n.data); 1739 return rc; 1740 } 1741 1742 int ksmbd_vfs_set_dos_attrib_xattr(struct mnt_idmap *idmap, 1743 const struct path *path, 1744 struct xattr_dos_attrib *da, 1745 bool get_write) 1746 { 1747 struct ndr n; 1748 int err; 1749 1750 err = ndr_encode_dos_attr(&n, da); 1751 if (err) 1752 goto out; 1753 1754 err = ksmbd_vfs_setxattr(idmap, path, XATTR_NAME_DOS_ATTRIBUTE, 1755 (void *)n.data, n.offset, 0, get_write); 1756 if (err) 1757 ksmbd_debug(SMB, "failed to store dos attribute in xattr\n"); 1758 1759 out: 1760 kfree(n.data); 1761 return err; 1762 } 1763 1764 int ksmbd_vfs_get_dos_attrib_xattr(struct mnt_idmap *idmap, 1765 struct dentry *dentry, 1766 struct xattr_dos_attrib *da) 1767 { 1768 struct ndr n; 1769 int err; 1770 1771 err = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_DOS_ATTRIBUTE, 1772 (char **)&n.data); 1773 if (err > 0) { 1774 n.length = err; 1775 if (ndr_decode_dos_attr(&n, da)) 1776 err = -EINVAL; 1777 kfree(n.data); 1778 } else { 1779 ksmbd_debug(SMB, "failed to load dos attribute in xattr\n"); 1780 } 1781 1782 return err; 1783 } 1784 1785 /** 1786 * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format 1787 * @p: destination buffer 1788 * @ksmbd_kstat: ksmbd kstat wrapper 1789 * 1790 * Returns: pointer to the converted &struct file_directory_info 1791 */ 1792 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat) 1793 { 1794 FILE_DIRECTORY_INFO *info = (FILE_DIRECTORY_INFO *)(*p); 1795 struct kstat *kstat = ksmbd_kstat->kstat; 1796 u64 time; 1797 1798 info->FileIndex = 0; 1799 info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time); 1800 time = ksmbd_UnixTimeToNT(kstat->atime); 1801 info->LastAccessTime = cpu_to_le64(time); 1802 time = ksmbd_UnixTimeToNT(kstat->mtime); 1803 info->LastWriteTime = cpu_to_le64(time); 1804 time = ksmbd_UnixTimeToNT(kstat->ctime); 1805 info->ChangeTime = cpu_to_le64(time); 1806 1807 if (ksmbd_kstat->file_attributes & FILE_ATTRIBUTE_DIRECTORY_LE) { 1808 info->EndOfFile = 0; 1809 info->AllocationSize = 0; 1810 } else { 1811 info->EndOfFile = cpu_to_le64(kstat->size); 1812 info->AllocationSize = cpu_to_le64(kstat->blocks << 9); 1813 } 1814 info->ExtFileAttributes = ksmbd_kstat->file_attributes; 1815 1816 return info; 1817 } 1818 1819 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, 1820 struct mnt_idmap *idmap, 1821 struct dentry *dentry, 1822 struct ksmbd_kstat *ksmbd_kstat) 1823 { 1824 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1825 u64 time; 1826 int rc; 1827 struct path path = { 1828 .mnt = share_conf->vfs_path.mnt, 1829 .dentry = dentry, 1830 }; 1831 1832 rc = vfs_getattr(&path, ksmbd_kstat->kstat, 1833 STATX_BASIC_STATS | STATX_BTIME, 1834 AT_STATX_SYNC_AS_STAT); 1835 if (rc) 1836 return rc; 1837 1838 time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime); 1839 ksmbd_kstat->create_time = time; 1840 1841 /* 1842 * set default value for the case that store dos attributes is not yes 1843 * or that acl is disable in server's filesystem and the config is yes. 1844 */ 1845 if (S_ISDIR(ksmbd_kstat->kstat->mode)) 1846 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_DIRECTORY_LE; 1847 else 1848 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_ARCHIVE_LE; 1849 1850 if (test_share_config_flag(work->tcon->share_conf, 1851 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { 1852 struct xattr_dos_attrib da; 1853 1854 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da); 1855 if (rc > 0) { 1856 ksmbd_kstat->file_attributes = cpu_to_le32(da.attr); 1857 ksmbd_kstat->create_time = da.create_time; 1858 } else { 1859 ksmbd_debug(VFS, "fail to load dos attribute.\n"); 1860 } 1861 } 1862 1863 /* 1864 * Only pay for this when it'll actually be used: AAPL 1865 * READDIR_ATTR_V2's flags field (AAPL_READDIR_ATTR_V2_NO_XATTR) is 1866 * the only consumer. XATTR_NAME_STREAM ("user.DosStream.") is a 1867 * reliable, distinct prefix for genuine ADS/stream xattrs -- unlike 1868 * DOSATTRIB or ACL xattrs, which live under different prefixes, so 1869 * this can't false-positive into telling Finder a file has no extra 1870 * data when it actually does. 1871 */ 1872 ksmbd_kstat->has_ads_stream = false; 1873 if (work->conn->aapl_readdir_attr_v2) { 1874 char *xattr_list = NULL, *name; 1875 ssize_t xattr_list_len; 1876 1877 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 1878 if (xattr_list_len > 0) { 1879 for (name = xattr_list; 1880 name - xattr_list < xattr_list_len; 1881 name += strlen(name) + 1) { 1882 if (!strncmp(name, XATTR_NAME_STREAM, 1883 XATTR_NAME_STREAM_LEN)) { 1884 ksmbd_kstat->has_ads_stream = true; 1885 break; 1886 } 1887 } 1888 } 1889 kvfree(xattr_list); 1890 } 1891 1892 return 0; 1893 } 1894 1895 ssize_t ksmbd_vfs_casexattr_len(struct mnt_idmap *idmap, 1896 struct dentry *dentry, char *attr_name, 1897 int attr_name_len) 1898 { 1899 char *name, *xattr_list = NULL; 1900 ssize_t value_len = -ENOENT, xattr_list_len; 1901 1902 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 1903 if (xattr_list_len <= 0) 1904 goto out; 1905 1906 for (name = xattr_list; name - xattr_list < xattr_list_len; 1907 name += strlen(name) + 1) { 1908 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); 1909 if (strncasecmp(attr_name, name, attr_name_len)) 1910 continue; 1911 1912 value_len = ksmbd_vfs_xattr_len(idmap, dentry, name); 1913 break; 1914 } 1915 1916 out: 1917 kvfree(xattr_list); 1918 return value_len; 1919 } 1920 1921 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name, 1922 size_t *xattr_stream_name_size, int s_type) 1923 { 1924 char *type, *buf; 1925 1926 if (s_type == DIR_STREAM) 1927 type = ":$INDEX_ALLOCATION"; 1928 else 1929 type = ":$DATA"; 1930 1931 buf = kasprintf(KSMBD_DEFAULT_GFP, "%s%s%s", 1932 XATTR_NAME_STREAM, stream_name, type); 1933 if (!buf) 1934 return -ENOMEM; 1935 1936 *xattr_stream_name = buf; 1937 *xattr_stream_name_size = strlen(buf) + 1; 1938 1939 return 0; 1940 } 1941 1942 static ssize_t ksmbd_vfs_copy_file_range_buffered(struct ksmbd_work *work, 1943 struct ksmbd_file *src_fp, 1944 struct ksmbd_file *dst_fp, 1945 loff_t src_off, 1946 loff_t dst_off, size_t len) 1947 { 1948 size_t buf_size = min_t(size_t, len, SZ_1M); 1949 size_t copied = 0; 1950 char *buf; 1951 ssize_t ret = 0; 1952 1953 buf = kvmalloc(buf_size, KSMBD_DEFAULT_GFP); 1954 if (!buf) 1955 return -ENOMEM; 1956 1957 while (copied < len) { 1958 size_t chunk_size = min(buf_size, len - copied); 1959 size_t done = 0; 1960 loff_t src_pos, dst_pos; 1961 1962 if (dst_off > src_off) { 1963 src_pos = src_off + len - copied - chunk_size; 1964 dst_pos = dst_off + len - copied - chunk_size; 1965 } else { 1966 src_pos = src_off + copied; 1967 dst_pos = dst_off + copied; 1968 } 1969 1970 while (done < chunk_size) { 1971 loff_t pos = src_pos + done; 1972 1973 ret = ksmbd_vfs_read(work, src_fp, chunk_size - done, 1974 &pos, buf + done); 1975 if (ret <= 0) { 1976 if (!ret) 1977 ret = -EIO; 1978 goto out; 1979 } 1980 done += ret; 1981 } 1982 1983 done = 0; 1984 while (done < chunk_size) { 1985 loff_t pos = dst_pos + done; 1986 ssize_t written = 0; 1987 1988 ret = ksmbd_vfs_write(work, dst_fp, buf + done, 1989 chunk_size - done, &pos, false, 1990 &written); 1991 if (ret < 0) 1992 goto out; 1993 if (!written) { 1994 ret = -EIO; 1995 goto out; 1996 } 1997 done += written; 1998 } 1999 copied += chunk_size; 2000 } 2001 ret = copied; 2002 out: 2003 kvfree(buf); 2004 return ret; 2005 } 2006 2007 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, 2008 struct ksmbd_file *src_fp, 2009 struct ksmbd_file *dst_fp, 2010 struct srv_copychunk *chunks, 2011 unsigned int chunk_count, 2012 unsigned int *chunk_count_written, 2013 unsigned int *chunk_size_written, 2014 loff_t *total_size_written) 2015 { 2016 unsigned int i; 2017 loff_t src_off, dst_off, src_file_size; 2018 size_t len; 2019 int ret; 2020 2021 *chunk_count_written = 0; 2022 *chunk_size_written = 0; 2023 *total_size_written = 0; 2024 2025 if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 2026 pr_err("no right to read(%pD)\n", src_fp->filp); 2027 return -EACCES; 2028 } 2029 if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) { 2030 pr_err("no right to write(%pD)\n", dst_fp->filp); 2031 return -EACCES; 2032 } 2033 2034 smb_break_all_levII_oplock(work, dst_fp, 1); 2035 2036 if (!work->tcon->posix_extensions) { 2037 for (i = 0; i < chunk_count; i++) { 2038 src_off = le64_to_cpu(chunks[i].SourceOffset); 2039 dst_off = le64_to_cpu(chunks[i].TargetOffset); 2040 len = le32_to_cpu(chunks[i].Length); 2041 2042 if (check_lock_range(src_fp->filp, src_off, 2043 src_off + len - 1, READ)) 2044 return -EAGAIN; 2045 if (check_lock_range(dst_fp->filp, dst_off, 2046 dst_off + len - 1, WRITE)) 2047 return -EAGAIN; 2048 } 2049 } 2050 2051 if (ksmbd_stream_fd(src_fp)) { 2052 const struct cred *saved_cred; 2053 2054 saved_cred = override_creds(src_fp->filp->f_cred); 2055 src_file_size = ksmbd_vfs_casexattr_len( 2056 file_mnt_idmap(src_fp->filp), 2057 src_fp->filp->f_path.dentry, 2058 src_fp->stream.name, src_fp->stream.size); 2059 revert_creds(saved_cred); 2060 if (src_file_size < 0) 2061 return src_file_size; 2062 } else { 2063 src_file_size = i_size_read(file_inode(src_fp->filp)); 2064 } 2065 2066 /* 2067 * macOS Finder's Cmd+D duplicate sends FSCTL_SRV_COPYCHUNK with 2068 * ChunkCount=0 meaning "copy the whole file/stream", not the 2069 * standard SMB2 "query my copy limits, no data" semantics -- 2070 * fsctl_copychunk() only reaches here with chunk_count == 0 for 2071 * AAPL-negotiated connections, so this doesn't affect compliant 2072 * non-AAPL clients. Without this, the destination stays at its 2073 * just-created 0 bytes / empty stream: the for loop below is a 2074 * no-op when chunk_count is 0, since it never has an iteration to 2075 * treat as "copy everything". 2076 */ 2077 if (chunk_count == 0 && work->conn->is_aapl) { 2078 loff_t off = 0; 2079 2080 while (off < src_file_size) { 2081 size_t remaining = src_file_size - off; 2082 ssize_t copied; 2083 2084 /* Same source/destination offset here: an in-place, 2085 * same-inode copy at matching offsets is a degenerate 2086 * no-op range, not a real overlap, but vfs_copy_file_range 2087 * still doesn't support streams -- route those (and the 2088 * same-inode case defensively) through the buffered path. 2089 */ 2090 if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp) || 2091 file_inode(src_fp->filp) == file_inode(dst_fp->filp)) { 2092 copied = ksmbd_vfs_copy_file_range_buffered(work, src_fp, dst_fp, 2093 off, off, remaining); 2094 } else { 2095 copied = vfs_copy_file_range(src_fp->filp, off, 2096 dst_fp->filp, off, 2097 remaining, 0); 2098 if (copied == -EOPNOTSUPP || copied == -EXDEV) 2099 copied = vfs_copy_file_range(src_fp->filp, off, 2100 dst_fp->filp, off, 2101 remaining, 2102 COPY_FILE_SPLICE); 2103 } 2104 if (copied < 0) 2105 return copied; 2106 if (copied == 0) 2107 break; 2108 off += copied; 2109 } 2110 2111 /* 2112 * This is a synthesized whole-file copy, not a response to 2113 * any chunk descriptor the client actually sent (it sent 2114 * none -- chunk_count is 0). Report zero chunks/chunk-bytes 2115 * rather than inventing a chunk that doesn't correspond to 2116 * anything in the request; only total_size_written (bytes 2117 * actually copied) is meaningful here. 2118 */ 2119 *chunk_count_written = 0; 2120 *chunk_size_written = 0; 2121 *total_size_written = off; 2122 return 0; 2123 } 2124 2125 for (i = 0; i < chunk_count; i++) { 2126 bool stream_len_mismatch = false; 2127 size_t copy_len; 2128 2129 src_off = le64_to_cpu(chunks[i].SourceOffset); 2130 dst_off = le64_to_cpu(chunks[i].TargetOffset); 2131 len = le32_to_cpu(chunks[i].Length); 2132 copy_len = len; 2133 2134 if (src_off < 0) 2135 return -E2BIG; 2136 2137 if (src_off > src_file_size || len > src_file_size - src_off) { 2138 /* 2139 * macOS can reuse the main file's chunk list when copying 2140 * streams, so the requested range can exceed the size of 2141 * the xattr-backed stream. For an AAPL connection, copy the 2142 * available stream data and report the requested length to 2143 * avoid a copy length mismatch. 2144 */ 2145 if (!work->conn->is_aapl || 2146 !ksmbd_stream_fd(src_fp) || 2147 !ksmbd_stream_fd(dst_fp)) 2148 return -E2BIG; 2149 2150 stream_len_mismatch = true; 2151 if (src_off < src_file_size) 2152 copy_len = src_file_size - src_off; 2153 else 2154 copy_len = 0; 2155 } 2156 2157 /* 2158 * vfs_copy_file_range does not support streams or overlapping 2159 * ranges within the same file. 2160 */ 2161 if (!copy_len) { 2162 ret = 0; 2163 } else if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp) || 2164 (file_inode(src_fp->filp) == file_inode(dst_fp->filp) && 2165 dst_off + copy_len > src_off && 2166 dst_off < src_off + copy_len)) { 2167 ret = ksmbd_vfs_copy_file_range_buffered(work, src_fp, 2168 dst_fp, src_off, 2169 dst_off, copy_len); 2170 } else { 2171 ret = vfs_copy_file_range(src_fp->filp, src_off, 2172 dst_fp->filp, dst_off, copy_len, 0); 2173 if (ret == -EOPNOTSUPP || ret == -EXDEV) 2174 ret = vfs_copy_file_range(src_fp->filp, src_off, 2175 dst_fp->filp, dst_off, 2176 copy_len, 2177 COPY_FILE_SPLICE); 2178 } 2179 if (ret < 0) 2180 return ret; 2181 if (stream_len_mismatch) 2182 ret = len; 2183 2184 *chunk_count_written += 1; 2185 *total_size_written += ret; 2186 } 2187 return 0; 2188 } 2189 2190 void ksmbd_vfs_posix_lock_wait(struct file_lock *flock) 2191 { 2192 wait_event(flock->c.flc_wait, !flock->c.flc_blocker); 2193 } 2194 2195 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock) 2196 { 2197 locks_delete_block(flock); 2198 } 2199 2200 int ksmbd_vfs_set_init_posix_acl(struct mnt_idmap *idmap, 2201 const struct path *path) 2202 { 2203 struct posix_acl_state acl_state; 2204 struct posix_acl *acls; 2205 struct dentry *dentry = path->dentry; 2206 struct inode *inode = d_inode(dentry); 2207 int rc; 2208 2209 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 2210 return -EOPNOTSUPP; 2211 2212 ksmbd_debug(SMB, "Set posix acls\n"); 2213 rc = init_acl_state(&acl_state, 1); 2214 if (rc) 2215 return rc; 2216 2217 /* Set default owner group */ 2218 acl_state.owner.allow = (inode->i_mode & 0700) >> 6; 2219 acl_state.group.allow = (inode->i_mode & 0070) >> 3; 2220 acl_state.other.allow = inode->i_mode & 0007; 2221 acl_state.users->aces[acl_state.users->n].uid = inode->i_uid; 2222 acl_state.users->aces[acl_state.users->n++].perms.allow = 2223 acl_state.owner.allow; 2224 acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid; 2225 acl_state.groups->aces[acl_state.groups->n++].perms.allow = 2226 acl_state.group.allow; 2227 acl_state.mask.allow = 0x07; 2228 2229 acls = posix_acl_alloc(6, KSMBD_DEFAULT_GFP); 2230 if (!acls) { 2231 free_acl_state(&acl_state); 2232 return -ENOMEM; 2233 } 2234 posix_state_to_acl(&acl_state, acls->a_entries); 2235 2236 rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls); 2237 if (rc < 0) 2238 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 2239 rc); 2240 else if (S_ISDIR(inode->i_mode)) { 2241 posix_state_to_acl(&acl_state, acls->a_entries); 2242 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, acls); 2243 if (rc < 0) 2244 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 2245 rc); 2246 } 2247 2248 free_acl_state(&acl_state); 2249 posix_acl_release(acls); 2250 return rc; 2251 } 2252 2253 int ksmbd_vfs_inherit_posix_acl(struct mnt_idmap *idmap, 2254 const struct path *path, struct inode *parent_inode) 2255 { 2256 struct posix_acl *acls; 2257 2258 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 2259 return -EOPNOTSUPP; 2260 2261 acls = get_inode_acl(parent_inode, ACL_TYPE_DEFAULT); 2262 if (IS_ERR_OR_NULL(acls)) 2263 return -ENOENT; 2264 2265 posix_acl_release(acls); 2266 return 0; 2267 } 2268 2269 void ksmbd_vfs_update_compressed_fattr(struct dentry *dentry, __le32 *fattr) 2270 { 2271 int rc; 2272 struct file_kattr fa = { .flags_valid = true }; 2273 2274 rc = vfs_fileattr_get(dentry, &fa); 2275 if (rc) 2276 return; 2277 2278 if (fa.flags & FS_COMPR_FL) 2279 *fattr |= FILE_ATTRIBUTE_COMPRESSED_LE; 2280 } 2281 2282 int ksmbd_vfs_get_compression(struct ksmbd_file *fp, u16 *fmt) 2283 { 2284 struct file_kattr fa = { .flags_valid = true }; 2285 int rc; 2286 2287 rc = vfs_fileattr_get(fp->filp->f_path.dentry, &fa); 2288 if (rc == -ENOIOCTLCMD || rc == -ENOTTY || rc == -EINVAL || 2289 rc == -EOPNOTSUPP) { 2290 if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_COMPRESSED_LE) 2291 *fmt = COMPRESSION_FORMAT_LZNT1; 2292 else 2293 *fmt = COMPRESSION_FORMAT_NONE; 2294 rc = 0; 2295 goto out; 2296 } 2297 if (rc) 2298 goto out; 2299 2300 if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_COMPRESSED_LE) 2301 *fmt = COMPRESSION_FORMAT_LZNT1; 2302 else 2303 *fmt = COMPRESSION_FORMAT_NONE; 2304 2305 out: 2306 return rc; 2307 } 2308 2309 static int __ksmbd_vfs_set_compression(struct ksmbd_work *work, 2310 struct ksmbd_file *fp, u16 fmt, 2311 bool check_access) 2312 { 2313 const struct cred *saved_cred = NULL; 2314 struct file_kattr fa; 2315 struct dentry *dentry = fp->filp->f_path.dentry; 2316 struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 2317 u32 flags; 2318 __le32 old_fattr; 2319 int rc; 2320 2321 if (check_access && !(fp->daccess & FILE_WRITE_DATA_LE)) { 2322 rc = -EACCES; 2323 goto out; 2324 } 2325 2326 if (fmt != COMPRESSION_FORMAT_NONE && 2327 fmt != COMPRESSION_FORMAT_DEFAULT && 2328 fmt != COMPRESSION_FORMAT_LZNT1) { 2329 rc = -EINVAL; 2330 goto out; 2331 } 2332 2333 saved_cred = override_creds(fp->filp->f_cred); 2334 rc = vfs_fileattr_get(dentry, &fa); 2335 if (rc == -ENOIOCTLCMD || rc == -ENOTTY || rc == -EINVAL || 2336 rc == -EOPNOTSUPP) 2337 goto update_fattr; 2338 if (rc) 2339 goto out; 2340 2341 flags = fa.flags; 2342 if (fmt == COMPRESSION_FORMAT_NONE) { 2343 flags &= ~FS_COMPR_FL; 2344 } else if (fmt == COMPRESSION_FORMAT_DEFAULT || 2345 fmt == COMPRESSION_FORMAT_LZNT1) { 2346 flags |= FS_COMPR_FL; 2347 } 2348 2349 if (flags != fa.flags) { 2350 fileattr_fill_flags(&fa, flags); 2351 rc = mnt_want_write_file(fp->filp); 2352 if (rc) 2353 goto out; 2354 2355 rc = vfs_fileattr_set(idmap, dentry, &fa); 2356 mnt_drop_write_file(fp->filp); 2357 if (rc == -ENOIOCTLCMD || rc == -ENOTTY || rc == -EINVAL || 2358 rc == -EOPNOTSUPP) 2359 goto update_fattr; 2360 if (rc) 2361 goto out; 2362 } 2363 2364 update_fattr: 2365 old_fattr = fp->f_ci->m_fattr; 2366 if (fmt == COMPRESSION_FORMAT_NONE) 2367 fp->f_ci->m_fattr &= ~FILE_ATTRIBUTE_COMPRESSED_LE; 2368 else 2369 fp->f_ci->m_fattr |= FILE_ATTRIBUTE_COMPRESSED_LE; 2370 2371 if (fp->f_ci->m_fattr != old_fattr) { 2372 struct xattr_dos_attrib da = {0}; 2373 2374 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da); 2375 if (rc <= 0) { 2376 da.version = 4; 2377 da.itime = fp->itime; 2378 da.create_time = fp->create_time; 2379 da.flags = XATTR_DOSINFO_CREATE_TIME | 2380 XATTR_DOSINFO_ITIME; 2381 } 2382 2383 da.attr = le32_to_cpu(fp->f_ci->m_fattr); 2384 da.flags |= XATTR_DOSINFO_ATTRIB; 2385 rc = ksmbd_vfs_set_dos_attrib_xattr(idmap, 2386 &fp->filp->f_path, 2387 &da, true); 2388 if (rc) 2389 rc = 0; 2390 } 2391 2392 out: 2393 if (saved_cred) 2394 revert_creds(saved_cred); 2395 return rc; 2396 } 2397 2398 int ksmbd_vfs_set_compression(struct ksmbd_work *work, 2399 struct ksmbd_file *fp, u16 fmt) 2400 { 2401 return __ksmbd_vfs_set_compression(work, fp, fmt, true); 2402 } 2403 2404 int ksmbd_vfs_set_compression_create(struct ksmbd_work *work, 2405 struct ksmbd_file *fp, u16 fmt) 2406 { 2407 return __ksmbd_vfs_set_compression(work, fp, fmt, false); 2408 } 2409