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