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/vmalloc.h> 20 #include <linux/sched/xacct.h> 21 #include <linux/crc32c.h> 22 #include <linux/splice.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 (start == end) 301 return 0; 302 303 if (!ctx || list_empty_careful(&ctx->flc_posix)) 304 return 0; 305 306 spin_lock(&ctx->flc_lock); 307 for_each_file_lock(flock, &ctx->flc_posix) { 308 /* check conflict locks */ 309 if (flock->fl_end >= start && end >= flock->fl_start) { 310 if (lock_is_read(flock)) { 311 if (type == WRITE) { 312 pr_err("not allow write by shared lock\n"); 313 error = 1; 314 goto out; 315 } 316 } else if (lock_is_write(flock)) { 317 /* check owner in lock */ 318 if (flock->c.flc_file != filp) { 319 error = 1; 320 pr_err("not allow rw access by exclusive lock from other opens\n"); 321 goto out; 322 } 323 } 324 } 325 } 326 out: 327 spin_unlock(&ctx->flc_lock); 328 return error; 329 } 330 331 /** 332 * ksmbd_vfs_read() - vfs helper for smb file read 333 * @work: smb work 334 * @fp: ksmbd file pointer 335 * @count: read byte count 336 * @pos: file pos 337 * @rbuf: read data buffer 338 * 339 * Return: number of read bytes on success, otherwise error 340 */ 341 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count, 342 loff_t *pos, char *rbuf) 343 { 344 struct file *filp = fp->filp; 345 ssize_t nbytes = 0; 346 struct inode *inode = file_inode(filp); 347 348 if (S_ISDIR(inode->i_mode)) 349 return -EISDIR; 350 351 if (unlikely(count == 0)) 352 return 0; 353 354 if (work->conn->connection_type) { 355 if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 356 pr_err("no right to read(%pD)\n", fp->filp); 357 return -EACCES; 358 } 359 } 360 361 if (ksmbd_stream_fd(fp)) 362 return ksmbd_vfs_stream_read(fp, rbuf, pos, count); 363 364 if (!work->tcon->posix_extensions) { 365 int ret; 366 367 ret = check_lock_range(filp, *pos, *pos + count - 1, READ); 368 if (ret) { 369 pr_err("unable to read due to lock\n"); 370 return -EAGAIN; 371 } 372 } 373 374 nbytes = kernel_read(filp, rbuf, count, pos); 375 if (nbytes < 0) { 376 pr_err("smb read failed, err = %zd\n", nbytes); 377 return nbytes; 378 } 379 380 filp->f_pos = *pos; 381 ksmbd_counter_add(KSMBD_COUNTER_READ_BYTES, (s64)nbytes); 382 return nbytes; 383 } 384 385 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos, 386 size_t count) 387 { 388 const struct cred *saved_cred; 389 char *stream_buf = NULL, *wbuf; 390 struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 391 size_t size; 392 ssize_t v_len; 393 int err = 0; 394 395 ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n", 396 *pos, count); 397 398 if (*pos >= XATTR_SIZE_MAX) { 399 pr_err("stream write position %lld is out of bounds\n", *pos); 400 return -EINVAL; 401 } 402 403 size = *pos + count; 404 if (size > XATTR_SIZE_MAX) { 405 size = XATTR_SIZE_MAX; 406 count = XATTR_SIZE_MAX - *pos; 407 } 408 409 saved_cred = override_creds(fp->filp->f_cred); 410 v_len = ksmbd_vfs_getcasexattr(idmap, 411 fp->filp->f_path.dentry, 412 fp->stream.name, 413 fp->stream.size, 414 &stream_buf); 415 if (v_len < 0) { 416 pr_err("not found stream in xattr : %zd\n", v_len); 417 err = v_len; 418 goto out_revert; 419 } 420 421 if (v_len < size) { 422 wbuf = kvzalloc(size, KSMBD_DEFAULT_GFP); 423 if (!wbuf) { 424 err = -ENOMEM; 425 goto out_revert; 426 } 427 428 if (v_len > 0) 429 memcpy(wbuf, stream_buf, v_len); 430 kvfree(stream_buf); 431 stream_buf = wbuf; 432 } 433 434 memcpy(&stream_buf[*pos], buf, count); 435 436 err = ksmbd_vfs_setxattr(idmap, 437 &fp->filp->f_path, 438 fp->stream.name, 439 (void *)stream_buf, 440 size, 441 0, 442 true); 443 out_revert: 444 revert_creds(saved_cred); 445 if (err < 0) 446 goto out; 447 else 448 fp->stream.pos = size; 449 err = 0; 450 out: 451 kvfree(stream_buf); 452 return err; 453 } 454 455 /** 456 * ksmbd_vfs_write() - vfs helper for smb file write 457 * @work: work 458 * @fp: ksmbd file pointer 459 * @buf: buf containing data for writing 460 * @count: read byte count 461 * @pos: file pos 462 * @sync: fsync after write 463 * @written: number of bytes written 464 * 465 * Return: 0 on success, otherwise error 466 */ 467 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp, 468 char *buf, size_t count, loff_t *pos, bool sync, 469 ssize_t *written) 470 { 471 struct file *filp; 472 loff_t offset = *pos; 473 int err = 0; 474 475 if (work->conn->connection_type) { 476 if (!(fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE)) || 477 S_ISDIR(file_inode(fp->filp)->i_mode)) { 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 err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath); 627 if (err) { 628 pr_err("cannot get linux path for %s, err = %d\n", 629 oldname, err); 630 goto out1; 631 } 632 633 dentry = ksmbd_vfs_kern_path_create(work, newname, 634 LOOKUP_NO_SYMLINKS | LOOKUP_REVAL, 635 &newpath); 636 if (IS_ERR(dentry)) { 637 err = PTR_ERR(dentry); 638 pr_err("path create err for %s, err %d\n", newname, err); 639 goto out2; 640 } 641 642 err = -EXDEV; 643 if (oldpath.mnt != newpath.mnt) { 644 pr_err("vfs_link failed err %d\n", err); 645 goto out3; 646 } 647 648 err = vfs_link(oldpath.dentry, mnt_idmap(newpath.mnt), 649 d_inode(newpath.dentry), 650 dentry, NULL); 651 if (err) 652 ksmbd_debug(VFS, "vfs_link failed err %d\n", err); 653 654 out3: 655 end_creating_path(&newpath, dentry); 656 out2: 657 path_put(&oldpath); 658 out1: 659 ksmbd_revert_fsids(work); 660 return err; 661 } 662 663 int ksmbd_vfs_rename(struct ksmbd_work *work, const struct path *old_path, 664 char *newname, int flags) 665 { 666 struct dentry *old_child = old_path->dentry; 667 struct path new_path; 668 struct qstr new_last; 669 struct renamedata rd; 670 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 671 struct ksmbd_file *parent_fp; 672 int err, lookup_flags = LOOKUP_NO_SYMLINKS; 673 674 if (ksmbd_override_fsids(work)) 675 return -ENOMEM; 676 677 CLASS(filename_kernel, to)(newname); 678 679 retry: 680 err = vfs_path_parent_lookup(to, lookup_flags | LOOKUP_BENEATH, 681 &new_path, &new_last, &share_conf->vfs_path); 682 if (err) 683 goto out1; 684 685 if (old_path->mnt != new_path.mnt) { 686 err = -EXDEV; 687 goto out2; 688 } 689 690 err = mnt_want_write(old_path->mnt); 691 if (err) 692 goto out2; 693 694 rd.mnt_idmap = mnt_idmap(old_path->mnt); 695 rd.old_parent = NULL; 696 rd.new_parent = new_path.dentry; 697 rd.flags = flags; 698 rd.delegated_inode = NULL; 699 err = start_renaming_dentry(&rd, lookup_flags, old_child, &new_last); 700 if (err) 701 goto out_drop_write; 702 703 if (!work->tcon->posix_extensions && d_is_dir(old_child) && 704 ksmbd_has_open_files(old_child)) { 705 err = -EACCES; 706 goto out3; 707 } 708 709 parent_fp = ksmbd_lookup_fd_inode(old_child->d_parent); 710 if (parent_fp) { 711 if ((parent_fp->daccess & FILE_DELETE_LE) || 712 (!parent_fp->attrib_only && 713 !(parent_fp->saccess & FILE_SHARE_DELETE_LE))) { 714 pr_err("parent dir blocks delete sharing\n"); 715 err = -ESHARE; 716 ksmbd_fd_put(work, parent_fp); 717 goto out3; 718 } 719 ksmbd_fd_put(work, parent_fp); 720 } 721 722 if (d_is_symlink(rd.new_dentry)) { 723 err = -EACCES; 724 goto out3; 725 } 726 727 err = vfs_rename(&rd); 728 if (err) 729 ksmbd_debug(VFS, "vfs_rename failed err %d\n", err); 730 731 out3: 732 end_renaming(&rd); 733 out_drop_write: 734 mnt_drop_write(old_path->mnt); 735 out2: 736 path_put(&new_path); 737 738 if (retry_estale(err, lookup_flags)) { 739 lookup_flags |= LOOKUP_REVAL; 740 goto retry; 741 } 742 out1: 743 ksmbd_revert_fsids(work); 744 return err; 745 } 746 747 /** 748 * ksmbd_vfs_truncate() - vfs helper for smb file truncate 749 * @work: work 750 * @fp: ksmbd file pointer 751 * @size: truncate to given size 752 * 753 * Return: 0 on success, otherwise error 754 */ 755 int ksmbd_vfs_truncate(struct ksmbd_work *work, 756 struct ksmbd_file *fp, loff_t size) 757 { 758 int err = 0; 759 struct file *filp; 760 761 filp = fp->filp; 762 763 /* Do we need to break any of a levelII oplock? */ 764 smb_break_all_levII_oplock(work, fp, 1); 765 766 if (!work->tcon->posix_extensions) { 767 struct inode *inode = file_inode(filp); 768 769 if (size < inode->i_size) { 770 err = check_lock_range(filp, size, 771 inode->i_size - 1, WRITE); 772 } else if (size > inode->i_size) { 773 err = check_lock_range(filp, inode->i_size, 774 size - 1, WRITE); 775 } 776 777 if (err) { 778 pr_err("failed due to lock\n"); 779 return -EAGAIN; 780 } 781 } 782 783 err = vfs_truncate(&filp->f_path, size); 784 if (err) 785 pr_err("truncate failed, err %d\n", err); 786 return err; 787 } 788 789 /** 790 * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes 791 * @dentry: dentry of file for listing xattrs 792 * @list: destination buffer 793 * 794 * Return: xattr list length on success, otherwise error 795 */ 796 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list) 797 { 798 ssize_t size; 799 char *vlist = NULL; 800 801 size = vfs_listxattr(dentry, NULL, 0); 802 if (size <= 0) 803 return size; 804 805 vlist = kvzalloc(size, KSMBD_DEFAULT_GFP); 806 if (!vlist) 807 return -ENOMEM; 808 809 *list = vlist; 810 size = vfs_listxattr(dentry, vlist, size); 811 if (size < 0) { 812 ksmbd_debug(VFS, "listxattr failed\n"); 813 kvfree(vlist); 814 *list = NULL; 815 } 816 817 return size; 818 } 819 820 static ssize_t ksmbd_vfs_xattr_len(struct mnt_idmap *idmap, 821 struct dentry *dentry, char *xattr_name) 822 { 823 return vfs_getxattr(idmap, dentry, xattr_name, NULL, 0); 824 } 825 826 /** 827 * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value 828 * @idmap: idmap 829 * @dentry: dentry of file for getting xattrs 830 * @xattr_name: name of xattr name to query 831 * @xattr_buf: destination buffer xattr value 832 * 833 * Return: read xattr value length on success, otherwise error 834 */ 835 ssize_t ksmbd_vfs_getxattr(struct mnt_idmap *idmap, 836 struct dentry *dentry, 837 char *xattr_name, char **xattr_buf) 838 { 839 ssize_t xattr_len; 840 char *buf; 841 842 *xattr_buf = NULL; 843 xattr_len = ksmbd_vfs_xattr_len(idmap, dentry, xattr_name); 844 if (xattr_len < 0) 845 return xattr_len; 846 847 buf = kmalloc(xattr_len + 1, KSMBD_DEFAULT_GFP); 848 if (!buf) 849 return -ENOMEM; 850 851 xattr_len = vfs_getxattr(idmap, dentry, xattr_name, 852 (void *)buf, xattr_len); 853 if (xattr_len > 0) 854 *xattr_buf = buf; 855 else 856 kfree(buf); 857 return xattr_len; 858 } 859 860 /** 861 * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value 862 * @idmap: idmap of the relevant mount 863 * @path: path of dentry to set XATTR at 864 * @attr_name: xattr name for setxattr 865 * @attr_value: xattr value to set 866 * @attr_size: size of xattr value 867 * @flags: destination buffer length 868 * @get_write: get write access to a mount 869 * 870 * Return: 0 on success, otherwise error 871 */ 872 int ksmbd_vfs_setxattr(struct mnt_idmap *idmap, 873 const struct path *path, const char *attr_name, 874 void *attr_value, size_t attr_size, int flags, 875 bool get_write) 876 { 877 int err; 878 879 if (get_write == true) { 880 err = mnt_want_write(path->mnt); 881 if (err) 882 return err; 883 } 884 885 err = vfs_setxattr(idmap, 886 path->dentry, 887 attr_name, 888 attr_value, 889 attr_size, 890 flags); 891 if (err) 892 ksmbd_debug(VFS, "setxattr failed, err %d\n", err); 893 if (get_write == true) 894 mnt_drop_write(path->mnt); 895 return err; 896 } 897 898 /** 899 * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options 900 * @filp: file pointer for IO 901 * @option: smb IO options 902 */ 903 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option) 904 { 905 struct address_space *mapping; 906 907 mapping = filp->f_mapping; 908 909 if (!option || !mapping) 910 return; 911 912 if (option & FILE_WRITE_THROUGH_LE) { 913 filp->f_flags |= O_SYNC; 914 } else if (option & FILE_SEQUENTIAL_ONLY_LE) { 915 filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2; 916 spin_lock(&filp->f_lock); 917 filp->f_mode &= ~FMODE_RANDOM; 918 spin_unlock(&filp->f_lock); 919 } else if (option & FILE_RANDOM_ACCESS_LE) { 920 spin_lock(&filp->f_lock); 921 filp->f_mode |= FMODE_RANDOM; 922 spin_unlock(&filp->f_lock); 923 } 924 } 925 926 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp, 927 loff_t off, loff_t len) 928 { 929 const struct cred *saved_cred; 930 int err; 931 932 smb_break_all_levII_oplock(work, fp, 1); 933 saved_cred = override_creds(fp->filp->f_cred); 934 if (fp->f_ci->m_fattr & FILE_ATTRIBUTE_SPARSE_FILE_LE) 935 err = vfs_fallocate(fp->filp, 936 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 937 off, len); 938 else 939 err = vfs_fallocate(fp->filp, 940 FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE, 941 off, len); 942 revert_creds(saved_cred); 943 return err; 944 } 945 946 int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length, 947 struct file_allocated_range_buffer *ranges, 948 unsigned int in_count, unsigned int *out_count) 949 { 950 struct file *f = fp->filp; 951 struct inode *inode = file_inode(fp->filp); 952 loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end; 953 loff_t extent_start, extent_end; 954 int ret = 0; 955 956 if (start > maxbytes) 957 return -EFBIG; 958 959 if (!in_count) 960 return 0; 961 962 /* 963 * Shrink request scope to what the fs can actually handle. 964 */ 965 if (length > maxbytes || (maxbytes - length) < start) 966 length = maxbytes - start; 967 968 if (start + length > inode->i_size) 969 length = inode->i_size - start; 970 971 *out_count = 0; 972 end = start + length; 973 while (start < end && *out_count < in_count) { 974 extent_start = vfs_llseek(f, start, SEEK_DATA); 975 if (extent_start < 0) { 976 if (extent_start != -ENXIO) 977 ret = (int)extent_start; 978 break; 979 } 980 981 if (extent_start >= end) 982 break; 983 984 extent_end = vfs_llseek(f, extent_start, SEEK_HOLE); 985 if (extent_end < 0) { 986 if (extent_end != -ENXIO) 987 ret = (int)extent_end; 988 break; 989 } else if (extent_start >= extent_end) { 990 break; 991 } 992 993 ranges[*out_count].file_offset = cpu_to_le64(extent_start); 994 ranges[(*out_count)++].length = 995 cpu_to_le64(min(extent_end, end) - extent_start); 996 997 start = extent_end; 998 } 999 1000 return ret; 1001 } 1002 1003 int ksmbd_vfs_remove_xattr(struct mnt_idmap *idmap, 1004 const struct path *path, char *attr_name, 1005 bool get_write) 1006 { 1007 int err; 1008 1009 if (get_write == true) { 1010 err = mnt_want_write(path->mnt); 1011 if (err) 1012 return err; 1013 } 1014 1015 err = vfs_removexattr(idmap, path->dentry, attr_name); 1016 1017 if (get_write == true) 1018 mnt_drop_write(path->mnt); 1019 1020 return err; 1021 } 1022 1023 int ksmbd_vfs_unlink(struct file *filp) 1024 { 1025 const struct cred *saved_cred; 1026 int err = 0; 1027 struct dentry *dir, *dentry = filp->f_path.dentry; 1028 struct mnt_idmap *idmap = file_mnt_idmap(filp); 1029 1030 saved_cred = override_creds(filp->f_cred); 1031 err = mnt_want_write(filp->f_path.mnt); 1032 if (err) 1033 goto out_revert; 1034 1035 dir = dget_parent(dentry); 1036 dentry = start_removing_dentry(dir, dentry); 1037 err = PTR_ERR(dentry); 1038 if (IS_ERR(dentry)) 1039 goto out; 1040 1041 if (S_ISDIR(d_inode(dentry)->i_mode)) 1042 err = vfs_rmdir(idmap, d_inode(dir), dentry, NULL); 1043 else 1044 err = vfs_unlink(idmap, d_inode(dir), dentry, NULL); 1045 1046 end_removing(dentry); 1047 if (err) 1048 ksmbd_debug(VFS, "failed to delete, err %d\n", err); 1049 out: 1050 dput(dir); 1051 mnt_drop_write(filp->f_path.mnt); 1052 out_revert: 1053 revert_creds(saved_cred); 1054 return err; 1055 } 1056 1057 static bool __dir_empty(struct dir_context *ctx, const char *name, int namlen, 1058 loff_t offset, u64 ino, unsigned int d_type) 1059 { 1060 struct ksmbd_readdir_data *buf; 1061 1062 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1063 if (!name_is_dot_dotdot(name, namlen)) 1064 buf->dirent_count++; 1065 1066 return !buf->dirent_count; 1067 } 1068 1069 /** 1070 * ksmbd_vfs_empty_dir() - check for empty directory 1071 * @fp: ksmbd file pointer 1072 * 1073 * Return: true if directory empty, otherwise false 1074 */ 1075 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp) 1076 { 1077 int err; 1078 struct ksmbd_readdir_data readdir_data; 1079 1080 memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data)); 1081 1082 set_ctx_actor(&readdir_data.ctx, __dir_empty); 1083 readdir_data.dirent_count = 0; 1084 1085 err = iterate_dir(fp->filp, &readdir_data.ctx); 1086 if (readdir_data.dirent_count) 1087 err = -ENOTEMPTY; 1088 else 1089 err = 0; 1090 return err; 1091 } 1092 1093 static bool __caseless_lookup(struct dir_context *ctx, const char *name, 1094 int namlen, loff_t offset, u64 ino, 1095 unsigned int d_type) 1096 { 1097 struct ksmbd_readdir_data *buf; 1098 int cmp = -EINVAL; 1099 1100 buf = container_of(ctx, struct ksmbd_readdir_data, ctx); 1101 1102 if (buf->used != namlen) 1103 return true; 1104 if (IS_ENABLED(CONFIG_UNICODE) && buf->um) { 1105 const struct qstr q_buf = {.name = buf->private, 1106 .len = buf->used}; 1107 const struct qstr q_name = {.name = name, 1108 .len = namlen}; 1109 1110 cmp = utf8_strncasecmp(buf->um, &q_buf, &q_name); 1111 } 1112 if (cmp < 0) 1113 cmp = strncasecmp((char *)buf->private, name, namlen); 1114 if (!cmp) { 1115 memcpy((char *)buf->private, name, buf->used); 1116 buf->dirent_count = 1; 1117 return false; 1118 } 1119 return true; 1120 } 1121 1122 /** 1123 * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory 1124 * @dir: path info 1125 * @name: filename to lookup 1126 * @namelen: filename length 1127 * @um: &struct unicode_map to use 1128 * 1129 * Return: 0 on success, otherwise error 1130 */ 1131 static int ksmbd_vfs_lookup_in_dir(const struct path *dir, char *name, 1132 size_t namelen, struct unicode_map *um) 1133 { 1134 int ret; 1135 struct file *dfilp; 1136 int flags = O_RDONLY | O_LARGEFILE; 1137 struct ksmbd_readdir_data readdir_data = { 1138 .ctx.actor = __caseless_lookup, 1139 .private = name, 1140 .used = namelen, 1141 .dirent_count = 0, 1142 .um = um, 1143 }; 1144 1145 dfilp = dentry_open(dir, flags, current_cred()); 1146 if (IS_ERR(dfilp)) 1147 return PTR_ERR(dfilp); 1148 1149 ret = iterate_dir(dfilp, &readdir_data.ctx); 1150 if (readdir_data.dirent_count > 0) 1151 ret = 0; 1152 fput(dfilp); 1153 return ret; 1154 } 1155 1156 static 1157 int __ksmbd_vfs_kern_path(struct ksmbd_work *work, char *filepath, 1158 unsigned int flags, 1159 struct path *path, bool caseless, bool for_remove) 1160 { 1161 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1162 struct path parent_path; 1163 size_t path_len, remain_len; 1164 int err; 1165 1166 retry: 1167 err = ksmbd_vfs_path_lookup(share_conf, filepath, flags, path, for_remove); 1168 if (!err || err != -ENOENT || !caseless) 1169 return err; 1170 1171 path_len = strlen(filepath); 1172 remain_len = path_len; 1173 1174 parent_path = share_conf->vfs_path; 1175 path_get(&parent_path); 1176 1177 while (d_can_lookup(parent_path.dentry)) { 1178 char *filename = filepath + path_len - remain_len; 1179 char *next = strchrnul(filename, '/'); 1180 size_t filename_len = next - filename; 1181 bool is_last = !next[0]; 1182 1183 if (filename_len == 0) 1184 break; 1185 1186 err = ksmbd_vfs_lookup_in_dir(&parent_path, filename, 1187 filename_len, 1188 work->conn->um); 1189 path_put(&parent_path); 1190 if (err) 1191 goto out; 1192 if (is_last) { 1193 caseless = false; 1194 goto retry; 1195 } 1196 next[0] = '\0'; 1197 1198 err = vfs_path_lookup(share_conf->vfs_path.dentry, 1199 share_conf->vfs_path.mnt, 1200 filepath, 1201 flags, 1202 &parent_path); 1203 next[0] = '/'; 1204 if (err) 1205 goto out; 1206 1207 remain_len -= filename_len + 1; 1208 } 1209 1210 err = -EINVAL; 1211 path_put(&parent_path); 1212 out: 1213 return err; 1214 } 1215 1216 /** 1217 * ksmbd_vfs_kern_path() - lookup a file and get path info 1218 * @work: work 1219 * @filepath: file path that is relative to share 1220 * @flags: lookup flags 1221 * @path: if lookup succeed, return path info 1222 * @caseless: caseless filename lookup 1223 * 1224 * Perform the lookup, possibly crossing over any mount point. 1225 * On return no locks will be held and write-access to filesystem 1226 * won't have been checked. 1227 * Return: 0 if file was found, otherwise error 1228 */ 1229 int ksmbd_vfs_kern_path(struct ksmbd_work *work, char *filepath, 1230 unsigned int flags, 1231 struct path *path, bool caseless) 1232 { 1233 return __ksmbd_vfs_kern_path(work, filepath, flags, path, 1234 caseless, false); 1235 } 1236 1237 /** 1238 * ksmbd_vfs_kern_path_start_removing() - lookup a file and get path info prior to removal 1239 * @work: work 1240 * @filepath: file path that is relative to share 1241 * @flags: lookup flags 1242 * @path: if lookup succeed, return path info 1243 * @caseless: caseless filename lookup 1244 * 1245 * Perform the lookup, but don't cross over any mount point. 1246 * On return the parent of path->dentry will be locked and write-access to 1247 * filesystem will have been gained. 1248 * Return: 0 on if file was found, otherwise error 1249 */ 1250 int ksmbd_vfs_kern_path_start_removing(struct ksmbd_work *work, char *filepath, 1251 unsigned int flags, 1252 struct path *path, bool caseless) 1253 { 1254 return __ksmbd_vfs_kern_path(work, filepath, flags, path, 1255 caseless, true); 1256 } 1257 1258 void ksmbd_vfs_kern_path_end_removing(const struct path *path) 1259 { 1260 end_removing(path->dentry); 1261 mnt_drop_write(path->mnt); 1262 mntput(path->mnt); 1263 } 1264 1265 struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work, 1266 const char *name, 1267 unsigned int flags, 1268 struct path *path) 1269 { 1270 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1271 struct qstr last; 1272 struct dentry *dent; 1273 int err; 1274 1275 /* resolve the name beneath the share root so ".." cannot escape */ 1276 CLASS(filename_kernel, filename)(name); 1277 1278 err = vfs_path_parent_lookup(filename, flags | LOOKUP_BENEATH, 1279 path, &last, &share_conf->vfs_path); 1280 if (err) 1281 return ERR_PTR(err); 1282 1283 err = mnt_want_write(path->mnt); 1284 if (err) { 1285 path_put(path); 1286 return ERR_PTR(err); 1287 } 1288 1289 dent = start_creating_noperm(path->dentry, &last); 1290 if (IS_ERR(dent)) { 1291 mnt_drop_write(path->mnt); 1292 path_put(path); 1293 } 1294 return dent; 1295 } 1296 1297 int ksmbd_vfs_remove_acl_xattrs(struct mnt_idmap *idmap, 1298 const struct path *path) 1299 { 1300 char *name, *xattr_list = NULL; 1301 ssize_t xattr_list_len; 1302 int err = 0; 1303 1304 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1305 if (xattr_list_len < 0) { 1306 goto out; 1307 } else if (!xattr_list_len) { 1308 ksmbd_debug(SMB, "empty xattr in the file\n"); 1309 goto out; 1310 } 1311 1312 err = mnt_want_write(path->mnt); 1313 if (err) 1314 goto out; 1315 1316 for (name = xattr_list; name - xattr_list < xattr_list_len; 1317 name += strlen(name) + 1) { 1318 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1319 1320 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS, 1321 sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) || 1322 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT, 1323 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) { 1324 err = vfs_remove_acl(idmap, path->dentry, name); 1325 if (err) 1326 ksmbd_debug(SMB, 1327 "remove acl xattr failed : %s\n", name); 1328 } 1329 } 1330 mnt_drop_write(path->mnt); 1331 1332 out: 1333 kvfree(xattr_list); 1334 return err; 1335 } 1336 1337 int ksmbd_vfs_remove_sd_xattrs(struct mnt_idmap *idmap, const struct path *path) 1338 { 1339 char *name, *xattr_list = NULL; 1340 ssize_t xattr_list_len; 1341 int err = 0; 1342 1343 xattr_list_len = ksmbd_vfs_listxattr(path->dentry, &xattr_list); 1344 if (xattr_list_len < 0) { 1345 goto out; 1346 } else if (!xattr_list_len) { 1347 ksmbd_debug(SMB, "empty xattr in the file\n"); 1348 goto out; 1349 } 1350 1351 for (name = xattr_list; name - xattr_list < xattr_list_len; 1352 name += strlen(name) + 1) { 1353 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name)); 1354 1355 if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) { 1356 err = ksmbd_vfs_remove_xattr(idmap, path, name, true); 1357 if (err) 1358 ksmbd_debug(SMB, "remove xattr failed : %s\n", name); 1359 } 1360 } 1361 out: 1362 kvfree(xattr_list); 1363 return err; 1364 } 1365 1366 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct mnt_idmap *idmap, 1367 struct inode *inode, 1368 int acl_type) 1369 { 1370 struct xattr_smb_acl *smb_acl = NULL; 1371 struct posix_acl *posix_acls; 1372 struct posix_acl_entry *pa_entry; 1373 struct xattr_acl_entry *xa_entry; 1374 int i; 1375 1376 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1377 return NULL; 1378 1379 posix_acls = get_inode_acl(inode, acl_type); 1380 if (IS_ERR_OR_NULL(posix_acls)) 1381 return NULL; 1382 1383 smb_acl = kzalloc(sizeof(struct xattr_smb_acl) + 1384 sizeof(struct xattr_acl_entry) * posix_acls->a_count, 1385 KSMBD_DEFAULT_GFP); 1386 if (!smb_acl) 1387 goto out; 1388 1389 smb_acl->count = posix_acls->a_count; 1390 pa_entry = posix_acls->a_entries; 1391 xa_entry = smb_acl->entries; 1392 for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) { 1393 switch (pa_entry->e_tag) { 1394 case ACL_USER: 1395 xa_entry->type = SMB_ACL_USER; 1396 xa_entry->uid = posix_acl_uid_translate(idmap, pa_entry); 1397 break; 1398 case ACL_USER_OBJ: 1399 xa_entry->type = SMB_ACL_USER_OBJ; 1400 break; 1401 case ACL_GROUP: 1402 xa_entry->type = SMB_ACL_GROUP; 1403 xa_entry->gid = posix_acl_gid_translate(idmap, pa_entry); 1404 break; 1405 case ACL_GROUP_OBJ: 1406 xa_entry->type = SMB_ACL_GROUP_OBJ; 1407 break; 1408 case ACL_OTHER: 1409 xa_entry->type = SMB_ACL_OTHER; 1410 break; 1411 case ACL_MASK: 1412 xa_entry->type = SMB_ACL_MASK; 1413 break; 1414 default: 1415 pr_err("unknown type : 0x%x\n", pa_entry->e_tag); 1416 goto out; 1417 } 1418 1419 if (pa_entry->e_perm & ACL_READ) 1420 xa_entry->perm |= SMB_ACL_READ; 1421 if (pa_entry->e_perm & ACL_WRITE) 1422 xa_entry->perm |= SMB_ACL_WRITE; 1423 if (pa_entry->e_perm & ACL_EXECUTE) 1424 xa_entry->perm |= SMB_ACL_EXECUTE; 1425 } 1426 out: 1427 posix_acl_release(posix_acls); 1428 return smb_acl; 1429 } 1430 1431 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, 1432 struct mnt_idmap *idmap, 1433 const struct path *path, 1434 struct smb_ntsd *pntsd, int len, 1435 bool get_write) 1436 { 1437 int rc; 1438 struct ndr sd_ndr = {0}, acl_ndr = {0}; 1439 struct xattr_ntacl acl = {0}; 1440 struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL; 1441 struct dentry *dentry = path->dentry; 1442 struct inode *inode = d_inode(dentry); 1443 1444 acl.version = 4; 1445 acl.hash_type = XATTR_SD_HASH_TYPE_SHA256; 1446 acl.current_time = ksmbd_UnixTimeToNT(current_time(inode)); 1447 1448 memcpy(acl.desc, "posix_acl", 9); 1449 acl.desc_len = 10; 1450 1451 pntsd->osidoffset = 1452 cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF); 1453 pntsd->gsidoffset = 1454 cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF); 1455 pntsd->dacloffset = 1456 cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF); 1457 1458 acl.sd_buf = (char *)pntsd; 1459 acl.sd_size = len; 1460 1461 sha256(acl.sd_buf, acl.sd_size, acl.hash); 1462 1463 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1464 ACL_TYPE_ACCESS); 1465 if (S_ISDIR(inode->i_mode)) 1466 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1467 ACL_TYPE_DEFAULT); 1468 1469 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, 1470 smb_acl, def_smb_acl); 1471 if (rc) { 1472 pr_err("failed to encode ndr to posix acl\n"); 1473 goto out; 1474 } 1475 1476 sha256(acl_ndr.data, acl_ndr.offset, acl.posix_acl_hash); 1477 1478 rc = ndr_encode_v4_ntacl(&sd_ndr, &acl); 1479 if (rc) { 1480 pr_err("failed to encode ndr to posix acl\n"); 1481 goto out; 1482 } 1483 1484 rc = ksmbd_vfs_setxattr(idmap, path, 1485 XATTR_NAME_SD, sd_ndr.data, 1486 sd_ndr.offset, 0, get_write); 1487 if (rc < 0) 1488 pr_err("Failed to store XATTR ntacl :%d\n", rc); 1489 1490 kfree(sd_ndr.data); 1491 out: 1492 kfree(acl_ndr.data); 1493 kfree(smb_acl); 1494 kfree(def_smb_acl); 1495 return rc; 1496 } 1497 1498 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, 1499 struct mnt_idmap *idmap, 1500 struct dentry *dentry, 1501 struct smb_ntsd **pntsd) 1502 { 1503 int rc; 1504 struct ndr n; 1505 struct inode *inode = d_inode(dentry); 1506 struct ndr acl_ndr = {0}; 1507 struct xattr_ntacl acl; 1508 struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL; 1509 __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0}; 1510 1511 rc = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_SD, &n.data); 1512 if (rc <= 0) 1513 return rc; 1514 1515 n.length = rc; 1516 rc = ndr_decode_v4_ntacl(&n, &acl); 1517 if (rc) 1518 goto free_n_data; 1519 1520 smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1521 ACL_TYPE_ACCESS); 1522 if (S_ISDIR(inode->i_mode)) 1523 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(idmap, inode, 1524 ACL_TYPE_DEFAULT); 1525 1526 rc = ndr_encode_posix_acl(&acl_ndr, idmap, inode, smb_acl, 1527 def_smb_acl); 1528 if (rc) { 1529 pr_err("failed to encode ndr to posix acl\n"); 1530 goto out_free; 1531 } 1532 1533 sha256(acl_ndr.data, acl_ndr.offset, cmp_hash); 1534 1535 if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) { 1536 pr_err("hash value diff\n"); 1537 rc = -EINVAL; 1538 goto out_free; 1539 } 1540 1541 *pntsd = acl.sd_buf; 1542 if (acl.sd_size < sizeof(struct smb_ntsd)) { 1543 pr_err("sd size is invalid\n"); 1544 goto out_free; 1545 } 1546 1547 (*pntsd)->osidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) - 1548 NDR_NTSD_OFFSETOF); 1549 (*pntsd)->gsidoffset = cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) - 1550 NDR_NTSD_OFFSETOF); 1551 (*pntsd)->dacloffset = cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) - 1552 NDR_NTSD_OFFSETOF); 1553 1554 rc = acl.sd_size; 1555 out_free: 1556 kfree(acl_ndr.data); 1557 kfree(smb_acl); 1558 kfree(def_smb_acl); 1559 if (rc < 0) { 1560 kfree(acl.sd_buf); 1561 *pntsd = NULL; 1562 } 1563 1564 free_n_data: 1565 kfree(n.data); 1566 return rc; 1567 } 1568 1569 int ksmbd_vfs_set_dos_attrib_xattr(struct mnt_idmap *idmap, 1570 const struct path *path, 1571 struct xattr_dos_attrib *da, 1572 bool get_write) 1573 { 1574 struct ndr n; 1575 int err; 1576 1577 err = ndr_encode_dos_attr(&n, da); 1578 if (err) 1579 return err; 1580 1581 err = ksmbd_vfs_setxattr(idmap, path, XATTR_NAME_DOS_ATTRIBUTE, 1582 (void *)n.data, n.offset, 0, get_write); 1583 if (err) 1584 ksmbd_debug(SMB, "failed to store dos attribute in xattr\n"); 1585 kfree(n.data); 1586 1587 return err; 1588 } 1589 1590 int ksmbd_vfs_get_dos_attrib_xattr(struct mnt_idmap *idmap, 1591 struct dentry *dentry, 1592 struct xattr_dos_attrib *da) 1593 { 1594 struct ndr n; 1595 int err; 1596 1597 err = ksmbd_vfs_getxattr(idmap, dentry, XATTR_NAME_DOS_ATTRIBUTE, 1598 (char **)&n.data); 1599 if (err > 0) { 1600 n.length = err; 1601 if (ndr_decode_dos_attr(&n, da)) 1602 err = -EINVAL; 1603 kfree(n.data); 1604 } else { 1605 ksmbd_debug(SMB, "failed to load dos attribute in xattr\n"); 1606 } 1607 1608 return err; 1609 } 1610 1611 /** 1612 * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format 1613 * @p: destination buffer 1614 * @ksmbd_kstat: ksmbd kstat wrapper 1615 * 1616 * Returns: pointer to the converted &struct file_directory_info 1617 */ 1618 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat) 1619 { 1620 FILE_DIRECTORY_INFO *info = (FILE_DIRECTORY_INFO *)(*p); 1621 struct kstat *kstat = ksmbd_kstat->kstat; 1622 u64 time; 1623 1624 info->FileIndex = 0; 1625 info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time); 1626 time = ksmbd_UnixTimeToNT(kstat->atime); 1627 info->LastAccessTime = cpu_to_le64(time); 1628 time = ksmbd_UnixTimeToNT(kstat->mtime); 1629 info->LastWriteTime = cpu_to_le64(time); 1630 time = ksmbd_UnixTimeToNT(kstat->ctime); 1631 info->ChangeTime = cpu_to_le64(time); 1632 1633 if (ksmbd_kstat->file_attributes & FILE_ATTRIBUTE_DIRECTORY_LE) { 1634 info->EndOfFile = 0; 1635 info->AllocationSize = 0; 1636 } else { 1637 info->EndOfFile = cpu_to_le64(kstat->size); 1638 info->AllocationSize = cpu_to_le64(kstat->blocks << 9); 1639 } 1640 info->ExtFileAttributes = ksmbd_kstat->file_attributes; 1641 1642 return info; 1643 } 1644 1645 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, 1646 struct mnt_idmap *idmap, 1647 struct dentry *dentry, 1648 struct ksmbd_kstat *ksmbd_kstat) 1649 { 1650 struct ksmbd_share_config *share_conf = work->tcon->share_conf; 1651 u64 time; 1652 int rc; 1653 struct path path = { 1654 .mnt = share_conf->vfs_path.mnt, 1655 .dentry = dentry, 1656 }; 1657 1658 rc = vfs_getattr(&path, ksmbd_kstat->kstat, 1659 STATX_BASIC_STATS | STATX_BTIME, 1660 AT_STATX_SYNC_AS_STAT); 1661 if (rc) 1662 return rc; 1663 1664 time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime); 1665 ksmbd_kstat->create_time = time; 1666 1667 /* 1668 * set default value for the case that store dos attributes is not yes 1669 * or that acl is disable in server's filesystem and the config is yes. 1670 */ 1671 if (S_ISDIR(ksmbd_kstat->kstat->mode)) 1672 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_DIRECTORY_LE; 1673 else 1674 ksmbd_kstat->file_attributes = FILE_ATTRIBUTE_ARCHIVE_LE; 1675 1676 if (test_share_config_flag(work->tcon->share_conf, 1677 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { 1678 struct xattr_dos_attrib da; 1679 1680 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da); 1681 if (rc > 0) { 1682 ksmbd_kstat->file_attributes = cpu_to_le32(da.attr); 1683 ksmbd_kstat->create_time = da.create_time; 1684 } else { 1685 ksmbd_debug(VFS, "fail to load dos attribute.\n"); 1686 } 1687 } 1688 1689 return 0; 1690 } 1691 1692 ssize_t ksmbd_vfs_casexattr_len(struct mnt_idmap *idmap, 1693 struct dentry *dentry, char *attr_name, 1694 int attr_name_len) 1695 { 1696 char *name, *xattr_list = NULL; 1697 ssize_t value_len = -ENOENT, xattr_list_len; 1698 1699 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list); 1700 if (xattr_list_len <= 0) 1701 goto out; 1702 1703 for (name = xattr_list; name - xattr_list < xattr_list_len; 1704 name += strlen(name) + 1) { 1705 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name)); 1706 if (strncasecmp(attr_name, name, attr_name_len)) 1707 continue; 1708 1709 value_len = ksmbd_vfs_xattr_len(idmap, dentry, name); 1710 break; 1711 } 1712 1713 out: 1714 kvfree(xattr_list); 1715 return value_len; 1716 } 1717 1718 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name, 1719 size_t *xattr_stream_name_size, int s_type) 1720 { 1721 char *type, *buf; 1722 1723 if (s_type == DIR_STREAM) 1724 type = ":$INDEX_ALLOCATION"; 1725 else 1726 type = ":$DATA"; 1727 1728 buf = kasprintf(KSMBD_DEFAULT_GFP, "%s%s%s", 1729 XATTR_NAME_STREAM, stream_name, type); 1730 if (!buf) 1731 return -ENOMEM; 1732 1733 *xattr_stream_name = buf; 1734 *xattr_stream_name_size = strlen(buf) + 1; 1735 1736 return 0; 1737 } 1738 1739 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work, 1740 struct ksmbd_file *src_fp, 1741 struct ksmbd_file *dst_fp, 1742 struct srv_copychunk *chunks, 1743 unsigned int chunk_count, 1744 unsigned int *chunk_count_written, 1745 unsigned int *chunk_size_written, 1746 loff_t *total_size_written) 1747 { 1748 unsigned int i; 1749 loff_t src_off, dst_off, src_file_size; 1750 size_t len; 1751 int ret; 1752 1753 *chunk_count_written = 0; 1754 *chunk_size_written = 0; 1755 *total_size_written = 0; 1756 1757 if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) { 1758 pr_err("no right to read(%pD)\n", src_fp->filp); 1759 return -EACCES; 1760 } 1761 if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) { 1762 pr_err("no right to write(%pD)\n", dst_fp->filp); 1763 return -EACCES; 1764 } 1765 1766 if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp)) 1767 return -EBADF; 1768 1769 smb_break_all_levII_oplock(work, dst_fp, 1); 1770 1771 if (!work->tcon->posix_extensions) { 1772 for (i = 0; i < chunk_count; i++) { 1773 src_off = le64_to_cpu(chunks[i].SourceOffset); 1774 dst_off = le64_to_cpu(chunks[i].TargetOffset); 1775 len = le32_to_cpu(chunks[i].Length); 1776 1777 if (check_lock_range(src_fp->filp, src_off, 1778 src_off + len - 1, READ)) 1779 return -EAGAIN; 1780 if (check_lock_range(dst_fp->filp, dst_off, 1781 dst_off + len - 1, WRITE)) 1782 return -EAGAIN; 1783 } 1784 } 1785 1786 src_file_size = i_size_read(file_inode(src_fp->filp)); 1787 1788 for (i = 0; i < chunk_count; i++) { 1789 src_off = le64_to_cpu(chunks[i].SourceOffset); 1790 dst_off = le64_to_cpu(chunks[i].TargetOffset); 1791 len = le32_to_cpu(chunks[i].Length); 1792 1793 if (src_off + len > src_file_size) 1794 return -E2BIG; 1795 1796 /* 1797 * vfs_copy_file_range does not allow overlapped copying 1798 * within the same file. 1799 */ 1800 if (file_inode(src_fp->filp) == file_inode(dst_fp->filp) && 1801 dst_off + len > src_off && 1802 dst_off < src_off + len) 1803 ret = do_splice_direct(src_fp->filp, &src_off, 1804 dst_fp->filp, &dst_off, 1805 min_t(size_t, len, MAX_RW_COUNT), 0); 1806 else 1807 ret = vfs_copy_file_range(src_fp->filp, src_off, 1808 dst_fp->filp, dst_off, len, 0); 1809 if (ret == -EOPNOTSUPP || ret == -EXDEV) 1810 ret = vfs_copy_file_range(src_fp->filp, src_off, 1811 dst_fp->filp, dst_off, len, 1812 COPY_FILE_SPLICE); 1813 if (ret < 0) 1814 return ret; 1815 1816 *chunk_count_written += 1; 1817 *total_size_written += ret; 1818 } 1819 return 0; 1820 } 1821 1822 void ksmbd_vfs_posix_lock_wait(struct file_lock *flock) 1823 { 1824 wait_event(flock->c.flc_wait, !flock->c.flc_blocker); 1825 } 1826 1827 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock) 1828 { 1829 locks_delete_block(flock); 1830 } 1831 1832 int ksmbd_vfs_set_init_posix_acl(struct mnt_idmap *idmap, 1833 const struct path *path) 1834 { 1835 struct posix_acl_state acl_state; 1836 struct posix_acl *acls; 1837 struct dentry *dentry = path->dentry; 1838 struct inode *inode = d_inode(dentry); 1839 int rc; 1840 1841 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1842 return -EOPNOTSUPP; 1843 1844 ksmbd_debug(SMB, "Set posix acls\n"); 1845 rc = init_acl_state(&acl_state, 1); 1846 if (rc) 1847 return rc; 1848 1849 /* Set default owner group */ 1850 acl_state.owner.allow = (inode->i_mode & 0700) >> 6; 1851 acl_state.group.allow = (inode->i_mode & 0070) >> 3; 1852 acl_state.other.allow = inode->i_mode & 0007; 1853 acl_state.users->aces[acl_state.users->n].uid = inode->i_uid; 1854 acl_state.users->aces[acl_state.users->n++].perms.allow = 1855 acl_state.owner.allow; 1856 acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid; 1857 acl_state.groups->aces[acl_state.groups->n++].perms.allow = 1858 acl_state.group.allow; 1859 acl_state.mask.allow = 0x07; 1860 1861 acls = posix_acl_alloc(6, KSMBD_DEFAULT_GFP); 1862 if (!acls) { 1863 free_acl_state(&acl_state); 1864 return -ENOMEM; 1865 } 1866 posix_state_to_acl(&acl_state, acls->a_entries); 1867 1868 rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls); 1869 if (rc < 0) 1870 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 1871 rc); 1872 else if (S_ISDIR(inode->i_mode)) { 1873 posix_state_to_acl(&acl_state, acls->a_entries); 1874 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, acls); 1875 if (rc < 0) 1876 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 1877 rc); 1878 } 1879 1880 free_acl_state(&acl_state); 1881 posix_acl_release(acls); 1882 return rc; 1883 } 1884 1885 int ksmbd_vfs_inherit_posix_acl(struct mnt_idmap *idmap, 1886 const struct path *path, struct inode *parent_inode) 1887 { 1888 struct posix_acl *acls; 1889 struct posix_acl_entry *pace; 1890 struct dentry *dentry = path->dentry; 1891 struct inode *inode = d_inode(dentry); 1892 int rc, i; 1893 1894 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL)) 1895 return -EOPNOTSUPP; 1896 1897 acls = get_inode_acl(parent_inode, ACL_TYPE_DEFAULT); 1898 if (IS_ERR_OR_NULL(acls)) 1899 return -ENOENT; 1900 pace = acls->a_entries; 1901 1902 for (i = 0; i < acls->a_count; i++, pace++) { 1903 if (pace->e_tag == ACL_MASK) { 1904 pace->e_perm = 0x07; 1905 break; 1906 } 1907 } 1908 1909 rc = set_posix_acl(idmap, dentry, ACL_TYPE_ACCESS, acls); 1910 if (rc < 0) 1911 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n", 1912 rc); 1913 if (S_ISDIR(inode->i_mode)) { 1914 rc = set_posix_acl(idmap, dentry, ACL_TYPE_DEFAULT, 1915 acls); 1916 if (rc < 0) 1917 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n", 1918 rc); 1919 } 1920 1921 posix_acl_release(acls); 1922 return rc; 1923 } 1924 1925 void ksmbd_vfs_update_compressed_fattr(struct dentry *dentry, __le32 *fattr) 1926 { 1927 int rc; 1928 struct file_kattr fa = { .flags_valid = true }; 1929 1930 rc = vfs_fileattr_get(dentry, &fa); 1931 if (rc == -ENOIOCTLCMD) 1932 *fattr &= ~FILE_ATTRIBUTE_COMPRESSED_LE; 1933 if (rc) 1934 return; 1935 1936 if (fa.flags & FS_COMPR_FL) 1937 *fattr |= FILE_ATTRIBUTE_COMPRESSED_LE; 1938 else 1939 *fattr &= ~FILE_ATTRIBUTE_COMPRESSED_LE; 1940 } 1941 1942 int ksmbd_vfs_get_compression(struct ksmbd_file *fp, u16 *fmt) 1943 { 1944 struct file_kattr fa = { .flags_valid = true }; 1945 int rc; 1946 1947 rc = vfs_fileattr_get(fp->filp->f_path.dentry, &fa); 1948 if (rc == -ENOIOCTLCMD) { 1949 *fmt = COMPRESSION_FORMAT_NONE; 1950 rc = 0; 1951 goto out; 1952 } 1953 if (rc) 1954 goto out; 1955 1956 if (fa.flags & FS_COMPR_FL) 1957 *fmt = COMPRESSION_FORMAT_LZNT1; 1958 else 1959 *fmt = COMPRESSION_FORMAT_NONE; 1960 1961 out: 1962 return rc; 1963 } 1964 1965 int ksmbd_vfs_set_compression(struct ksmbd_work *work, struct ksmbd_file *fp, u16 fmt) 1966 { 1967 const struct cred *saved_cred = NULL; 1968 struct file_kattr fa; 1969 struct dentry *dentry = fp->filp->f_path.dentry; 1970 struct mnt_idmap *idmap = file_mnt_idmap(fp->filp); 1971 u32 flags; 1972 __le32 old_fattr; 1973 int rc; 1974 1975 if (!(fp->daccess & FILE_WRITE_DATA_LE)) { 1976 rc = -EACCES; 1977 goto out; 1978 } 1979 1980 saved_cred = override_creds(fp->filp->f_cred); 1981 rc = vfs_fileattr_get(dentry, &fa); 1982 if (rc) 1983 goto out; 1984 1985 flags = fa.flags; 1986 if (fmt == COMPRESSION_FORMAT_NONE) { 1987 flags &= ~FS_COMPR_FL; 1988 } else if (fmt == COMPRESSION_FORMAT_DEFAULT || 1989 fmt == COMPRESSION_FORMAT_LZNT1) { 1990 flags |= FS_COMPR_FL; 1991 } else { 1992 rc = -EINVAL; 1993 goto out; 1994 } 1995 1996 if (flags != fa.flags) { 1997 fileattr_fill_flags(&fa, flags); 1998 rc = mnt_want_write_file(fp->filp); 1999 if (rc) 2000 goto out; 2001 2002 rc = vfs_fileattr_set(idmap, dentry, &fa); 2003 mnt_drop_write_file(fp->filp); 2004 if (rc) 2005 goto out; 2006 } 2007 2008 old_fattr = fp->f_ci->m_fattr; 2009 if (fmt == COMPRESSION_FORMAT_NONE) 2010 fp->f_ci->m_fattr &= ~FILE_ATTRIBUTE_COMPRESSED_LE; 2011 else 2012 fp->f_ci->m_fattr |= FILE_ATTRIBUTE_COMPRESSED_LE; 2013 2014 if (fp->f_ci->m_fattr != old_fattr && 2015 test_share_config_flag(work->tcon->share_conf, 2016 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) { 2017 struct xattr_dos_attrib da; 2018 2019 rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, dentry, &da); 2020 if (rc <= 0) { 2021 rc = 0; 2022 goto out; 2023 } 2024 2025 da.attr = le32_to_cpu(fp->f_ci->m_fattr); 2026 rc = ksmbd_vfs_set_dos_attrib_xattr(idmap, 2027 &fp->filp->f_path, 2028 &da, true); 2029 if (rc) 2030 rc = 0; 2031 } 2032 2033 out: 2034 if (saved_cred) 2035 revert_creds(saved_cred); 2036 return rc; 2037 } 2038