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/filelock.h>
10 #include <linux/uaccess.h>
11 #include <linux/backing-dev.h>
12 #include <linux/writeback.h>
13 #include <linux/xattr.h>
14 #include <linux/falloc.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>
21 #include <linux/namei.h>
25 #include "connection.h"
27 #include "vfs_cache.h"
33 #include "smb_common.h"
34 #include "mgmt/share_config.h"
35 #include "mgmt/tree_connect.h"
36 #include "mgmt/user_session.h"
37 #include "mgmt/user_config.h"
39 static void ksmbd_vfs_inherit_owner(struct ksmbd_work
*work
,
40 struct inode
*parent_inode
,
43 if (!test_share_config_flag(work
->tcon
->share_conf
,
44 KSMBD_SHARE_FLAG_INHERIT_OWNER
))
47 i_uid_write(inode
, i_uid_read(parent_inode
));
51 * ksmbd_vfs_lock_parent() - lock parent dentry if it is stable
53 int ksmbd_vfs_lock_parent(struct dentry
*parent
, struct dentry
*child
)
55 inode_lock_nested(d_inode(parent
), I_MUTEX_PARENT
);
56 if (child
->d_parent
!= parent
) {
57 inode_unlock(d_inode(parent
));
64 static int ksmbd_vfs_path_lookup_locked(struct ksmbd_share_config
*share_conf
,
65 char *pathname
, unsigned int flags
,
66 struct path
*parent_path
,
70 struct filename
*filename
;
71 struct path
*root_share_path
= &share_conf
->vfs_path
;
75 if (pathname
[0] == '\0') {
76 pathname
= share_conf
->path
;
77 root_share_path
= NULL
;
79 flags
|= LOOKUP_BENEATH
;
82 filename
= getname_kernel(pathname
);
84 return PTR_ERR(filename
);
86 err
= vfs_path_parent_lookup(filename
, flags
,
87 parent_path
, &last
, &type
,
94 if (unlikely(type
!= LAST_NORM
)) {
95 path_put(parent_path
);
100 err
= mnt_want_write(parent_path
->mnt
);
102 path_put(parent_path
);
107 inode_lock_nested(parent_path
->dentry
->d_inode
, I_MUTEX_PARENT
);
108 d
= lookup_one_qstr_excl(&last
, parent_path
->dentry
, 0);
112 if (d_is_negative(d
)) {
118 path
->mnt
= mntget(parent_path
->mnt
);
120 if (test_share_config_flag(share_conf
, KSMBD_SHARE_FLAG_CROSSMNT
)) {
121 err
= follow_down(path
, 0);
132 inode_unlock(d_inode(parent_path
->dentry
));
133 mnt_drop_write(parent_path
->mnt
);
134 path_put(parent_path
);
139 void ksmbd_vfs_query_maximal_access(struct mnt_idmap
*idmap
,
140 struct dentry
*dentry
, __le32
*daccess
)
142 *daccess
= cpu_to_le32(FILE_READ_ATTRIBUTES
| READ_CONTROL
);
144 if (!inode_permission(idmap
, d_inode(dentry
), MAY_OPEN
| MAY_WRITE
))
145 *daccess
|= cpu_to_le32(WRITE_DAC
| WRITE_OWNER
| SYNCHRONIZE
|
146 FILE_WRITE_DATA
| FILE_APPEND_DATA
|
147 FILE_WRITE_EA
| FILE_WRITE_ATTRIBUTES
|
150 if (!inode_permission(idmap
, d_inode(dentry
), MAY_OPEN
| MAY_READ
))
151 *daccess
|= FILE_READ_DATA_LE
| FILE_READ_EA_LE
;
153 if (!inode_permission(idmap
, d_inode(dentry
), MAY_OPEN
| MAY_EXEC
))
154 *daccess
|= FILE_EXECUTE_LE
;
156 if (!inode_permission(idmap
, d_inode(dentry
->d_parent
), MAY_EXEC
| MAY_WRITE
))
157 *daccess
|= FILE_DELETE_LE
;
161 * ksmbd_vfs_create() - vfs helper for smb create file
163 * @name: file name that is relative to share
164 * @mode: file create mode
166 * Return: 0 on success, otherwise error
168 int ksmbd_vfs_create(struct ksmbd_work
*work
, const char *name
, umode_t mode
)
171 struct dentry
*dentry
;
174 dentry
= ksmbd_vfs_kern_path_create(work
, name
,
175 LOOKUP_NO_SYMLINKS
, &path
);
176 if (IS_ERR(dentry
)) {
177 err
= PTR_ERR(dentry
);
179 pr_err("path create failed for %s, err %d\n",
185 err
= vfs_create(mnt_idmap(path
.mnt
), d_inode(path
.dentry
),
188 ksmbd_vfs_inherit_owner(work
, d_inode(path
.dentry
),
191 pr_err("File(%s): creation failed (err:%d)\n", name
, err
);
194 done_path_create(&path
, dentry
);
199 * ksmbd_vfs_mkdir() - vfs helper for smb create directory
201 * @name: directory name that is relative to share
202 * @mode: directory create mode
204 * Return: 0 on success, otherwise error
206 int ksmbd_vfs_mkdir(struct ksmbd_work
*work
, const char *name
, umode_t mode
)
208 struct mnt_idmap
*idmap
;
210 struct dentry
*dentry
;
213 dentry
= ksmbd_vfs_kern_path_create(work
, name
,
214 LOOKUP_NO_SYMLINKS
| LOOKUP_DIRECTORY
,
216 if (IS_ERR(dentry
)) {
217 err
= PTR_ERR(dentry
);
219 ksmbd_debug(VFS
, "path create failed for %s, err %d\n",
224 idmap
= mnt_idmap(path
.mnt
);
226 err
= vfs_mkdir(idmap
, d_inode(path
.dentry
), dentry
, mode
);
227 if (!err
&& d_unhashed(dentry
)) {
230 d
= lookup_one(idmap
, dentry
->d_name
.name
, dentry
->d_parent
,
236 if (unlikely(d_is_negative(d
))) {
242 ksmbd_vfs_inherit_owner(work
, d_inode(path
.dentry
), d_inode(d
));
247 done_path_create(&path
, dentry
);
249 pr_err("mkdir(%s): creation failed (err:%d)\n", name
, err
);
253 static ssize_t
ksmbd_vfs_getcasexattr(struct mnt_idmap
*idmap
,
254 struct dentry
*dentry
, char *attr_name
,
255 int attr_name_len
, char **attr_value
)
257 char *name
, *xattr_list
= NULL
;
258 ssize_t value_len
= -ENOENT
, xattr_list_len
;
260 xattr_list_len
= ksmbd_vfs_listxattr(dentry
, &xattr_list
);
261 if (xattr_list_len
<= 0)
264 for (name
= xattr_list
; name
- xattr_list
< xattr_list_len
;
265 name
+= strlen(name
) + 1) {
266 ksmbd_debug(VFS
, "%s, len %zd\n", name
, strlen(name
));
267 if (strncasecmp(attr_name
, name
, attr_name_len
))
270 value_len
= ksmbd_vfs_getxattr(idmap
,
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(file_mnt_idmap(fp
->filp
),
294 fp
->filp
->f_path
.dentry
,
306 if (v_len
- *pos
< count
)
307 count
= v_len
- *pos
;
309 memcpy(buf
, &stream_buf
[*pos
], count
);
317 * check_lock_range() - vfs helper for smb byte range file locking
318 * @filp: the file to apply the lock to
319 * @start: lock start byte offset
320 * @end: lock end byte offset
321 * @type: byte range type read/write
323 * Return: 0 on success, otherwise error
325 static int check_lock_range(struct file
*filp
, loff_t start
, loff_t end
,
328 struct file_lock
*flock
;
329 struct file_lock_context
*ctx
= locks_inode_context(file_inode(filp
));
332 if (!ctx
|| list_empty_careful(&ctx
->flc_posix
))
335 spin_lock(&ctx
->flc_lock
);
336 list_for_each_entry(flock
, &ctx
->flc_posix
, fl_list
) {
337 /* check conflict locks */
338 if (flock
->fl_end
>= start
&& end
>= flock
->fl_start
) {
339 if (flock
->fl_type
== F_RDLCK
) {
341 pr_err("not allow write by shared lock\n");
345 } else if (flock
->fl_type
== F_WRLCK
) {
346 /* check owner in lock */
347 if (flock
->fl_file
!= filp
) {
349 pr_err("not allow rw access by exclusive lock from other opens\n");
356 spin_unlock(&ctx
->flc_lock
);
361 * ksmbd_vfs_read() - vfs helper for smb file read
363 * @fid: file id of open file
364 * @count: read byte count
366 * @rbuf: read data buffer
368 * Return: number of read bytes on success, otherwise error
370 int ksmbd_vfs_read(struct ksmbd_work
*work
, struct ksmbd_file
*fp
, size_t count
,
371 loff_t
*pos
, char *rbuf
)
373 struct file
*filp
= fp
->filp
;
375 struct inode
*inode
= file_inode(filp
);
377 if (S_ISDIR(inode
->i_mode
))
380 if (unlikely(count
== 0))
383 if (work
->conn
->connection_type
) {
384 if (!(fp
->daccess
& (FILE_READ_DATA_LE
| FILE_EXECUTE_LE
))) {
385 pr_err("no right to read(%pD)\n", fp
->filp
);
390 if (ksmbd_stream_fd(fp
))
391 return ksmbd_vfs_stream_read(fp
, rbuf
, pos
, count
);
393 if (!work
->tcon
->posix_extensions
) {
396 ret
= check_lock_range(filp
, *pos
, *pos
+ count
- 1, READ
);
398 pr_err("unable to read due to lock\n");
403 nbytes
= kernel_read(filp
, rbuf
, count
, pos
);
405 pr_err("smb read failed, err = %zd\n", nbytes
);
413 static int ksmbd_vfs_stream_write(struct ksmbd_file
*fp
, char *buf
, loff_t
*pos
,
416 char *stream_buf
= NULL
, *wbuf
;
417 struct mnt_idmap
*idmap
= file_mnt_idmap(fp
->filp
);
422 ksmbd_debug(VFS
, "write stream data pos : %llu, count : %zd\n",
426 if (size
> XATTR_SIZE_MAX
) {
427 size
= XATTR_SIZE_MAX
;
428 count
= (*pos
+ count
) - XATTR_SIZE_MAX
;
431 v_len
= ksmbd_vfs_getcasexattr(idmap
,
432 fp
->filp
->f_path
.dentry
,
437 pr_err("not found stream in xattr : %zd\n", v_len
);
443 wbuf
= kvzalloc(size
, GFP_KERNEL
);
450 memcpy(wbuf
, stream_buf
, v_len
);
455 memcpy(&stream_buf
[*pos
], buf
, count
);
457 err
= ksmbd_vfs_setxattr(idmap
,
467 fp
->filp
->f_pos
= *pos
;
475 * ksmbd_vfs_write() - vfs helper for smb file write
477 * @fid: file id of open file
478 * @buf: buf containing data for writing
479 * @count: read byte count
481 * @sync: fsync after write
482 * @written: number of bytes written
484 * Return: 0 on success, otherwise error
486 int ksmbd_vfs_write(struct ksmbd_work
*work
, struct ksmbd_file
*fp
,
487 char *buf
, size_t count
, loff_t
*pos
, bool sync
,
491 loff_t offset
= *pos
;
494 if (work
->conn
->connection_type
) {
495 if (!(fp
->daccess
& FILE_WRITE_DATA_LE
)) {
496 pr_err("no right to write(%pD)\n", fp
->filp
);
504 if (ksmbd_stream_fd(fp
)) {
505 err
= ksmbd_vfs_stream_write(fp
, buf
, pos
, count
);
511 if (!work
->tcon
->posix_extensions
) {
512 err
= check_lock_range(filp
, *pos
, *pos
+ count
- 1, WRITE
);
514 pr_err("unable to write due to lock\n");
520 /* Reserve lease break for parent dir at closing time */
521 fp
->reserve_lease_break
= true;
523 /* Do we need to break any of a levelII oplock? */
524 smb_break_all_levII_oplock(work
, fp
, 1);
526 err
= kernel_write(filp
, buf
, count
, pos
);
528 ksmbd_debug(VFS
, "smb write failed, err = %d\n", err
);
536 err
= vfs_fsync_range(filp
, offset
, offset
+ *written
, 0);
538 pr_err("fsync failed for filename = %pD, err = %d\n",
547 * ksmbd_vfs_getattr() - vfs helper for smb getattr
549 * @fid: file id of open file
550 * @attrs: inode attributes
552 * Return: 0 on success, otherwise error
554 int ksmbd_vfs_getattr(const struct path
*path
, struct kstat
*stat
)
558 err
= vfs_getattr(path
, stat
, STATX_BTIME
, AT_STATX_SYNC_AS_STAT
);
560 pr_err("getattr failed, err %d\n", err
);
565 * ksmbd_vfs_fsync() - vfs helper for smb fsync
567 * @fid: file id of open file
569 * Return: 0 on success, otherwise error
571 int ksmbd_vfs_fsync(struct ksmbd_work
*work
, u64 fid
, u64 p_id
)
573 struct ksmbd_file
*fp
;
576 fp
= ksmbd_lookup_fd_slow(work
, fid
, p_id
);
578 pr_err("failed to get filp for fid %llu\n", fid
);
581 err
= vfs_fsync(fp
->filp
, 0);
583 pr_err("smb fsync failed, err = %d\n", err
);
584 ksmbd_fd_put(work
, fp
);
589 * ksmbd_vfs_remove_file() - vfs helper for smb rmdir or unlink
590 * @name: directory or file name that is relative to share
592 * Return: 0 on success, otherwise error
594 int ksmbd_vfs_remove_file(struct ksmbd_work
*work
, const struct path
*path
)
596 struct mnt_idmap
*idmap
;
597 struct dentry
*parent
= path
->dentry
->d_parent
;
600 if (ksmbd_override_fsids(work
))
603 if (!d_inode(path
->dentry
)->i_nlink
) {
608 idmap
= mnt_idmap(path
->mnt
);
609 if (S_ISDIR(d_inode(path
->dentry
)->i_mode
)) {
610 err
= vfs_rmdir(idmap
, d_inode(parent
), path
->dentry
);
611 if (err
&& err
!= -ENOTEMPTY
)
612 ksmbd_debug(VFS
, "rmdir failed, err %d\n", err
);
614 err
= vfs_unlink(idmap
, d_inode(parent
), path
->dentry
, NULL
);
616 ksmbd_debug(VFS
, "unlink failed, err %d\n", err
);
620 ksmbd_revert_fsids(work
);
625 * ksmbd_vfs_link() - vfs helper for creating smb hardlink
626 * @oldname: source file name
627 * @newname: hardlink name that is relative to share
629 * Return: 0 on success, otherwise error
631 int ksmbd_vfs_link(struct ksmbd_work
*work
, const char *oldname
,
634 struct path oldpath
, newpath
;
635 struct dentry
*dentry
;
638 if (ksmbd_override_fsids(work
))
641 err
= kern_path(oldname
, LOOKUP_NO_SYMLINKS
, &oldpath
);
643 pr_err("cannot get linux path for %s, err = %d\n",
648 dentry
= ksmbd_vfs_kern_path_create(work
, newname
,
649 LOOKUP_NO_SYMLINKS
| LOOKUP_REVAL
,
651 if (IS_ERR(dentry
)) {
652 err
= PTR_ERR(dentry
);
653 pr_err("path create err for %s, err %d\n", newname
, err
);
658 if (oldpath
.mnt
!= newpath
.mnt
) {
659 pr_err("vfs_link failed err %d\n", err
);
663 err
= vfs_link(oldpath
.dentry
, mnt_idmap(newpath
.mnt
),
664 d_inode(newpath
.dentry
),
667 ksmbd_debug(VFS
, "vfs_link failed err %d\n", err
);
670 done_path_create(&newpath
, dentry
);
674 ksmbd_revert_fsids(work
);
678 int ksmbd_vfs_rename(struct ksmbd_work
*work
, const struct path
*old_path
,
679 char *newname
, int flags
)
681 struct dentry
*old_parent
, *new_dentry
, *trap
;
682 struct dentry
*old_child
= old_path
->dentry
;
683 struct path new_path
;
684 struct qstr new_last
;
685 struct renamedata rd
;
687 struct ksmbd_share_config
*share_conf
= work
->tcon
->share_conf
;
688 struct ksmbd_file
*parent_fp
;
690 int err
, lookup_flags
= LOOKUP_NO_SYMLINKS
;
692 if (ksmbd_override_fsids(work
))
695 to
= getname_kernel(newname
);
702 err
= vfs_path_parent_lookup(to
, lookup_flags
| LOOKUP_BENEATH
,
703 &new_path
, &new_last
, &new_type
,
704 &share_conf
->vfs_path
);
708 if (old_path
->mnt
!= new_path
.mnt
) {
713 err
= mnt_want_write(old_path
->mnt
);
717 trap
= lock_rename_child(old_child
, new_path
.dentry
);
719 old_parent
= dget(old_child
->d_parent
);
720 if (d_unhashed(old_child
)) {
725 parent_fp
= ksmbd_lookup_fd_inode(old_child
->d_parent
);
727 if (parent_fp
->daccess
& FILE_DELETE_LE
) {
728 pr_err("parent dir is opened with delete access\n");
730 ksmbd_fd_put(work
, parent_fp
);
733 ksmbd_fd_put(work
, parent_fp
);
736 new_dentry
= lookup_one_qstr_excl(&new_last
, new_path
.dentry
,
737 lookup_flags
| LOOKUP_RENAME_TARGET
);
738 if (IS_ERR(new_dentry
)) {
739 err
= PTR_ERR(new_dentry
);
743 if (d_is_symlink(new_dentry
)) {
748 if ((flags
& RENAME_NOREPLACE
) && d_is_positive(new_dentry
)) {
753 if (old_child
== trap
) {
758 if (new_dentry
== trap
) {
763 rd
.old_mnt_idmap
= mnt_idmap(old_path
->mnt
),
764 rd
.old_dir
= d_inode(old_parent
),
765 rd
.old_dentry
= old_child
,
766 rd
.new_mnt_idmap
= mnt_idmap(new_path
.mnt
),
767 rd
.new_dir
= new_path
.dentry
->d_inode
,
768 rd
.new_dentry
= new_dentry
,
770 rd
.delegated_inode
= NULL
,
771 err
= vfs_rename(&rd
);
773 ksmbd_debug(VFS
, "vfs_rename failed err %d\n", err
);
779 unlock_rename(old_parent
, new_path
.dentry
);
780 mnt_drop_write(old_path
->mnt
);
784 if (retry_estale(err
, lookup_flags
)) {
785 lookup_flags
|= LOOKUP_REVAL
;
791 ksmbd_revert_fsids(work
);
796 * ksmbd_vfs_truncate() - vfs helper for smb file truncate
798 * @fid: file id of old file
799 * @size: truncate to given size
801 * Return: 0 on success, otherwise error
803 int ksmbd_vfs_truncate(struct ksmbd_work
*work
,
804 struct ksmbd_file
*fp
, loff_t size
)
811 /* Do we need to break any of a levelII oplock? */
812 smb_break_all_levII_oplock(work
, fp
, 1);
814 if (!work
->tcon
->posix_extensions
) {
815 struct inode
*inode
= file_inode(filp
);
817 if (size
< inode
->i_size
) {
818 err
= check_lock_range(filp
, size
,
819 inode
->i_size
- 1, WRITE
);
821 err
= check_lock_range(filp
, inode
->i_size
,
826 pr_err("failed due to lock\n");
831 err
= vfs_truncate(&filp
->f_path
, size
);
833 pr_err("truncate failed, err %d\n", err
);
838 * ksmbd_vfs_listxattr() - vfs helper for smb list extended attributes
839 * @dentry: dentry of file for listing xattrs
840 * @list: destination buffer
841 * @size: destination buffer length
843 * Return: xattr list length on success, otherwise error
845 ssize_t
ksmbd_vfs_listxattr(struct dentry
*dentry
, char **list
)
850 size
= vfs_listxattr(dentry
, NULL
, 0);
854 vlist
= kvzalloc(size
, GFP_KERNEL
);
859 size
= vfs_listxattr(dentry
, vlist
, size
);
861 ksmbd_debug(VFS
, "listxattr failed\n");
869 static ssize_t
ksmbd_vfs_xattr_len(struct mnt_idmap
*idmap
,
870 struct dentry
*dentry
, char *xattr_name
)
872 return vfs_getxattr(idmap
, dentry
, xattr_name
, NULL
, 0);
876 * ksmbd_vfs_getxattr() - vfs helper for smb get extended attributes value
878 * @dentry: dentry of file for getting xattrs
879 * @xattr_name: name of xattr name to query
880 * @xattr_buf: destination buffer xattr value
882 * Return: read xattr value length on success, otherwise error
884 ssize_t
ksmbd_vfs_getxattr(struct mnt_idmap
*idmap
,
885 struct dentry
*dentry
,
886 char *xattr_name
, char **xattr_buf
)
892 xattr_len
= ksmbd_vfs_xattr_len(idmap
, dentry
, xattr_name
);
896 buf
= kmalloc(xattr_len
+ 1, GFP_KERNEL
);
900 xattr_len
= vfs_getxattr(idmap
, dentry
, xattr_name
,
901 (void *)buf
, xattr_len
);
910 * ksmbd_vfs_setxattr() - vfs helper for smb set extended attributes value
911 * @idmap: idmap of the relevant mount
912 * @path: path of dentry to set XATTR at
913 * @attr_name: xattr name for setxattr
914 * @attr_value: xattr value to set
915 * @attr_size: size of xattr value
916 * @flags: destination buffer length
917 * @get_write: get write access to a mount
919 * Return: 0 on success, otherwise error
921 int ksmbd_vfs_setxattr(struct mnt_idmap
*idmap
,
922 const struct path
*path
, const char *attr_name
,
923 void *attr_value
, size_t attr_size
, int flags
,
928 if (get_write
== true) {
929 err
= mnt_want_write(path
->mnt
);
934 err
= vfs_setxattr(idmap
,
941 ksmbd_debug(VFS
, "setxattr failed, err %d\n", err
);
942 if (get_write
== true)
943 mnt_drop_write(path
->mnt
);
948 * ksmbd_vfs_set_fadvise() - convert smb IO caching options to linux options
949 * @filp: file pointer for IO
950 * @options: smb IO options
952 void ksmbd_vfs_set_fadvise(struct file
*filp
, __le32 option
)
954 struct address_space
*mapping
;
956 mapping
= filp
->f_mapping
;
958 if (!option
|| !mapping
)
961 if (option
& FILE_WRITE_THROUGH_LE
) {
962 filp
->f_flags
|= O_SYNC
;
963 } else if (option
& FILE_SEQUENTIAL_ONLY_LE
) {
964 filp
->f_ra
.ra_pages
= inode_to_bdi(mapping
->host
)->ra_pages
* 2;
965 spin_lock(&filp
->f_lock
);
966 filp
->f_mode
&= ~FMODE_RANDOM
;
967 spin_unlock(&filp
->f_lock
);
968 } else if (option
& FILE_RANDOM_ACCESS_LE
) {
969 spin_lock(&filp
->f_lock
);
970 filp
->f_mode
|= FMODE_RANDOM
;
971 spin_unlock(&filp
->f_lock
);
975 int ksmbd_vfs_zero_data(struct ksmbd_work
*work
, struct ksmbd_file
*fp
,
976 loff_t off
, loff_t len
)
978 smb_break_all_levII_oplock(work
, fp
, 1);
979 if (fp
->f_ci
->m_fattr
& FILE_ATTRIBUTE_SPARSE_FILE_LE
)
980 return vfs_fallocate(fp
->filp
,
981 FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
,
984 return vfs_fallocate(fp
->filp
,
985 FALLOC_FL_ZERO_RANGE
| FALLOC_FL_KEEP_SIZE
,
989 int ksmbd_vfs_fqar_lseek(struct ksmbd_file
*fp
, loff_t start
, loff_t length
,
990 struct file_allocated_range_buffer
*ranges
,
991 unsigned int in_count
, unsigned int *out_count
)
993 struct file
*f
= fp
->filp
;
994 struct inode
*inode
= file_inode(fp
->filp
);
995 loff_t maxbytes
= (u64
)inode
->i_sb
->s_maxbytes
, end
;
996 loff_t extent_start
, extent_end
;
999 if (start
> maxbytes
)
1006 * Shrink request scope to what the fs can actually handle.
1008 if (length
> maxbytes
|| (maxbytes
- length
) < start
)
1009 length
= maxbytes
- start
;
1011 if (start
+ length
> inode
->i_size
)
1012 length
= inode
->i_size
- start
;
1015 end
= start
+ length
;
1016 while (start
< end
&& *out_count
< in_count
) {
1017 extent_start
= vfs_llseek(f
, start
, SEEK_DATA
);
1018 if (extent_start
< 0) {
1019 if (extent_start
!= -ENXIO
)
1020 ret
= (int)extent_start
;
1024 if (extent_start
>= end
)
1027 extent_end
= vfs_llseek(f
, extent_start
, SEEK_HOLE
);
1028 if (extent_end
< 0) {
1029 if (extent_end
!= -ENXIO
)
1030 ret
= (int)extent_end
;
1032 } else if (extent_start
>= extent_end
) {
1036 ranges
[*out_count
].file_offset
= cpu_to_le64(extent_start
);
1037 ranges
[(*out_count
)++].length
=
1038 cpu_to_le64(min(extent_end
, end
) - extent_start
);
1046 int ksmbd_vfs_remove_xattr(struct mnt_idmap
*idmap
,
1047 const struct path
*path
, char *attr_name
)
1051 err
= mnt_want_write(path
->mnt
);
1055 err
= vfs_removexattr(idmap
, path
->dentry
, attr_name
);
1056 mnt_drop_write(path
->mnt
);
1061 int ksmbd_vfs_unlink(struct file
*filp
)
1064 struct dentry
*dir
, *dentry
= filp
->f_path
.dentry
;
1065 struct mnt_idmap
*idmap
= file_mnt_idmap(filp
);
1067 err
= mnt_want_write(filp
->f_path
.mnt
);
1071 dir
= dget_parent(dentry
);
1072 err
= ksmbd_vfs_lock_parent(dir
, dentry
);
1077 if (S_ISDIR(d_inode(dentry
)->i_mode
))
1078 err
= vfs_rmdir(idmap
, d_inode(dir
), dentry
);
1080 err
= vfs_unlink(idmap
, d_inode(dir
), dentry
, NULL
);
1083 inode_unlock(d_inode(dir
));
1085 ksmbd_debug(VFS
, "failed to delete, err %d\n", err
);
1088 mnt_drop_write(filp
->f_path
.mnt
);
1093 static bool __dir_empty(struct dir_context
*ctx
, const char *name
, int namlen
,
1094 loff_t offset
, u64 ino
, unsigned int d_type
)
1096 struct ksmbd_readdir_data
*buf
;
1098 buf
= container_of(ctx
, struct ksmbd_readdir_data
, ctx
);
1099 buf
->dirent_count
++;
1101 return buf
->dirent_count
<= 2;
1105 * ksmbd_vfs_empty_dir() - check for empty directory
1106 * @fp: ksmbd file pointer
1108 * Return: true if directory empty, otherwise false
1110 int ksmbd_vfs_empty_dir(struct ksmbd_file
*fp
)
1113 struct ksmbd_readdir_data readdir_data
;
1115 memset(&readdir_data
, 0, sizeof(struct ksmbd_readdir_data
));
1117 set_ctx_actor(&readdir_data
.ctx
, __dir_empty
);
1118 readdir_data
.dirent_count
= 0;
1120 err
= iterate_dir(fp
->filp
, &readdir_data
.ctx
);
1121 if (readdir_data
.dirent_count
> 2)
1128 static bool __caseless_lookup(struct dir_context
*ctx
, const char *name
,
1129 int namlen
, loff_t offset
, u64 ino
,
1130 unsigned int d_type
)
1132 struct ksmbd_readdir_data
*buf
;
1135 buf
= container_of(ctx
, struct ksmbd_readdir_data
, ctx
);
1137 if (buf
->used
!= namlen
)
1139 if (IS_ENABLED(CONFIG_UNICODE
) && buf
->um
) {
1140 const struct qstr q_buf
= {.name
= buf
->private,
1142 const struct qstr q_name
= {.name
= name
,
1145 cmp
= utf8_strncasecmp(buf
->um
, &q_buf
, &q_name
);
1148 cmp
= strncasecmp((char *)buf
->private, name
, namlen
);
1150 memcpy((char *)buf
->private, name
, namlen
);
1151 buf
->dirent_count
= 1;
1158 * ksmbd_vfs_lookup_in_dir() - lookup a file in a directory
1160 * @name: filename to lookup
1161 * @namelen: filename length
1163 * Return: 0 on success, otherwise error
1165 static int ksmbd_vfs_lookup_in_dir(const struct path
*dir
, char *name
,
1166 size_t namelen
, struct unicode_map
*um
)
1170 int flags
= O_RDONLY
| O_LARGEFILE
;
1171 struct ksmbd_readdir_data readdir_data
= {
1172 .ctx
.actor
= __caseless_lookup
,
1179 dfilp
= dentry_open(dir
, flags
, current_cred());
1181 return PTR_ERR(dfilp
);
1183 ret
= iterate_dir(dfilp
, &readdir_data
.ctx
);
1184 if (readdir_data
.dirent_count
> 0)
1191 * ksmbd_vfs_kern_path_locked() - lookup a file and get path info
1192 * @name: file path that is relative to share
1193 * @flags: lookup flags
1194 * @parent_path: if lookup succeed, return parent_path info
1195 * @path: if lookup succeed, return path info
1196 * @caseless: caseless filename lookup
1198 * Return: 0 on success, otherwise error
1200 int ksmbd_vfs_kern_path_locked(struct ksmbd_work
*work
, char *name
,
1201 unsigned int flags
, struct path
*parent_path
,
1202 struct path
*path
, bool caseless
)
1204 struct ksmbd_share_config
*share_conf
= work
->tcon
->share_conf
;
1207 err
= ksmbd_vfs_path_lookup_locked(share_conf
, name
, flags
, parent_path
,
1214 size_t path_len
, remain_len
;
1216 filepath
= kstrdup(name
, GFP_KERNEL
);
1220 path_len
= strlen(filepath
);
1221 remain_len
= path_len
;
1223 *parent_path
= share_conf
->vfs_path
;
1224 path_get(parent_path
);
1226 while (d_can_lookup(parent_path
->dentry
)) {
1227 char *filename
= filepath
+ path_len
- remain_len
;
1228 char *next
= strchrnul(filename
, '/');
1229 size_t filename_len
= next
- filename
;
1230 bool is_last
= !next
[0];
1232 if (filename_len
== 0)
1235 err
= ksmbd_vfs_lookup_in_dir(parent_path
, filename
,
1243 err
= vfs_path_lookup(share_conf
->vfs_path
.dentry
,
1244 share_conf
->vfs_path
.mnt
,
1252 path_put(parent_path
);
1253 *parent_path
= *path
;
1256 remain_len
-= filename_len
+ 1;
1261 path_put(parent_path
);
1267 err
= mnt_want_write(parent_path
->mnt
);
1270 path_put(parent_path
);
1274 err
= ksmbd_vfs_lock_parent(parent_path
->dentry
, path
->dentry
);
1277 path_put(parent_path
);
1283 void ksmbd_vfs_kern_path_unlock(struct path
*parent_path
, struct path
*path
)
1285 inode_unlock(d_inode(parent_path
->dentry
));
1286 mnt_drop_write(parent_path
->mnt
);
1288 path_put(parent_path
);
1291 struct dentry
*ksmbd_vfs_kern_path_create(struct ksmbd_work
*work
,
1297 struct dentry
*dent
;
1299 abs_name
= convert_to_unix_name(work
->tcon
->share_conf
, name
);
1301 return ERR_PTR(-ENOMEM
);
1303 dent
= kern_path_create(AT_FDCWD
, abs_name
, path
, flags
);
1308 int ksmbd_vfs_remove_acl_xattrs(struct mnt_idmap
*idmap
,
1309 const struct path
*path
)
1311 char *name
, *xattr_list
= NULL
;
1312 ssize_t xattr_list_len
;
1315 xattr_list_len
= ksmbd_vfs_listxattr(path
->dentry
, &xattr_list
);
1316 if (xattr_list_len
< 0) {
1318 } else if (!xattr_list_len
) {
1319 ksmbd_debug(SMB
, "empty xattr in the file\n");
1323 err
= mnt_want_write(path
->mnt
);
1327 for (name
= xattr_list
; name
- xattr_list
< xattr_list_len
;
1328 name
+= strlen(name
) + 1) {
1329 ksmbd_debug(SMB
, "%s, len %zd\n", name
, strlen(name
));
1331 if (!strncmp(name
, XATTR_NAME_POSIX_ACL_ACCESS
,
1332 sizeof(XATTR_NAME_POSIX_ACL_ACCESS
) - 1) ||
1333 !strncmp(name
, XATTR_NAME_POSIX_ACL_DEFAULT
,
1334 sizeof(XATTR_NAME_POSIX_ACL_DEFAULT
) - 1)) {
1335 err
= vfs_remove_acl(idmap
, path
->dentry
, name
);
1338 "remove acl xattr failed : %s\n", name
);
1341 mnt_drop_write(path
->mnt
);
1348 int ksmbd_vfs_remove_sd_xattrs(struct mnt_idmap
*idmap
, const struct path
*path
)
1350 char *name
, *xattr_list
= NULL
;
1351 ssize_t xattr_list_len
;
1354 xattr_list_len
= ksmbd_vfs_listxattr(path
->dentry
, &xattr_list
);
1355 if (xattr_list_len
< 0) {
1357 } else if (!xattr_list_len
) {
1358 ksmbd_debug(SMB
, "empty xattr in the file\n");
1362 for (name
= xattr_list
; name
- xattr_list
< xattr_list_len
;
1363 name
+= strlen(name
) + 1) {
1364 ksmbd_debug(SMB
, "%s, len %zd\n", name
, strlen(name
));
1366 if (!strncmp(name
, XATTR_NAME_SD
, XATTR_NAME_SD_LEN
)) {
1367 err
= ksmbd_vfs_remove_xattr(idmap
, path
, name
);
1369 ksmbd_debug(SMB
, "remove xattr failed : %s\n", name
);
1377 static struct xattr_smb_acl
*ksmbd_vfs_make_xattr_posix_acl(struct mnt_idmap
*idmap
,
1378 struct inode
*inode
,
1381 struct xattr_smb_acl
*smb_acl
= NULL
;
1382 struct posix_acl
*posix_acls
;
1383 struct posix_acl_entry
*pa_entry
;
1384 struct xattr_acl_entry
*xa_entry
;
1387 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
))
1390 posix_acls
= get_inode_acl(inode
, acl_type
);
1391 if (IS_ERR_OR_NULL(posix_acls
))
1394 smb_acl
= kzalloc(sizeof(struct xattr_smb_acl
) +
1395 sizeof(struct xattr_acl_entry
) * posix_acls
->a_count
,
1400 smb_acl
->count
= posix_acls
->a_count
;
1401 pa_entry
= posix_acls
->a_entries
;
1402 xa_entry
= smb_acl
->entries
;
1403 for (i
= 0; i
< posix_acls
->a_count
; i
++, pa_entry
++, xa_entry
++) {
1404 switch (pa_entry
->e_tag
) {
1406 xa_entry
->type
= SMB_ACL_USER
;
1407 xa_entry
->uid
= posix_acl_uid_translate(idmap
, pa_entry
);
1410 xa_entry
->type
= SMB_ACL_USER_OBJ
;
1413 xa_entry
->type
= SMB_ACL_GROUP
;
1414 xa_entry
->gid
= posix_acl_gid_translate(idmap
, pa_entry
);
1417 xa_entry
->type
= SMB_ACL_GROUP_OBJ
;
1420 xa_entry
->type
= SMB_ACL_OTHER
;
1423 xa_entry
->type
= SMB_ACL_MASK
;
1426 pr_err("unknown type : 0x%x\n", pa_entry
->e_tag
);
1430 if (pa_entry
->e_perm
& ACL_READ
)
1431 xa_entry
->perm
|= SMB_ACL_READ
;
1432 if (pa_entry
->e_perm
& ACL_WRITE
)
1433 xa_entry
->perm
|= SMB_ACL_WRITE
;
1434 if (pa_entry
->e_perm
& ACL_EXECUTE
)
1435 xa_entry
->perm
|= SMB_ACL_EXECUTE
;
1438 posix_acl_release(posix_acls
);
1442 int ksmbd_vfs_set_sd_xattr(struct ksmbd_conn
*conn
,
1443 struct mnt_idmap
*idmap
,
1444 const struct path
*path
,
1445 struct smb_ntsd
*pntsd
, int len
,
1449 struct ndr sd_ndr
= {0}, acl_ndr
= {0};
1450 struct xattr_ntacl acl
= {0};
1451 struct xattr_smb_acl
*smb_acl
, *def_smb_acl
= NULL
;
1452 struct dentry
*dentry
= path
->dentry
;
1453 struct inode
*inode
= d_inode(dentry
);
1456 acl
.hash_type
= XATTR_SD_HASH_TYPE_SHA256
;
1457 acl
.current_time
= ksmbd_UnixTimeToNT(current_time(inode
));
1459 memcpy(acl
.desc
, "posix_acl", 9);
1463 cpu_to_le32(le32_to_cpu(pntsd
->osidoffset
) + NDR_NTSD_OFFSETOF
);
1465 cpu_to_le32(le32_to_cpu(pntsd
->gsidoffset
) + NDR_NTSD_OFFSETOF
);
1467 cpu_to_le32(le32_to_cpu(pntsd
->dacloffset
) + NDR_NTSD_OFFSETOF
);
1469 acl
.sd_buf
= (char *)pntsd
;
1472 rc
= ksmbd_gen_sd_hash(conn
, acl
.sd_buf
, acl
.sd_size
, acl
.hash
);
1474 pr_err("failed to generate hash for ndr acl\n");
1478 smb_acl
= ksmbd_vfs_make_xattr_posix_acl(idmap
, inode
,
1480 if (S_ISDIR(inode
->i_mode
))
1481 def_smb_acl
= ksmbd_vfs_make_xattr_posix_acl(idmap
, inode
,
1484 rc
= ndr_encode_posix_acl(&acl_ndr
, idmap
, inode
,
1485 smb_acl
, def_smb_acl
);
1487 pr_err("failed to encode ndr to posix acl\n");
1491 rc
= ksmbd_gen_sd_hash(conn
, acl_ndr
.data
, acl_ndr
.offset
,
1492 acl
.posix_acl_hash
);
1494 pr_err("failed to generate hash for ndr acl\n");
1498 rc
= ndr_encode_v4_ntacl(&sd_ndr
, &acl
);
1500 pr_err("failed to encode ndr to posix acl\n");
1504 rc
= ksmbd_vfs_setxattr(idmap
, path
,
1505 XATTR_NAME_SD
, sd_ndr
.data
,
1506 sd_ndr
.offset
, 0, get_write
);
1508 pr_err("Failed to store XATTR ntacl :%d\n", rc
);
1512 kfree(acl_ndr
.data
);
1518 int ksmbd_vfs_get_sd_xattr(struct ksmbd_conn
*conn
,
1519 struct mnt_idmap
*idmap
,
1520 struct dentry
*dentry
,
1521 struct smb_ntsd
**pntsd
)
1525 struct inode
*inode
= d_inode(dentry
);
1526 struct ndr acl_ndr
= {0};
1527 struct xattr_ntacl acl
;
1528 struct xattr_smb_acl
*smb_acl
= NULL
, *def_smb_acl
= NULL
;
1529 __u8 cmp_hash
[XATTR_SD_HASH_SIZE
] = {0};
1531 rc
= ksmbd_vfs_getxattr(idmap
, dentry
, XATTR_NAME_SD
, &n
.data
);
1536 rc
= ndr_decode_v4_ntacl(&n
, &acl
);
1540 smb_acl
= ksmbd_vfs_make_xattr_posix_acl(idmap
, inode
,
1542 if (S_ISDIR(inode
->i_mode
))
1543 def_smb_acl
= ksmbd_vfs_make_xattr_posix_acl(idmap
, inode
,
1546 rc
= ndr_encode_posix_acl(&acl_ndr
, idmap
, inode
, smb_acl
,
1549 pr_err("failed to encode ndr to posix acl\n");
1553 rc
= ksmbd_gen_sd_hash(conn
, acl_ndr
.data
, acl_ndr
.offset
, cmp_hash
);
1555 pr_err("failed to generate hash for ndr acl\n");
1559 if (memcmp(cmp_hash
, acl
.posix_acl_hash
, XATTR_SD_HASH_SIZE
)) {
1560 pr_err("hash value diff\n");
1565 *pntsd
= acl
.sd_buf
;
1566 if (acl
.sd_size
< sizeof(struct smb_ntsd
)) {
1567 pr_err("sd size is invalid\n");
1571 (*pntsd
)->osidoffset
= cpu_to_le32(le32_to_cpu((*pntsd
)->osidoffset
) -
1573 (*pntsd
)->gsidoffset
= cpu_to_le32(le32_to_cpu((*pntsd
)->gsidoffset
) -
1575 (*pntsd
)->dacloffset
= cpu_to_le32(le32_to_cpu((*pntsd
)->dacloffset
) -
1580 kfree(acl_ndr
.data
);
1593 int ksmbd_vfs_set_dos_attrib_xattr(struct mnt_idmap
*idmap
,
1594 const struct path
*path
,
1595 struct xattr_dos_attrib
*da
,
1601 err
= ndr_encode_dos_attr(&n
, da
);
1605 err
= ksmbd_vfs_setxattr(idmap
, path
, XATTR_NAME_DOS_ATTRIBUTE
,
1606 (void *)n
.data
, n
.offset
, 0, get_write
);
1608 ksmbd_debug(SMB
, "failed to store dos attribute in xattr\n");
1614 int ksmbd_vfs_get_dos_attrib_xattr(struct mnt_idmap
*idmap
,
1615 struct dentry
*dentry
,
1616 struct xattr_dos_attrib
*da
)
1621 err
= ksmbd_vfs_getxattr(idmap
, dentry
, XATTR_NAME_DOS_ATTRIBUTE
,
1625 if (ndr_decode_dos_attr(&n
, da
))
1629 ksmbd_debug(SMB
, "failed to load dos attribute in xattr\n");
1636 * ksmbd_vfs_init_kstat() - convert unix stat information to smb stat format
1637 * @p: destination buffer
1638 * @ksmbd_kstat: ksmbd kstat wrapper
1640 void *ksmbd_vfs_init_kstat(char **p
, struct ksmbd_kstat
*ksmbd_kstat
)
1642 struct file_directory_info
*info
= (struct file_directory_info
*)(*p
);
1643 struct kstat
*kstat
= ksmbd_kstat
->kstat
;
1646 info
->FileIndex
= 0;
1647 info
->CreationTime
= cpu_to_le64(ksmbd_kstat
->create_time
);
1648 time
= ksmbd_UnixTimeToNT(kstat
->atime
);
1649 info
->LastAccessTime
= cpu_to_le64(time
);
1650 time
= ksmbd_UnixTimeToNT(kstat
->mtime
);
1651 info
->LastWriteTime
= cpu_to_le64(time
);
1652 time
= ksmbd_UnixTimeToNT(kstat
->ctime
);
1653 info
->ChangeTime
= cpu_to_le64(time
);
1655 if (ksmbd_kstat
->file_attributes
& FILE_ATTRIBUTE_DIRECTORY_LE
) {
1656 info
->EndOfFile
= 0;
1657 info
->AllocationSize
= 0;
1659 info
->EndOfFile
= cpu_to_le64(kstat
->size
);
1660 info
->AllocationSize
= cpu_to_le64(kstat
->blocks
<< 9);
1662 info
->ExtFileAttributes
= ksmbd_kstat
->file_attributes
;
1667 int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work
*work
,
1668 struct mnt_idmap
*idmap
,
1669 struct dentry
*dentry
,
1670 struct ksmbd_kstat
*ksmbd_kstat
)
1675 generic_fillattr(idmap
, STATX_BASIC_STATS
, d_inode(dentry
),
1676 ksmbd_kstat
->kstat
);
1678 time
= ksmbd_UnixTimeToNT(ksmbd_kstat
->kstat
->ctime
);
1679 ksmbd_kstat
->create_time
= time
;
1682 * set default value for the case that store dos attributes is not yes
1683 * or that acl is disable in server's filesystem and the config is yes.
1685 if (S_ISDIR(ksmbd_kstat
->kstat
->mode
))
1686 ksmbd_kstat
->file_attributes
= FILE_ATTRIBUTE_DIRECTORY_LE
;
1688 ksmbd_kstat
->file_attributes
= FILE_ATTRIBUTE_ARCHIVE_LE
;
1690 if (test_share_config_flag(work
->tcon
->share_conf
,
1691 KSMBD_SHARE_FLAG_STORE_DOS_ATTRS
)) {
1692 struct xattr_dos_attrib da
;
1694 rc
= ksmbd_vfs_get_dos_attrib_xattr(idmap
, dentry
, &da
);
1696 ksmbd_kstat
->file_attributes
= cpu_to_le32(da
.attr
);
1697 ksmbd_kstat
->create_time
= da
.create_time
;
1699 ksmbd_debug(VFS
, "fail to load dos attribute.\n");
1706 ssize_t
ksmbd_vfs_casexattr_len(struct mnt_idmap
*idmap
,
1707 struct dentry
*dentry
, char *attr_name
,
1710 char *name
, *xattr_list
= NULL
;
1711 ssize_t value_len
= -ENOENT
, xattr_list_len
;
1713 xattr_list_len
= ksmbd_vfs_listxattr(dentry
, &xattr_list
);
1714 if (xattr_list_len
<= 0)
1717 for (name
= xattr_list
; name
- xattr_list
< xattr_list_len
;
1718 name
+= strlen(name
) + 1) {
1719 ksmbd_debug(VFS
, "%s, len %zd\n", name
, strlen(name
));
1720 if (strncasecmp(attr_name
, name
, attr_name_len
))
1723 value_len
= ksmbd_vfs_xattr_len(idmap
, dentry
, name
);
1732 int ksmbd_vfs_xattr_stream_name(char *stream_name
, char **xattr_stream_name
,
1733 size_t *xattr_stream_name_size
, int s_type
)
1737 if (s_type
== DIR_STREAM
)
1738 type
= ":$INDEX_ALLOCATION";
1742 buf
= kasprintf(GFP_KERNEL
, "%s%s%s",
1743 XATTR_NAME_STREAM
, stream_name
, type
);
1747 *xattr_stream_name
= buf
;
1748 *xattr_stream_name_size
= strlen(buf
) + 1;
1753 int ksmbd_vfs_copy_file_ranges(struct ksmbd_work
*work
,
1754 struct ksmbd_file
*src_fp
,
1755 struct ksmbd_file
*dst_fp
,
1756 struct srv_copychunk
*chunks
,
1757 unsigned int chunk_count
,
1758 unsigned int *chunk_count_written
,
1759 unsigned int *chunk_size_written
,
1760 loff_t
*total_size_written
)
1763 loff_t src_off
, dst_off
, src_file_size
;
1767 *chunk_count_written
= 0;
1768 *chunk_size_written
= 0;
1769 *total_size_written
= 0;
1771 if (!(src_fp
->daccess
& (FILE_READ_DATA_LE
| FILE_EXECUTE_LE
))) {
1772 pr_err("no right to read(%pD)\n", src_fp
->filp
);
1775 if (!(dst_fp
->daccess
& (FILE_WRITE_DATA_LE
| FILE_APPEND_DATA_LE
))) {
1776 pr_err("no right to write(%pD)\n", dst_fp
->filp
);
1780 if (ksmbd_stream_fd(src_fp
) || ksmbd_stream_fd(dst_fp
))
1783 smb_break_all_levII_oplock(work
, dst_fp
, 1);
1785 if (!work
->tcon
->posix_extensions
) {
1786 for (i
= 0; i
< chunk_count
; i
++) {
1787 src_off
= le64_to_cpu(chunks
[i
].SourceOffset
);
1788 dst_off
= le64_to_cpu(chunks
[i
].TargetOffset
);
1789 len
= le32_to_cpu(chunks
[i
].Length
);
1791 if (check_lock_range(src_fp
->filp
, src_off
,
1792 src_off
+ len
- 1, READ
))
1794 if (check_lock_range(dst_fp
->filp
, dst_off
,
1795 dst_off
+ len
- 1, WRITE
))
1800 src_file_size
= i_size_read(file_inode(src_fp
->filp
));
1802 for (i
= 0; i
< chunk_count
; i
++) {
1803 src_off
= le64_to_cpu(chunks
[i
].SourceOffset
);
1804 dst_off
= le64_to_cpu(chunks
[i
].TargetOffset
);
1805 len
= le32_to_cpu(chunks
[i
].Length
);
1807 if (src_off
+ len
> src_file_size
)
1810 ret
= vfs_copy_file_range(src_fp
->filp
, src_off
,
1811 dst_fp
->filp
, dst_off
, len
, 0);
1812 if (ret
== -EOPNOTSUPP
|| ret
== -EXDEV
)
1813 ret
= vfs_copy_file_range(src_fp
->filp
, src_off
,
1814 dst_fp
->filp
, dst_off
, len
,
1819 *chunk_count_written
+= 1;
1820 *total_size_written
+= ret
;
1825 void ksmbd_vfs_posix_lock_wait(struct file_lock
*flock
)
1827 wait_event(flock
->fl_wait
, !flock
->fl_blocker
);
1830 int ksmbd_vfs_posix_lock_wait_timeout(struct file_lock
*flock
, long timeout
)
1832 return wait_event_interruptible_timeout(flock
->fl_wait
,
1837 void ksmbd_vfs_posix_lock_unblock(struct file_lock
*flock
)
1839 locks_delete_block(flock
);
1842 int ksmbd_vfs_set_init_posix_acl(struct mnt_idmap
*idmap
,
1845 struct posix_acl_state acl_state
;
1846 struct posix_acl
*acls
;
1847 struct dentry
*dentry
= path
->dentry
;
1848 struct inode
*inode
= d_inode(dentry
);
1851 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
))
1854 ksmbd_debug(SMB
, "Set posix acls\n");
1855 rc
= init_acl_state(&acl_state
, 1);
1859 /* Set default owner group */
1860 acl_state
.owner
.allow
= (inode
->i_mode
& 0700) >> 6;
1861 acl_state
.group
.allow
= (inode
->i_mode
& 0070) >> 3;
1862 acl_state
.other
.allow
= inode
->i_mode
& 0007;
1863 acl_state
.users
->aces
[acl_state
.users
->n
].uid
= inode
->i_uid
;
1864 acl_state
.users
->aces
[acl_state
.users
->n
++].perms
.allow
=
1865 acl_state
.owner
.allow
;
1866 acl_state
.groups
->aces
[acl_state
.groups
->n
].gid
= inode
->i_gid
;
1867 acl_state
.groups
->aces
[acl_state
.groups
->n
++].perms
.allow
=
1868 acl_state
.group
.allow
;
1869 acl_state
.mask
.allow
= 0x07;
1871 acls
= posix_acl_alloc(6, GFP_KERNEL
);
1873 free_acl_state(&acl_state
);
1876 posix_state_to_acl(&acl_state
, acls
->a_entries
);
1878 rc
= set_posix_acl(idmap
, dentry
, ACL_TYPE_ACCESS
, acls
);
1880 ksmbd_debug(SMB
, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1882 else if (S_ISDIR(inode
->i_mode
)) {
1883 posix_state_to_acl(&acl_state
, acls
->a_entries
);
1884 rc
= set_posix_acl(idmap
, dentry
, ACL_TYPE_DEFAULT
, acls
);
1886 ksmbd_debug(SMB
, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1890 free_acl_state(&acl_state
);
1891 posix_acl_release(acls
);
1895 int ksmbd_vfs_inherit_posix_acl(struct mnt_idmap
*idmap
,
1896 struct path
*path
, struct inode
*parent_inode
)
1898 struct posix_acl
*acls
;
1899 struct posix_acl_entry
*pace
;
1900 struct dentry
*dentry
= path
->dentry
;
1901 struct inode
*inode
= d_inode(dentry
);
1904 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL
))
1907 acls
= get_inode_acl(parent_inode
, ACL_TYPE_DEFAULT
);
1908 if (IS_ERR_OR_NULL(acls
))
1910 pace
= acls
->a_entries
;
1912 for (i
= 0; i
< acls
->a_count
; i
++, pace
++) {
1913 if (pace
->e_tag
== ACL_MASK
) {
1914 pace
->e_perm
= 0x07;
1919 rc
= set_posix_acl(idmap
, dentry
, ACL_TYPE_ACCESS
, acls
);
1921 ksmbd_debug(SMB
, "Set posix acl(ACL_TYPE_ACCESS) failed, rc : %d\n",
1923 if (S_ISDIR(inode
->i_mode
)) {
1924 rc
= set_posix_acl(idmap
, dentry
, ACL_TYPE_DEFAULT
,
1927 ksmbd_debug(SMB
, "Set posix acl(ACL_TYPE_DEFAULT) failed, rc : %d\n",
1931 posix_acl_release(acls
);