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