1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org>
4 * Copyright (C) 2018 Samsung Electronics Co., Ltd.
7 #include <linux/kernel.h>
9 #include <linux/uaccess.h>
10 #include <linux/backing-dev.h>
11 #include <linux/writeback.h>
12 #include <linux/xattr.h>
13 #include <linux/falloc.h>
14 #include <linux/genhd.h>
15 #include <linux/fsnotify.h>
16 #include <linux/dcache.h>
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched/xacct.h>
20 #include <linux/crc32c.h>
24 #include "connection.h"
26 #include "vfs_cache.h"
32 #include "smb_common.h"
33 #include "mgmt/share_config.h"
34 #include "mgmt/tree_connect.h"
35 #include "mgmt/user_session.h"
36 #include "mgmt/user_config.h"
38 static char *extract_last_component(char *path)
40 char *p = strrchr(path, '/');
42 if (p && p[1] != '\0') {
47 pr_err("Invalid path %s\n", path);
52 static void ksmbd_vfs_inherit_owner(struct ksmbd_work *work,
53 struct inode *parent_inode,
56 if (!test_share_config_flag(work->tcon->share_conf,
57 KSMBD_SHARE_FLAG_INHERIT_OWNER))
60 i_uid_write(inode, i_uid_read(parent_inode));
64 * ksmbd_vfs_lock_parent() - lock parent dentry if it is stable
66 * the parent dentry got by dget_parent or @parent could be
67 * unstable, we try to lock a parent inode and lookup the
70 * the reference count of @parent isn't incremented.
72 static int ksmbd_vfs_lock_parent(struct dentry *parent, struct dentry *child)
74 struct dentry *dentry;
77 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT);
78 dentry = lookup_one_len(child->d_name.name, parent,
81 ret = PTR_ERR(dentry);
85 if (dentry != child) {
94 inode_unlock(d_inode(parent));
98 int ksmbd_vfs_inode_permission(struct dentry *dentry, int acc_mode, bool delete)
103 acc_mode &= O_ACCMODE;
105 if (acc_mode == O_RDONLY)
107 else if (acc_mode == O_WRONLY)
109 else if (acc_mode == O_RDWR)
110 mask = MAY_READ | MAY_WRITE;
112 if (inode_permission(&init_user_ns, d_inode(dentry), mask | MAY_OPEN))
116 struct dentry *parent;
118 parent = dget_parent(dentry);
119 ret = ksmbd_vfs_lock_parent(parent, dentry);
125 if (inode_permission(&init_user_ns, d_inode(parent), MAY_EXEC | MAY_WRITE))
128 inode_unlock(d_inode(parent));
134 int ksmbd_vfs_query_maximal_access(struct dentry *dentry, __le32 *daccess)
136 struct dentry *parent;
139 *daccess = cpu_to_le32(FILE_READ_ATTRIBUTES | READ_CONTROL);
141 if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_WRITE))
142 *daccess |= cpu_to_le32(WRITE_DAC | WRITE_OWNER | SYNCHRONIZE |
143 FILE_WRITE_DATA | FILE_APPEND_DATA |
144 FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES |
147 if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_READ))
148 *daccess |= FILE_READ_DATA_LE | FILE_READ_EA_LE;
150 if (!inode_permission(&init_user_ns, d_inode(dentry), MAY_OPEN | MAY_EXEC))
151 *daccess |= FILE_EXECUTE_LE;
153 parent = dget_parent(dentry);
154 ret = ksmbd_vfs_lock_parent(parent, dentry);
160 if (!inode_permission(&init_user_ns, d_inode(parent), MAY_EXEC | MAY_WRITE))
161 *daccess |= FILE_DELETE_LE;
163 inode_unlock(d_inode(parent));
169 * ksmbd_vfs_create() - vfs helper for smb create file
172 * @mode: file create mode
174 * Return: 0 on success, otherwise error
176 int ksmbd_vfs_create(struct ksmbd_work *work, const char *name, umode_t mode)
179 struct dentry *dentry;
182 dentry = kern_path_create(AT_FDCWD, name, &path, 0);
183 if (IS_ERR(dentry)) {
184 err = PTR_ERR(dentry);
186 pr_err("path create failed for %s, err %d\n",
192 err = vfs_create(&init_user_ns, d_inode(path.dentry), dentry, mode, true);
194 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry),
197 pr_err("File(%s): creation failed (err:%d)\n", name, err);
199 done_path_create(&path, dentry);
204 * ksmbd_vfs_mkdir() - vfs helper for smb create directory
206 * @name: directory name
207 * @mode: directory create mode
209 * Return: 0 on success, otherwise error
211 int ksmbd_vfs_mkdir(struct ksmbd_work *work, const char *name, umode_t mode)
214 struct dentry *dentry;
217 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY);
218 if (IS_ERR(dentry)) {
219 err = PTR_ERR(dentry);
221 ksmbd_debug(VFS, "path create failed for %s, err %d\n",
227 err = vfs_mkdir(&init_user_ns, d_inode(path.dentry), dentry, mode);
230 } else if (d_unhashed(dentry)) {
233 d = lookup_one_len(dentry->d_name.name, dentry->d_parent,
239 if (unlikely(d_is_negative(d))) {
245 ksmbd_vfs_inherit_owner(work, d_inode(path.dentry), d_inode(d));
249 done_path_create(&path, dentry);
251 pr_err("mkdir(%s): creation failed (err:%d)\n", name, err);
255 static ssize_t ksmbd_vfs_getcasexattr(struct dentry *dentry, char *attr_name,
256 int attr_name_len, char **attr_value)
258 char *name, *xattr_list = NULL;
259 ssize_t value_len = -ENOENT, xattr_list_len;
261 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
262 if (xattr_list_len <= 0)
265 for (name = xattr_list; name - xattr_list < xattr_list_len;
266 name += strlen(name) + 1) {
267 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
268 if (strncasecmp(attr_name, name, attr_name_len))
271 value_len = ksmbd_vfs_getxattr(dentry,
275 pr_err("failed to get xattr in file\n");
284 static int ksmbd_vfs_stream_read(struct ksmbd_file *fp, char *buf, loff_t *pos,
288 char *stream_buf = NULL;
290 ksmbd_debug(VFS, "read stream data pos : %llu, count : %zd\n",
293 v_len = ksmbd_vfs_getcasexattr(fp->filp->f_path.dentry,
305 if (v_len - *pos < count)
306 count = v_len - *pos;
308 memcpy(buf, &stream_buf[*pos], count);
316 * check_lock_range() - vfs helper for smb byte range file locking
317 * @filp: the file to apply the lock to
318 * @start: lock start byte offset
319 * @end: lock end byte offset
320 * @type: byte range type read/write
322 * Return: 0 on success, otherwise error
324 static int check_lock_range(struct file *filp, loff_t start, loff_t end,
327 struct file_lock *flock;
328 struct file_lock_context *ctx = file_inode(filp)->i_flctx;
331 if (!ctx || list_empty_careful(&ctx->flc_posix))
334 spin_lock(&ctx->flc_lock);
335 list_for_each_entry(flock, &ctx->flc_posix, fl_list) {
336 /* check conflict locks */
337 if (flock->fl_end >= start && end >= flock->fl_start) {
338 if (flock->fl_type == F_RDLCK) {
340 pr_err("not allow write by shared lock\n");
344 } else if (flock->fl_type == F_WRLCK) {
345 /* check owner in lock */
346 if (flock->fl_file != filp) {
348 pr_err("not allow rw access by exclusive lock from other opens\n");
355 spin_unlock(&ctx->flc_lock);
360 * ksmbd_vfs_read() - vfs helper for smb file read
362 * @fid: file id of open file
363 * @count: read byte count
366 * Return: number of read bytes on success, otherwise error
368 int ksmbd_vfs_read(struct ksmbd_work *work, struct ksmbd_file *fp, size_t count,
371 struct file *filp = fp->filp;
373 char *rbuf = work->aux_payload_buf;
374 struct inode *inode = file_inode(filp);
376 if (S_ISDIR(inode->i_mode))
379 if (unlikely(count == 0))
382 if (work->conn->connection_type) {
383 if (!(fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
384 pr_err("no right to read(%s)\n", FP_FILENAME(fp));
389 if (ksmbd_stream_fd(fp))
390 return ksmbd_vfs_stream_read(fp, rbuf, pos, count);
392 if (!work->tcon->posix_extensions) {
395 ret = check_lock_range(filp, *pos, *pos + count - 1, READ);
397 pr_err("unable to read due to lock\n");
402 nbytes = kernel_read(filp, rbuf, count, pos);
404 pr_err("smb read failed for (%s), err = %zd\n",
405 fp->filename, nbytes);
413 static int ksmbd_vfs_stream_write(struct ksmbd_file *fp, char *buf, loff_t *pos,
416 char *stream_buf = NULL, *wbuf;
420 ksmbd_debug(VFS, "write stream data pos : %llu, count : %zd\n",
424 if (size > XATTR_SIZE_MAX) {
425 size = XATTR_SIZE_MAX;
426 count = (*pos + count) - XATTR_SIZE_MAX;
429 v_len = ksmbd_vfs_getcasexattr(fp->filp->f_path.dentry,
433 if ((int)v_len < 0) {
434 pr_err("not found stream in xattr : %zd\n", v_len);
440 wbuf = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
447 memcpy(wbuf, stream_buf, v_len);
452 memcpy(&stream_buf[*pos], buf, count);
454 err = ksmbd_vfs_setxattr(fp->filp->f_path.dentry,
462 fp->filp->f_pos = *pos;
470 * ksmbd_vfs_write() - vfs helper for smb file write
472 * @fid: file id of open file
473 * @buf: buf containing data for writing
474 * @count: read byte count
476 * @sync: fsync after write
477 * @written: number of bytes written
479 * Return: 0 on success, otherwise error
481 int ksmbd_vfs_write(struct ksmbd_work *work, struct ksmbd_file *fp,
482 char *buf, size_t count, loff_t *pos, bool sync,
485 struct ksmbd_session *sess = work->sess;
487 loff_t offset = *pos;
490 if (sess->conn->connection_type) {
491 if (!(fp->daccess & FILE_WRITE_DATA_LE)) {
492 pr_err("no right to write(%s)\n", FP_FILENAME(fp));
500 if (ksmbd_stream_fd(fp)) {
501 err = ksmbd_vfs_stream_write(fp, buf, pos, count);
507 if (!work->tcon->posix_extensions) {
508 err = check_lock_range(filp, *pos, *pos + count - 1, WRITE);
510 pr_err("unable to write due to lock\n");
516 /* Do we need to break any of a levelII oplock? */
517 smb_break_all_levII_oplock(work, fp, 1);
519 err = kernel_write(filp, buf, count, pos);
521 ksmbd_debug(VFS, "smb write failed, err = %d\n", err);
529 err = vfs_fsync_range(filp, offset, offset + *written, 0);
531 pr_err("fsync failed for filename = %s, err = %d\n",
532 FP_FILENAME(fp), err);
540 * ksmbd_vfs_getattr() - vfs helper for smb getattr
542 * @fid: file id of open file
543 * @attrs: inode attributes
545 * Return: 0 on success, otherwise error
547 int ksmbd_vfs_getattr(struct path *path, struct kstat *stat)
551 err = vfs_getattr(path, stat, STATX_BTIME, AT_STATX_SYNC_AS_STAT);
553 pr_err("getattr failed, err %d\n", err);
558 * ksmbd_vfs_fsync() - vfs helper for smb fsync
560 * @fid: file id of open file
562 * Return: 0 on success, otherwise error
564 int ksmbd_vfs_fsync(struct ksmbd_work *work, u64 fid, u64 p_id)
566 struct ksmbd_file *fp;
569 fp = ksmbd_lookup_fd_slow(work, fid, p_id);
571 pr_err("failed to get filp for fid %llu\n", fid);
574 err = vfs_fsync(fp->filp, 0);
576 pr_err("smb fsync failed, err = %d\n", err);
577 ksmbd_fd_put(work, fp);
582 * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink
583 * @name: absolute directory or file name
585 * Return: 0 on success, otherwise error
587 int ksmbd_vfs_remove_file(struct ksmbd_work *work, char *name)
590 struct dentry *parent;
594 if (ksmbd_override_fsids(work))
597 if (test_share_config_flag(work->tcon->share_conf,
598 KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS))
599 flags = LOOKUP_FOLLOW;
601 err = kern_path(name, flags, &path);
603 ksmbd_debug(VFS, "can't get %s, err %d\n", name, err);
604 ksmbd_revert_fsids(work);
608 parent = dget_parent(path.dentry);
609 err = ksmbd_vfs_lock_parent(parent, path.dentry);
613 ksmbd_revert_fsids(work);
617 if (!d_inode(path.dentry)->i_nlink) {
622 if (S_ISDIR(d_inode(path.dentry)->i_mode)) {
623 err = vfs_rmdir(&init_user_ns, d_inode(parent), path.dentry);
624 if (err && err != -ENOTEMPTY)
625 ksmbd_debug(VFS, "%s: rmdir failed, err %d\n", name,
628 err = vfs_unlink(&init_user_ns, d_inode(parent), path.dentry,
631 ksmbd_debug(VFS, "%s: unlink failed, err %d\n", name,
636 inode_unlock(d_inode(parent));
639 ksmbd_revert_fsids(work);
644 * ksmbd_vfs_link() - vfs helper for creating smb hardlink
645 * @oldname: source file name
646 * @newname: hardlink name
648 * Return: 0 on success, otherwise error
650 int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,
653 struct path oldpath, newpath;
654 struct dentry *dentry;
658 if (ksmbd_override_fsids(work))
661 if (test_share_config_flag(work->tcon->share_conf,
662 KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS))
663 flags = LOOKUP_FOLLOW;
665 err = kern_path(oldname, flags, &oldpath);
667 pr_err("cannot get linux path for %s, err = %d\n",
672 dentry = kern_path_create(AT_FDCWD, newname, &newpath,
673 flags | LOOKUP_REVAL);
674 if (IS_ERR(dentry)) {
675 err = PTR_ERR(dentry);
676 pr_err("path create err for %s, err %d\n", newname, err);
681 if (oldpath.mnt != newpath.mnt) {
682 pr_err("vfs_link failed err %d\n", err);
686 err = vfs_link(oldpath.dentry, &init_user_ns, d_inode(newpath.dentry),
689 ksmbd_debug(VFS, "vfs_link failed err %d\n", err);
692 done_path_create(&newpath, dentry);
696 ksmbd_revert_fsids(work);
700 static int ksmbd_validate_entry_in_use(struct dentry *src_dent)
702 struct dentry *dst_dent;
704 spin_lock(&src_dent->d_lock);
705 list_for_each_entry(dst_dent, &src_dent->d_subdirs, d_child) {
706 struct ksmbd_file *child_fp;
708 if (d_really_is_negative(dst_dent))
711 child_fp = ksmbd_lookup_fd_inode(d_inode(dst_dent));
713 spin_unlock(&src_dent->d_lock);
714 ksmbd_debug(VFS, "Forbid rename, sub file/dir is in use\n");
718 spin_unlock(&src_dent->d_lock);
723 static int __ksmbd_vfs_rename(struct ksmbd_work *work,
724 struct dentry *src_dent_parent,
725 struct dentry *src_dent,
726 struct dentry *dst_dent_parent,
727 struct dentry *trap_dent,
730 struct dentry *dst_dent;
733 if (!work->tcon->posix_extensions) {
734 err = ksmbd_validate_entry_in_use(src_dent);
739 if (d_really_is_negative(src_dent_parent))
741 if (d_really_is_negative(dst_dent_parent))
743 if (d_really_is_negative(src_dent))
745 if (src_dent == trap_dent)
748 if (ksmbd_override_fsids(work))
751 dst_dent = lookup_one_len(dst_name, dst_dent_parent, strlen(dst_name));
752 err = PTR_ERR(dst_dent);
753 if (IS_ERR(dst_dent)) {
754 pr_err("lookup failed %s [%d]\n", dst_name, err);
759 if (dst_dent != trap_dent && !d_really_is_positive(dst_dent)) {
760 struct renamedata rd = {
761 .old_mnt_userns = &init_user_ns,
762 .old_dir = d_inode(src_dent_parent),
763 .old_dentry = src_dent,
764 .new_mnt_userns = &init_user_ns,
765 .new_dir = d_inode(dst_dent_parent),
766 .new_dentry = dst_dent,
768 err = vfs_rename(&rd);
771 pr_err("vfs_rename failed err %d\n", err);
775 ksmbd_revert_fsids(work);
779 int ksmbd_vfs_fp_rename(struct ksmbd_work *work, struct ksmbd_file *fp,
782 struct path dst_path;
783 struct dentry *src_dent_parent, *dst_dent_parent;
784 struct dentry *src_dent, *trap_dent, *src_child;
789 dst_name = extract_last_component(newname);
793 src_dent_parent = dget_parent(fp->filp->f_path.dentry);
794 src_dent = fp->filp->f_path.dentry;
796 flags = LOOKUP_DIRECTORY;
797 if (test_share_config_flag(work->tcon->share_conf,
798 KSMBD_SHARE_FLAG_FOLLOW_SYMLINKS))
799 flags |= LOOKUP_FOLLOW;
801 err = kern_path(newname, flags, &dst_path);
803 ksmbd_debug(VFS, "Cannot get path for %s [%d]\n", newname, err);
806 dst_dent_parent = dst_path.dentry;
808 trap_dent = lock_rename(src_dent_parent, dst_dent_parent);
810 dget(dst_dent_parent);
811 src_child = lookup_one_len(src_dent->d_name.name, src_dent_parent,
812 src_dent->d_name.len);
813 if (IS_ERR(src_child)) {
814 err = PTR_ERR(src_child);
818 if (src_child != src_dent) {
825 err = __ksmbd_vfs_rename(work,
833 dput(dst_dent_parent);
834 unlock_rename(src_dent_parent, dst_dent_parent);
837 dput(src_dent_parent);
842 * ksmbd_vfs_truncate() - vfs helper for smb file truncate
844 * @name: old filename
845 * @fid: file id of old file
846 * @size: truncate to given size
848 * Return: 0 on success, otherwise error
850 int ksmbd_vfs_truncate(struct ksmbd_work *work, const char *name,
851 struct ksmbd_file *fp, loff_t size)
857 err = kern_path(name, 0, &path);
859 pr_err("cannot get linux path for %s, err %d\n",
863 err = vfs_truncate(&path, size);
865 pr_err("truncate failed for %s err %d\n",
873 /* Do we need to break any of a levelII oplock? */
874 smb_break_all_levII_oplock(work, fp, 1);
876 if (!work->tcon->posix_extensions) {
877 struct inode *inode = file_inode(filp);
879 if (size < inode->i_size) {
880 err = check_lock_range(filp, size,
881 inode->i_size - 1, WRITE);
883 err = check_lock_range(filp, inode->i_size,
888 pr_err("failed due to lock\n");
893 err = vfs_truncate(&filp->f_path, size);
895 pr_err("truncate failed for filename : %s err %d\n",
903 * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes
904 * @dentry: dentry of file for listing xattrs
905 * @list: destination buffer
906 * @size: destination buffer length
908 * Return: xattr list length on success, otherwise error
910 ssize_t ksmbd_vfs_listxattr(struct dentry *dentry, char **list)
915 size = vfs_listxattr(dentry, NULL, 0);
919 vlist = kvmalloc(size, GFP_KERNEL | __GFP_ZERO);
924 size = vfs_listxattr(dentry, vlist, size);
926 ksmbd_debug(VFS, "listxattr failed\n");
934 static ssize_t ksmbd_vfs_xattr_len(struct dentry *dentry, char *xattr_name)
936 return vfs_getxattr(&init_user_ns, dentry, xattr_name, NULL, 0);
940 * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value
941 * @dentry: dentry of file for getting xattrs
942 * @xattr_name: name of xattr name to query
943 * @xattr_buf: destination buffer xattr value
945 * Return: read xattr value length on success, otherwise error
947 ssize_t ksmbd_vfs_getxattr(struct dentry *dentry, char *xattr_name,
954 xattr_len = ksmbd_vfs_xattr_len(dentry, xattr_name);
958 buf = kmalloc(xattr_len + 1, GFP_KERNEL);
962 xattr_len = vfs_getxattr(&init_user_ns, dentry, xattr_name,
963 (void *)buf, xattr_len);
972 * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value
973 * @dentry: dentry to set XATTR at
974 * @name: xattr name for setxattr
975 * @value: xattr value to set
976 * @size: size of xattr value
977 * @flags: destination buffer length
979 * Return: 0 on success, otherwise error
981 int ksmbd_vfs_setxattr(struct dentry *dentry, const char *attr_name,
982 const void *attr_value, size_t attr_size, int flags)
986 err = vfs_setxattr(&init_user_ns, dentry,
992 ksmbd_debug(VFS, "setxattr failed, err %d\n", err);
997 * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options
998 * @filp: file pointer for IO
999 * @options: smb IO options
1001 void ksmbd_vfs_set_fadvise(struct file *filp, __le32 option)
1003 struct address_space *mapping;
1005 mapping = filp->f_mapping;
1007 if (!option || !mapping)
1010 if (option & FILE_WRITE_THROUGH_LE) {
1011 filp->f_flags |= O_SYNC;
1012 } else if (option & FILE_SEQUENTIAL_ONLY_LE) {
1013 filp->f_ra.ra_pages = inode_to_bdi(mapping->host)->ra_pages * 2;
1014 spin_lock(&filp->f_lock);
1015 filp->f_mode &= ~FMODE_RANDOM;
1016 spin_unlock(&filp->f_lock);
1017 } else if (option & FILE_RANDOM_ACCESS_LE) {
1018 spin_lock(&filp->f_lock);
1019 filp->f_mode |= FMODE_RANDOM;
1020 spin_unlock(&filp->f_lock);
1024 int ksmbd_vfs_zero_data(struct ksmbd_work *work, struct ksmbd_file *fp,
1025 loff_t off, loff_t len)
1027 smb_break_all_levII_oplock(work, fp, 1);
1028 if (fp->f_ci->m_fattr & ATTR_SPARSE_FILE_LE)
1029 return vfs_fallocate(fp->filp,
1030 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1033 return vfs_fallocate(fp->filp, FALLOC_FL_ZERO_RANGE, off, len);
1036 int ksmbd_vfs_fqar_lseek(struct ksmbd_file *fp, loff_t start, loff_t length,
1037 struct file_allocated_range_buffer *ranges,
1038 int in_count, int *out_count)
1040 struct file *f = fp->filp;
1041 struct inode *inode = FP_INODE(fp);
1042 loff_t maxbytes = (u64)inode->i_sb->s_maxbytes, end;
1043 loff_t extent_start, extent_end;
1046 if (start > maxbytes)
1053 * Shrink request scope to what the fs can actually handle.
1055 if (length > maxbytes || (maxbytes - length) < start)
1056 length = maxbytes - start;
1058 if (start + length > inode->i_size)
1059 length = inode->i_size - start;
1062 end = start + length;
1063 while (start < end && *out_count < in_count) {
1064 extent_start = f->f_op->llseek(f, start, SEEK_DATA);
1065 if (extent_start < 0) {
1066 if (extent_start != -ENXIO)
1067 ret = (int)extent_start;
1071 if (extent_start >= end)
1074 extent_end = f->f_op->llseek(f, extent_start, SEEK_HOLE);
1075 if (extent_end < 0) {
1076 if (extent_end != -ENXIO)
1077 ret = (int)extent_end;
1079 } else if (extent_start >= extent_end) {
1083 ranges[*out_count].file_offset = cpu_to_le64(extent_start);
1084 ranges[(*out_count)++].length =
1085 cpu_to_le64(min(extent_end, end) - extent_start);
1093 int ksmbd_vfs_remove_xattr(struct dentry *dentry, char *attr_name)
1095 return vfs_removexattr(&init_user_ns, dentry, attr_name);
1098 int ksmbd_vfs_unlink(struct dentry *dir, struct dentry *dentry)
1102 err = ksmbd_vfs_lock_parent(dir, dentry);
1107 if (S_ISDIR(d_inode(dentry)->i_mode))
1108 err = vfs_rmdir(&init_user_ns, d_inode(dir), dentry);
1110 err = vfs_unlink(&init_user_ns, d_inode(dir), dentry, NULL);
1113 inode_unlock(d_inode(dir));
1115 ksmbd_debug(VFS, "failed to delete, err %d\n", err);
1120 static int __dir_empty(struct dir_context *ctx, const char *name, int namlen,
1121 loff_t offset, u64 ino, unsigned int d_type)
1123 struct ksmbd_readdir_data *buf;
1125 buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1126 buf->dirent_count++;
1128 if (buf->dirent_count > 2)
1134 * ksmbd_vfs_empty_dir() - check for empty directory
1135 * @fp: ksmbd file pointer
1137 * Return: true if directory empty, otherwise false
1139 int ksmbd_vfs_empty_dir(struct ksmbd_file *fp)
1142 struct ksmbd_readdir_data readdir_data;
1144 memset(&readdir_data, 0, sizeof(struct ksmbd_readdir_data));
1146 set_ctx_actor(&readdir_data.ctx, __dir_empty);
1147 readdir_data.dirent_count = 0;
1149 err = iterate_dir(fp->filp, &readdir_data.ctx);
1150 if (readdir_data.dirent_count > 2)
1157 static int __caseless_lookup(struct dir_context *ctx, const char *name,
1158 int namlen, loff_t offset, u64 ino,
1159 unsigned int d_type)
1161 struct ksmbd_readdir_data *buf;
1163 buf = container_of(ctx, struct ksmbd_readdir_data, ctx);
1165 if (buf->used != namlen)
1167 if (!strncasecmp((char *)buf->private, name, namlen)) {
1168 memcpy((char *)buf->private, name, namlen);
1169 buf->dirent_count = 1;
1176 * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory
1178 * @name: filename to lookup
1179 * @namelen: filename length
1181 * Return: 0 on success, otherwise error
1183 static int ksmbd_vfs_lookup_in_dir(struct path *dir, char *name, size_t namelen)
1187 int flags = O_RDONLY | O_LARGEFILE;
1188 struct ksmbd_readdir_data readdir_data = {
1189 .ctx.actor = __caseless_lookup,
1195 dfilp = dentry_open(dir, flags, current_cred());
1197 return PTR_ERR(dfilp);
1199 ret = iterate_dir(dfilp, &readdir_data.ctx);
1200 if (readdir_data.dirent_count > 0)
1207 * ksmbd_vfs_kern_path() - lookup a file and get path info
1208 * @name: name of file for lookup
1209 * @flags: lookup flags
1210 * @path: if lookup succeed, return path info
1211 * @caseless: caseless filename lookup
1213 * Return: 0 on success, otherwise error
1215 int ksmbd_vfs_kern_path(char *name, unsigned int flags, struct path *path,
1223 err = kern_path(name, flags, path);
1230 size_t path_len, remain_len;
1232 filepath = kstrdup(name, GFP_KERNEL);
1236 path_len = strlen(filepath);
1237 remain_len = path_len - 1;
1239 err = kern_path("/", flags, &parent);
1243 while (d_can_lookup(parent.dentry)) {
1244 char *filename = filepath + path_len - remain_len;
1245 char *next = strchrnul(filename, '/');
1246 size_t filename_len = next - filename;
1247 bool is_last = !next[0];
1249 if (filename_len == 0)
1252 err = ksmbd_vfs_lookup_in_dir(&parent, filename,
1262 err = kern_path(filepath, flags, &parent);
1267 path->mnt = parent.mnt;
1268 path->dentry = parent.dentry;
1273 remain_len -= filename_len + 1;
1284 int ksmbd_vfs_remove_acl_xattrs(struct dentry *dentry)
1286 char *name, *xattr_list = NULL;
1287 ssize_t xattr_list_len;
1290 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1291 if (xattr_list_len < 0) {
1293 } else if (!xattr_list_len) {
1294 ksmbd_debug(SMB, "empty xattr in the file\n");
1298 for (name = xattr_list; name - xattr_list < xattr_list_len;
1299 name += strlen(name) + 1) {
1300 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1302 if (!strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
1303 sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1) ||
1304 !strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
1305 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1)) {
1306 err = ksmbd_vfs_remove_xattr(dentry, name);
1309 "remove acl xattr failed : %s\n", name);
1317 int ksmbd_vfs_remove_sd_xattrs(struct dentry *dentry)
1319 char *name, *xattr_list = NULL;
1320 ssize_t xattr_list_len;
1323 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1324 if (xattr_list_len < 0) {
1326 } else if (!xattr_list_len) {
1327 ksmbd_debug(SMB, "empty xattr in the file\n");
1331 for (name = xattr_list; name - xattr_list < xattr_list_len;
1332 name += strlen(name) + 1) {
1333 ksmbd_debug(SMB, "%s, len %zd\n", name, strlen(name));
1335 if (!strncmp(name, XATTR_NAME_SD, XATTR_NAME_SD_LEN)) {
1336 err = ksmbd_vfs_remove_xattr(dentry, name);
1338 ksmbd_debug(SMB, "remove xattr failed : %s\n", name);
1346 static struct xattr_smb_acl *ksmbd_vfs_make_xattr_posix_acl(struct inode *inode,
1349 struct xattr_smb_acl *smb_acl = NULL;
1350 struct posix_acl *posix_acls;
1351 struct posix_acl_entry *pa_entry;
1352 struct xattr_acl_entry *xa_entry;
1355 posix_acls = get_acl(inode, acl_type);
1359 smb_acl = kzalloc(sizeof(struct xattr_smb_acl) +
1360 sizeof(struct xattr_acl_entry) * posix_acls->a_count,
1365 smb_acl->count = posix_acls->a_count;
1366 pa_entry = posix_acls->a_entries;
1367 xa_entry = smb_acl->entries;
1368 for (i = 0; i < posix_acls->a_count; i++, pa_entry++, xa_entry++) {
1369 switch (pa_entry->e_tag) {
1371 xa_entry->type = SMB_ACL_USER;
1372 xa_entry->uid = from_kuid(&init_user_ns, pa_entry->e_uid);
1375 xa_entry->type = SMB_ACL_USER_OBJ;
1378 xa_entry->type = SMB_ACL_GROUP;
1379 xa_entry->gid = from_kgid(&init_user_ns, pa_entry->e_gid);
1382 xa_entry->type = SMB_ACL_GROUP_OBJ;
1385 xa_entry->type = SMB_ACL_OTHER;
1388 xa_entry->type = SMB_ACL_MASK;
1391 pr_err("unknown type : 0x%x\n", pa_entry->e_tag);
1395 if (pa_entry->e_perm & ACL_READ)
1396 xa_entry->perm |= SMB_ACL_READ;
1397 if (pa_entry->e_perm & ACL_WRITE)
1398 xa_entry->perm |= SMB_ACL_WRITE;
1399 if (pa_entry->e_perm & ACL_EXECUTE)
1400 xa_entry->perm |= SMB_ACL_EXECUTE;
1403 posix_acl_release(posix_acls);
1407 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
1408 struct smb_ntsd *pntsd, int len)
1411 struct ndr sd_ndr = {0}, acl_ndr = {0};
1412 struct xattr_ntacl acl = {0};
1413 struct xattr_smb_acl *smb_acl, *def_smb_acl = NULL;
1414 struct inode *inode = d_inode(dentry);
1417 acl.hash_type = XATTR_SD_HASH_TYPE_SHA256;
1418 acl.current_time = ksmbd_UnixTimeToNT(current_time(inode));
1420 memcpy(acl.desc, "posix_acl", 9);
1424 cpu_to_le32(le32_to_cpu(pntsd->osidoffset) + NDR_NTSD_OFFSETOF);
1426 cpu_to_le32(le32_to_cpu(pntsd->gsidoffset) + NDR_NTSD_OFFSETOF);
1428 cpu_to_le32(le32_to_cpu(pntsd->dacloffset) + NDR_NTSD_OFFSETOF);
1430 acl.sd_buf = (char *)pntsd;
1433 rc = ksmbd_gen_sd_hash(conn, acl.sd_buf, acl.sd_size, acl.hash);
1435 pr_err("failed to generate hash for ndr acl\n");
1439 smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode, ACL_TYPE_ACCESS);
1440 if (S_ISDIR(inode->i_mode))
1441 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode,
1444 rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl);
1446 pr_err("failed to encode ndr to posix acl\n");
1450 rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
1451 acl.posix_acl_hash);
1453 pr_err("failed to generate hash for ndr acl\n");
1457 rc = ndr_encode_v4_ntacl(&sd_ndr, &acl);
1459 pr_err("failed to encode ndr to posix acl\n");
1463 rc = ksmbd_vfs_setxattr(dentry, XATTR_NAME_SD, sd_ndr.data,
1466 pr_err("Failed to store XATTR ntacl :%d\n", rc);
1470 kfree(acl_ndr.data);
1476 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn *conn, struct dentry *dentry,
1477 struct smb_ntsd **pntsd)
1482 rc = ksmbd_vfs_getxattr(dentry, XATTR_NAME_SD, &n.data);
1484 struct inode *inode = d_inode(dentry);
1485 struct ndr acl_ndr = {0};
1486 struct xattr_ntacl acl;
1487 struct xattr_smb_acl *smb_acl = NULL, *def_smb_acl = NULL;
1488 __u8 cmp_hash[XATTR_SD_HASH_SIZE] = {0};
1491 rc = ndr_decode_v4_ntacl(&n, &acl);
1495 smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode,
1497 if (S_ISDIR(inode->i_mode))
1498 def_smb_acl = ksmbd_vfs_make_xattr_posix_acl(inode,
1501 rc = ndr_encode_posix_acl(&acl_ndr, inode, smb_acl, def_smb_acl);
1503 pr_err("failed to encode ndr to posix acl\n");
1507 rc = ksmbd_gen_sd_hash(conn, acl_ndr.data, acl_ndr.offset,
1510 pr_err("failed to generate hash for ndr acl\n");
1514 if (memcmp(cmp_hash, acl.posix_acl_hash, XATTR_SD_HASH_SIZE)) {
1515 pr_err("hash value diff\n");
1520 *pntsd = acl.sd_buf;
1521 (*pntsd)->osidoffset =
1522 cpu_to_le32(le32_to_cpu((*pntsd)->osidoffset) - NDR_NTSD_OFFSETOF);
1523 (*pntsd)->gsidoffset =
1524 cpu_to_le32(le32_to_cpu((*pntsd)->gsidoffset) - NDR_NTSD_OFFSETOF);
1525 (*pntsd)->dacloffset =
1526 cpu_to_le32(le32_to_cpu((*pntsd)->dacloffset) - NDR_NTSD_OFFSETOF);
1531 kfree(acl_ndr.data);
1539 int ksmbd_vfs_set_dos_attrib_xattr(struct dentry *dentry,
1540 struct xattr_dos_attrib *da)
1545 err = ndr_encode_dos_attr(&n, da);
1549 err = ksmbd_vfs_setxattr(dentry, XATTR_NAME_DOS_ATTRIBUTE,
1550 (void *)n.data, n.offset, 0);
1552 ksmbd_debug(SMB, "failed to store dos attribute in xattr\n");
1558 int ksmbd_vfs_get_dos_attrib_xattr(struct dentry *dentry,
1559 struct xattr_dos_attrib *da)
1564 err = ksmbd_vfs_getxattr(dentry, XATTR_NAME_DOS_ATTRIBUTE,
1568 if (ndr_decode_dos_attr(&n, da))
1572 ksmbd_debug(SMB, "failed to load dos attribute in xattr\n");
1579 * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format
1580 * @p: destination buffer
1581 * @ksmbd_kstat: ksmbd kstat wrapper
1583 void *ksmbd_vfs_init_kstat(char **p, struct ksmbd_kstat *ksmbd_kstat)
1585 struct file_directory_info *info = (struct file_directory_info *)(*p);
1586 struct kstat *kstat = ksmbd_kstat->kstat;
1589 info->FileIndex = 0;
1590 info->CreationTime = cpu_to_le64(ksmbd_kstat->create_time);
1591 time = ksmbd_UnixTimeToNT(kstat->atime);
1592 info->LastAccessTime = cpu_to_le64(time);
1593 time = ksmbd_UnixTimeToNT(kstat->mtime);
1594 info->LastWriteTime = cpu_to_le64(time);
1595 time = ksmbd_UnixTimeToNT(kstat->ctime);
1596 info->ChangeTime = cpu_to_le64(time);
1598 if (ksmbd_kstat->file_attributes & ATTR_DIRECTORY_LE) {
1599 info->EndOfFile = 0;
1600 info->AllocationSize = 0;
1602 info->EndOfFile = cpu_to_le64(kstat->size);
1603 info->AllocationSize = cpu_to_le64(kstat->blocks << 9);
1605 info->ExtFileAttributes = ksmbd_kstat->file_attributes;
1610 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work, struct dentry *dentry,
1611 struct ksmbd_kstat *ksmbd_kstat)
1616 generic_fillattr(&init_user_ns, d_inode(dentry), ksmbd_kstat->kstat);
1618 time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime);
1619 ksmbd_kstat->create_time = time;
1622 * set default value for the case that store dos attributes is not yes
1623 * or that acl is disable in server's filesystem and the config is yes.
1625 if (S_ISDIR(ksmbd_kstat->kstat->mode))
1626 ksmbd_kstat->file_attributes = ATTR_DIRECTORY_LE;
1628 ksmbd_kstat->file_attributes = ATTR_ARCHIVE_LE;
1630 if (test_share_config_flag(work->tcon->share_conf,
1631 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS)) {
1632 struct xattr_dos_attrib da;
1634 rc = ksmbd_vfs_get_dos_attrib_xattr(dentry, &da);
1636 ksmbd_kstat->file_attributes = cpu_to_le32(da.attr);
1637 ksmbd_kstat->create_time = da.create_time;
1639 ksmbd_debug(VFS, "fail to load dos attribute.\n");
1646 ssize_t ksmbd_vfs_casexattr_len(struct dentry *dentry, char *attr_name,
1649 char *name, *xattr_list = NULL;
1650 ssize_t value_len = -ENOENT, xattr_list_len;
1652 xattr_list_len = ksmbd_vfs_listxattr(dentry, &xattr_list);
1653 if (xattr_list_len <= 0)
1656 for (name = xattr_list; name - xattr_list < xattr_list_len;
1657 name += strlen(name) + 1) {
1658 ksmbd_debug(VFS, "%s, len %zd\n", name, strlen(name));
1659 if (strncasecmp(attr_name, name, attr_name_len))
1662 value_len = ksmbd_vfs_xattr_len(dentry, name);
1671 int ksmbd_vfs_xattr_stream_name(char *stream_name, char **xattr_stream_name,
1672 size_t *xattr_stream_name_size, int s_type)
1674 int stream_name_size;
1675 char *xattr_stream_name_buf;
1679 if (s_type == DIR_STREAM)
1680 type = ":$INDEX_ALLOCATION";
1684 type_len = strlen(type);
1685 stream_name_size = strlen(stream_name);
1686 *xattr_stream_name_size = stream_name_size + XATTR_NAME_STREAM_LEN + 1;
1687 xattr_stream_name_buf = kmalloc(*xattr_stream_name_size + type_len,
1689 if (!xattr_stream_name_buf)
1692 memcpy(xattr_stream_name_buf, XATTR_NAME_STREAM, XATTR_NAME_STREAM_LEN);
1694 if (stream_name_size) {
1695 memcpy(&xattr_stream_name_buf[XATTR_NAME_STREAM_LEN],
1696 stream_name, stream_name_size);
1698 memcpy(&xattr_stream_name_buf[*xattr_stream_name_size - 1], type, type_len);
1699 *xattr_stream_name_size += type_len;
1701 xattr_stream_name_buf[*xattr_stream_name_size - 1] = '\0';
1702 *xattr_stream_name = xattr_stream_name_buf;
1707 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work *work,
1708 struct ksmbd_file *src_fp,
1709 struct ksmbd_file *dst_fp,
1710 struct srv_copychunk *chunks,
1711 unsigned int chunk_count,
1712 unsigned int *chunk_count_written,
1713 unsigned int *chunk_size_written,
1714 loff_t *total_size_written)
1717 loff_t src_off, dst_off, src_file_size;
1721 *chunk_count_written = 0;
1722 *chunk_size_written = 0;
1723 *total_size_written = 0;
1725 if (!(src_fp->daccess & (FILE_READ_DATA_LE | FILE_EXECUTE_LE))) {
1726 pr_err("no right to read(%s)\n", FP_FILENAME(src_fp));
1729 if (!(dst_fp->daccess & (FILE_WRITE_DATA_LE | FILE_APPEND_DATA_LE))) {
1730 pr_err("no right to write(%s)\n", FP_FILENAME(dst_fp));
1734 if (ksmbd_stream_fd(src_fp) || ksmbd_stream_fd(dst_fp))
1737 smb_break_all_levII_oplock(work, dst_fp, 1);
1739 if (!work->tcon->posix_extensions) {
1740 for (i = 0; i < chunk_count; i++) {
1741 src_off = le64_to_cpu(chunks[i].SourceOffset);
1742 dst_off = le64_to_cpu(chunks[i].TargetOffset);
1743 len = le32_to_cpu(chunks[i].Length);
1745 if (check_lock_range(src_fp->filp, src_off,
1746 src_off + len - 1, READ))
1748 if (check_lock_range(dst_fp->filp, dst_off,
1749 dst_off + len - 1, WRITE))
1754 src_file_size = i_size_read(file_inode(src_fp->filp));
1756 for (i = 0; i < chunk_count; i++) {
1757 src_off = le64_to_cpu(chunks[i].SourceOffset);
1758 dst_off = le64_to_cpu(chunks[i].TargetOffset);
1759 len = le32_to_cpu(chunks[i].Length);
1761 if (src_off + len > src_file_size)
1764 ret = vfs_copy_file_range(src_fp->filp, src_off,
1765 dst_fp->filp, dst_off, len, 0);
1769 *chunk_count_written += 1;
1770 *total_size_written += ret;
1775 int ksmbd_vfs_posix_lock_wait(struct file_lock *flock)
1777 return wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
1780 int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock *flock, long timeout)
1782 return wait_event_interruptible_timeout(flock->fl_wait,
1787 void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock)
1789 locks_delete_block(flock);
1792 int ksmbd_vfs_set_init_posix_acl(struct inode *inode)
1794 struct posix_acl_state acl_state;
1795 struct posix_acl *acls;
1798 ksmbd_debug(SMB, "Set posix acls\n");
1799 rc = init_acl_state(&acl_state, 1);
1803 /* Set default owner group */
1804 acl_state.owner.allow = (inode->i_mode & 0700) >> 6;
1805 acl_state.group.allow = (inode->i_mode & 0070) >> 3;
1806 acl_state.other.allow = inode->i_mode & 0007;
1807 acl_state.users->aces[acl_state.users->n].uid = inode->i_uid;
1808 acl_state.users->aces[acl_state.users->n++].perms.allow =
1809 acl_state.owner.allow;
1810 acl_state.groups->aces[acl_state.groups->n].gid = inode->i_gid;
1811 acl_state.groups->aces[acl_state.groups->n++].perms.allow =
1812 acl_state.group.allow;
1813 acl_state.mask.allow = 0x07;
1815 acls = posix_acl_alloc(6, GFP_KERNEL);
1817 free_acl_state(&acl_state);
1820 posix_state_to_acl(&acl_state, acls->a_entries);
1821 rc = set_posix_acl(&init_user_ns, inode, ACL_TYPE_ACCESS, acls);
1823 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1825 else if (S_ISDIR(inode->i_mode)) {
1826 posix_state_to_acl(&acl_state, acls->a_entries);
1827 rc = set_posix_acl(&init_user_ns, inode, ACL_TYPE_DEFAULT,
1830 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1833 free_acl_state(&acl_state);
1834 posix_acl_release(acls);
1838 int ksmbd_vfs_inherit_posix_acl(struct inode *inode, struct inode *parent_inode)
1840 struct posix_acl *acls;
1841 struct posix_acl_entry *pace;
1844 acls = get_acl(parent_inode, ACL_TYPE_DEFAULT);
1847 pace = acls->a_entries;
1849 for (i = 0; i < acls->a_count; i++, pace++) {
1850 if (pace->e_tag == ACL_MASK) {
1851 pace->e_perm = 0x07;
1856 rc = set_posix_acl(&init_user_ns, inode, ACL_TYPE_ACCESS, acls);
1858 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1860 if (S_ISDIR(inode->i_mode)) {
1861 rc = set_posix_acl(&init_user_ns, inode, ACL_TYPE_DEFAULT,
1864 ksmbd_debug(SMB, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1867 posix_acl_release(acls);