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