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