netfs, cifs: Delegate high-level I/O to netfslib
Subsystems (8)
David Howells
maintainerv6 cover netfs, cifs: Delegate high-level I/O to netfslib
Hi Steve,
Here are patches to convert cifs to use the netfslib library. I've tested them with and without a cache. Unfortunately, if "-o fsc" is specified a leak of a tcon object shows up, particularly with the generic/013 xfstest that prevents further testing. I've investigated this and found that the tcon leak is actually present upstream, but just goes unnoticed unless it also pins an fscache volume cookie.
The patches remove around 2000 lines from CIFS.
Notes:
(1) CIFS is made to use unbuffered I/O for unbuffered caching modes and write-through caching for cache=strict.
(2) Various cifs fallocate() function implementations have issues that aren't easily fixed without enhanced protocol support.
(3) It should be possible to turn on multipage folio support in CIFS now.
(4) The then-unused CIFS code is removed in three patches, not one, to avoid the git patch generator from producing confusing patches in which it thinks code is being moved around rather than just being removed.
The patches can be found here also:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=cifs-netfs
Changes
=======
ver #6)
- The netfslib write helpers got rewritten and, consequently, some changes were made here.
- Rearranged the patch order a little to put the smaller changes first.
- Use a different way to invalidate that doesn't use ->launder_folio().
- Attempt to open the handle on the server READ+WRITE, even if the user asks for O_WRONLY, if the mount was with "-o fsc" so that we can fill in the gaps in partial folio writes; if we can't fall back to WRITE-only and disable caching.
- Fixed the cookie key to match the key used by iget5_locked() to avoid "Duplicate cookie" errors.
- Made add_credits_and_wake_if() clear the number of returned credits, allowing it to be called multiple times in cleanup/error handling.
- Made ->async_writev() not return an error directly, but always set it on the subreq.
- Fixed error handling from writethrough writing.
ver #5)
- Rebased to -rc3 plus SteveF's for-next branch as netfslib is now upstream, as are a couple of patches from this series.
- Replace the ->replay bool Shyam added with a flag on the netfs subrequest. This is tested by the code, but not currently set (see above).
ver #4)
- Slimmed down the branch:
- Split the cifs-related patches off to a separate branch (cifs-netfs)
- Deferred the content-encryption to the in-progress ceph changes.
- Deferred the use-PG_writeback rather than PG_fscache patch
- Rebased on a later linux-next with afs-rotation patches.
ver #3)
- Moved the fscache module into netfslib to avoid export cycles.
- Fixed a bunch of bugs.
- Got CIFS to pass as much of xfstests as possible.
- Added a patch to make 9P use all the helpers.
- Added a patch to stop using PG_fscache, but rather dirty pages on reading and have writepages write to the cache.
ver #2)
- Folded the addition of NETFS_RREQ_NONBLOCK/BLOCKED into first patch that uses them.
- Folded addition of rsize member into first user.
- Don't set rsize in ceph (yet) and set it in kafs to 256KiB. cifs sets it dynamically.
- Moved direct_bv next to direct_bv_count in struct netfs_io_request and labelled it with a __counted_by().
- Passed flags into netfs_xa_store_and_mark() rather than two bools.
- Removed netfs_set_up_buffer() as it wasn't used.
David
David Howells (15):
cifs: Replace cifs_readdata with a wrapper around netfs_io_subrequest
cifs: Replace cifs_writedata with a wrapper around netfs_io_subrequest
cifs: Use more fields from netfs_io_subrequest
cifs: Make wait_mtu_credits take size_t args
cifs: Replace the writedata replay bool with a netfs sreq flag
cifs: Move cifs_loose_read_iter() and cifs_file_write_iter() to file.c
cifs: Set zero_point in the copy_file_range() and remap_file_range()
cifs: Add mempools for cifs_io_request and cifs_io_subrequest structs
cifs: Make add_credits_and_wake_if() clear deducted credits
cifs: Implement netfslib hooks
cifs: When caching, try to open O_WRONLY file rdwr on server
cifs: Cut over to using netfslib
cifs: Remove some code that's no longer used, part 1
cifs: Remove some code that's no longer used, part 2
cifs: Remove some code that's no longer used, part 3
fs/netfs/buffered_write.c | 6 + fs/netfs/io.c | 7 +- fs/smb/client/Kconfig | 1 + fs/smb/client/cifsfs.c | 124 +- fs/smb/client/cifsfs.h | 10 +- fs/smb/client/cifsglob.h | 65 +- fs/smb/client/cifsproto.h | 12 +- fs/smb/client/cifssmb.c | 120 +- fs/smb/client/dir.c | 15 + fs/smb/client/file.c | 2841 ++++++---------------------------- fs/smb/client/fscache.c | 109 -- fs/smb/client/fscache.h | 54 +- fs/smb/client/inode.c | 19 +- fs/smb/client/smb2ops.c | 10 +- fs/smb/client/smb2pdu.c | 186 ++- fs/smb/client/smb2proto.h | 5 +- fs/smb/client/trace.h | 144 +- fs/smb/client/transport.c | 17 +- include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 20 files changed, 946 insertions(+), 2801 deletions(-)
David Howells
maintainerPATCH v6 1/15 cifs: Replace cifs_readdata with a wrapper around netfs_io_subrequest
Netfslib has a facility whereby the allocation for netfs_io_subrequest can be increased to so that filesystem-specific data can be tagged on the end.
Prepare to use this by making a struct, cifs_io_subrequest, that wraps netfs_io_subrequest, and absorb struct cifs_readdata into it.
--- fs/smb/client/cifsglob.h | 22 +++++++++++--------- fs/smb/client/cifsproto.h | 13 ++++++++++-- fs/smb/client/cifssmb.c | 11 ++++------ fs/smb/client/file.c | 44 ++++++++++++++++++--------------------- fs/smb/client/smb2ops.c | 2 +- fs/smb/client/smb2pdu.c | 12 ++++++----- fs/smb/client/smb2proto.h | 2 +- fs/smb/client/transport.c | 4 ++-- 8 files changed, 58 insertions(+), 52 deletions(-)
fs/smb/client/cifsglob.h +12 -10
@@ -268,7 +268,7 @@ struct dfs_info3_param;struct cifs_fattr ;struct smb3_fs_context ;struct cifs_fid ; -struct cifs_readdata ; +struct cifs_io_subrequest ;struct cifs_writedata ;struct cifs_io_parms ;struct cifs_search_info ;
@@ -450,7 +450,7 @@ struct smb_version_operations {/* send a flush request to the server */ int (*flush)(const unsigned int ,struct cifs_tcon *,struct cifs_fid *);/* async read from the server */ -int (*async_readv)(struct cifs_readdata *); +int (*async_readv)(struct cifs_io_subrequest *);/* async write to the server */ int (*async_writev)(struct cifs_writedata *,void (*release)(struct kref *));
@@ -1488,26 +1488,28 @@ struct cifs_aio_ctx { };/* asynchronous read support */ -struct cifs_readdata { -struct kref refcount; -struct list_head list; -struct completion done; +struct cifs_io_subrequest { +struct netfs_io_subrequest subreq;struct cifsFileInfo *cfile;struct address_space *mapping;struct cifs_aio_ctx *ctx; -__u64 offset;ssize_t got_bytes; -unsigned int bytes;pid_t pid;int result; -struct work_struct work; -struct iov_iter iter;struct kvec iov[2 ];struct TCP_Server_Info *server;#ifdef CONFIG_CIFS_SMB_DIRECT struct smbd_mr *mr;#endif struct cifs_credits credits; + +// TODO: Remove following elements +struct list_head list; +struct completion done; +struct work_struct work; +struct iov_iter iter; +__u64 offset; +unsigned int bytes; };/* asynchronous write support */
fs/smb/client/cifsproto.h +11 -2
@@ -598,8 +598,17 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); -void cifs_readdata_release (struct kref *refcount); -int cifs_async_readv (struct cifs_readdata *rdata); +void cifs_readdata_release (struct cifs_io_subrequest *rdata); +static inline void cifs_get_readdata (struct cifs_io_subrequest *rdata) +{ +refcount_inc (&rdata->subreq.ref); +} +static inline void cifs_put_readdata (struct cifs_io_subrequest *rdata) +{ +if (refcount_dec_and_test (&rdata->subreq.ref)) +cifs_readdata_release (rdata); +} +int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid); int cifs_async_writev(struct cifs_writedata *wdata,
fs/smb/client/cifssmb.c +4 -7
@@ -24,6 +24,8 @@#include <linux/swap.h> #include <linux/task_io_accounting_ops.h> #include <linux/uaccess.h> +#include <linux/netfs.h> +#include <trace/events/netfs.h> #include "cifspdu.h" #include "cifsfs.h" #include "cifsglob.h"
@@ -1262,12 +1264,11 @@ CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,static void cifs_readv_callback (struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (rdata->cfile->tlink);struct TCP_Server_Info *server = tcon->ses->server;struct smb_rqst rqst = { .rq_iov = rdata->iov, .rq_nvec =2 , - .rq_iter_size =iov_iter_count (&rdata->iter), .rq_iter = rdata->iter };struct cifs_credits credits = { .value =1 , .instance =0 };
@@ -1312,7 +1313,7 @@ cifs_readv_callback(struct mid_q_entry *mid)/* cifs_async_readv - send an async write, and set up mid to handle result */ int -cifs_async_readv (struct cifs_readdata *rdata) +cifs_async_readv (struct cifs_io_subrequest *rdata) {int rc;READ_REQ *smb =NULL ;
@@ -1364,15 +1365,11 @@ cifs_async_readv(struct cifs_readdata *rdata) rdata->iov[1 ].iov_base = (char *)smb +4 ; rdata->iov[1 ].iov_len =get_rfc1002_length (smb); -kref_get (&rdata->refcount); rc =cifs_call_async (tcon->ses->server, &rqst, cifs_readv_receive, cifs_readv_callback,NULL , rdata,0 ,NULL );if (rc ==0 )cifs_stats_inc (&tcon->stats.cifs_stats.num_reads); -else -kref_put (&rdata->refcount, cifs_readdata_release); -cifs_small_buf_release (smb);return rc; }
fs/smb/client/file.c +20 -24
136 lines not on this page · raw message
fs/smb/client/smb2ops.c +1 -1
@@ -4482,7 +4482,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,unsigned int cur_off;unsigned int cur_page_idx;unsigned int pad_len; -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct smb2_hdr *shdr = (struct smb2_hdr *)buf;int length;bool use_rdma_mr = false;
fs/smb/client/smb2pdu.c +7 -5
@@ -23,6 +23,8 @@#include <linux/uuid.h> #include <linux/pagemap.h> #include <linux/xattr.h> +#include <linux/netfs.h> +#include <trace/events/netfs.h> #include "cifsglob.h" #include "cifsacl.h" #include "cifsproto.h"
@@ -4378,7 +4380,7 @@ static inline bool smb3_use_rdma_offload(struct cifs_io_parms *io_parms)*/ static int smb2_new_read_req (void **buf,unsigned int *total_len, -struct cifs_io_parms *io_parms,struct cifs_readdata *rdata, +struct cifs_io_parms *io_parms,struct cifs_io_subrequest *rdata,unsigned int remaining_bytes,int request_type) {int rc = -EACCES ;
@@ -4470,7 +4472,7 @@ smb2_new_read_req(void **buf, unsigned int *total_len,static void smb2_readv_callback (struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (rdata->cfile->tlink);struct TCP_Server_Info *server = rdata->server; struct smb2_hdr *shdr =
@@ -4557,7 +4559,7 @@ smb2_readv_callback(struct mid_q_entry *mid)/* smb2_async_readv - send an async read, and set up mid to handle result */ int -smb2_async_readv (struct cifs_readdata *rdata) +smb2_async_readv (struct cifs_io_subrequest *rdata) {int rc, flags =0 ;char *buf;
@@ -4615,13 +4617,13 @@ smb2_async_readv(struct cifs_readdata *rdata) flags |=CIFS_HAS_CREDITS ; } -kref_get (&rdata->refcount); +cifs_get_readdata (rdata); rc =cifs_call_async (server, &rqst, cifs_readv_receive, smb2_readv_callback, smb3_handle_read_data, rdata, flags, &rdata->credits);if (rc) { -kref_put (&rdata->refcount, cifs_readdata_release); +cifs_put_readdata (rdata);cifs_stats_fail_inc (io_parms.tcon,SMB2_READ_HE ); trace_smb3_read_err(0 /* xid */, io_parms.persistent_fid, io_parms.tcon->tid,
fs/smb/client/smb2proto.h +1 -1
@@ -210,7 +210,7 @@ extern int SMB2_query_acl(const unsigned int xid, struct cifs_tcon *tcon,extern int SMB2_get_srv_num (const unsigned int xid,struct cifs_tcon *tcon,u64 persistent_fid,u64 volatile_fid,__le64 *uniqueid); -extern int smb2_async_readv (struct cifs_readdata *rdata); +extern int smb2_async_readv (struct cifs_io_subrequest *rdata);extern int SMB2_read (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,char **buf,int *buf_type); extern int smb2_async_writev(struct cifs_writedata *wdata,
fs/smb/client/transport.c +2 -2
@@ -1687,7 +1687,7 @@ __cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid,static int cifs_readv_discard (struct TCP_Server_Info *server,struct mid_q_entry *mid) { -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;return __cifs_readv_discard (server, mid, rdata->result); }
@@ -1697,7 +1697,7 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) {int length, len;unsigned int data_offset, data_len; -struct cifs_readdata *rdata = mid->callback_data; +struct cifs_io_subrequest *rdata = mid->callback_data;char *buf = server->smallbuf;unsigned int buflen = server->pdu_size +HEADER_PREAMBLE_SIZE (server);bool use_rdma_mr = false;
David Howells
maintainerPATCH v6 2/15 cifs: Replace cifs_writedata with a wrapper around netfs_io_subrequest
In reply to David HowellsReplace the cifs_writedata struct with the same wrapper around netfs_io_subrequest that was used to replace cifs_readdata.
--- fs/smb/client/cifsglob.h | 32 +++------------- fs/smb/client/cifsproto.h | 16 ++++++-- fs/smb/client/cifssmb.c | 9 ++--- fs/smb/client/file.c | 79 ++++++++++++++++----------------------- fs/smb/client/smb2pdu.c | 9 ++--- fs/smb/client/smb2proto.h | 3 +- 6 files changed, 59 insertions(+), 89 deletions(-)
fs/smb/client/cifsglob.h +6 -26
@@ -269,7 +269,6 @@ struct cifs_fattr;struct smb3_fs_context ;struct cifs_fid ;struct cifs_io_subrequest ; -struct cifs_writedata ;struct cifs_io_parms ;struct cifs_search_info ;struct cifsInodeInfo ;
@@ -452,8 +451,7 @@ struct smb_version_operations {/* async read from the server */ int (*async_readv)(struct cifs_io_subrequest *);/* async write to the server */ -int (*async_writev)(struct cifs_writedata *, -void (*release)(struct kref *)); +int (*async_writev)(struct cifs_io_subrequest *);/* sync read from the server */ int (*sync_read)(const unsigned int, struct cifs_fid *, struct cifs_io_parms *, unsigned int *, char **,
@@ -1503,36 +1501,18 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -// TODO: Remove following elements -struct list_head list; -struct completion done; -struct work_struct work; -struct iov_iter iter; -__u64 offset; -unsigned int bytes; -}; +enum writeback_sync_modes sync_mode; +bool uncached; +bool replay; +struct bio_vec *bv; -/* asynchronous write support */ -struct cifs_writedata { -struct kref refcount; +// TODO: Remove following elements struct list_head list;struct completion done; -enum writeback_sync_modes sync_mode;struct work_struct work; -struct cifsFileInfo *cfile; -struct cifs_aio_ctx *ctx;struct iov_iter iter; -struct bio_vec *bv;__u64 offset; -pid_t pid;unsigned int bytes; -int result; -struct TCP_Server_Info *server; -#ifdef CONFIG_CIFS_SMB_DIRECT -struct smbd_mr *mr; -#endif -struct cifs_credits credits; -bool replay; };/*
fs/smb/client/cifsproto.h +12 -4
@@ -611,11 +611,19 @@ static inline void cifs_put_readdata(struct cifs_io_subrequest *rdata)int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid); -int cifs_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)); +int cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); -struct cifs_writedata *cifs_writedata_alloc (work_func_t complete); -void cifs_writedata_release (struct kref *refcount); +struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete); +void cifs_writedata_release (struct cifs_io_subrequest *rdata); +static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata) +{ +refcount_inc (&wdata->subreq.ref); +} +static inline void cifs_put_writedata (struct cifs_io_subrequest *wdata) +{ +if (refcount_dec_and_test (&wdata->subreq.ref)) +cifs_writedata_release (wdata); +} int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/cifssmb.c +4 -5
@@ -1612,7 +1612,7 @@ CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,static void cifs_writev_callback (struct mid_q_entry *mid) { -struct cifs_writedata *wdata = mid->callback_data; +struct cifs_io_subrequest *wdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (wdata->cfile->tlink);unsigned int written;WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
@@ -1657,8 +1657,7 @@ cifs_writev_callback(struct mid_q_entry *mid)/* cifs_async_writev - send an async write, and set up mid to handle result */ int -cifs_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)) +cifs_async_writev (struct cifs_io_subrequest *wdata) {int rc = -EACCES ;WRITE_REQ *smb =NULL ;
@@ -1725,14 +1724,14 @@ cifs_async_writev(struct cifs_writedata *wdata, iov[1 ].iov_len +=4 ;/* pad bigger by four bytes */ } -kref_get (&wdata->refcount); +cifs_get_writedata (wdata); rc =cifs_call_async (tcon->ses->server, &rqst,NULL , cifs_writev_callback,NULL , wdata,0 ,NULL );if (rc ==0 )cifs_stats_inc (&tcon->stats.cifs_stats.num_writes);else -kref_put (&wdata->refcount, release); +cifs_put_writedata (wdata); async_writev_out:cifs_small_buf_release (smb);
fs/smb/client/file.c +32 -47
226 lines not on this page · raw message
fs/smb/client/smb2pdu.c +4 -5
@@ -4724,7 +4724,7 @@ SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,static void smb2_writev_callback (struct mid_q_entry *mid) { -struct cifs_writedata *wdata = mid->callback_data; +struct cifs_io_subrequest *wdata = mid->callback_data;struct cifs_tcon *tcon =tlink_tcon (wdata->cfile->tlink);struct TCP_Server_Info *server = wdata->server;unsigned int written;
@@ -4805,8 +4805,7 @@ smb2_writev_callback(struct mid_q_entry *mid)/* smb2_async_writev - send an async write, and set up mid to handle result */ int -smb2_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)) +smb2_async_writev (struct cifs_io_subrequest *wdata) {int rc = -EACCES , flags =0 ;struct smb2_write_req *req =NULL ;
@@ -4940,7 +4939,7 @@ smb2_async_writev(struct cifs_writedata *wdata, flags |=CIFS_HAS_CREDITS ; } -kref_get (&wdata->refcount); +cifs_get_writedata (wdata); rc =cifs_call_async (server, &rqst,NULL , smb2_writev_callback,NULL , wdata, flags, &wdata->credits);
@@ -4952,7 +4951,7 @@ smb2_async_writev(struct cifs_writedata *wdata, io_parms->offset, io_parms->length, rc); -kref_put (&wdata->refcount, release); +cifs_put_writedata (wdata);cifs_stats_fail_inc (tcon,SMB2_WRITE_HE ); }
fs/smb/client/smb2proto.h +1 -2
@@ -213,8 +213,7 @@ extern int SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon,extern int smb2_async_readv (struct cifs_io_subrequest *rdata);extern int SMB2_read (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,char **buf,int *buf_type); -extern int smb2_async_writev (struct cifs_writedata *wdata, -void (*release)(struct kref *kref)); +extern int smb2_async_writev (struct cifs_io_subrequest *wdata);extern int SMB2_write (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,struct kvec *iov,int n_vec);extern int SMB2_echo (struct TCP_Server_Info *server);
David Howells
maintainerPATCH v6 3/15 cifs: Use more fields from netfs_io_subrequest
In reply to David HowellsUse more fields from netfs_io_subrequest instead of those incorporated into cifs_io_subrequest from cifs_readdata and cifs_writedata.
--- fs/smb/client/cifsglob.h | 3 - fs/smb/client/cifssmb.c | 52 +++++++++--------- fs/smb/client/file.c | 112 +++++++++++++++++++------------------- fs/smb/client/smb2ops.c | 4 +- fs/smb/client/smb2pdu.c | 52 +++++++++--------- fs/smb/client/transport.c | 6 +- 6 files changed, 113 insertions(+), 116 deletions(-)
fs/smb/client/cifsglob.h +0 -3
@@ -1510,9 +1510,6 @@ struct cifs_io_subrequest {struct list_head list;struct completion done;struct work_struct work; -struct iov_iter iter; -__u64 offset; -unsigned int bytes; };/*
fs/smb/client/cifssmb.c +26 -26
117 lines not on this page · raw message
fs/smb/client/file.c +56 -56
280 lines not on this page · raw message
fs/smb/client/smb2ops.c +2 -2
@@ -4584,7 +4584,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,/* Copy the data to the output I/O iterator. */ rdata->result =cifs_copy_pages_to_iter (pages, pages_len, - cur_off, &rdata->iter); + cur_off, &rdata->subreq.io_iter);if (rdata->result !=0 ) {if (is_offloaded) mid->mid_state =MID_RESPONSE_MALFORMED ;
@@ -4598,7 +4598,7 @@ handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,/* read response payload is in buf */ WARN_ONCE (pages && !xa_empty (pages),"read data can be either in buf or in pages" ); - length =copy_to_iter (buf + data_offset, data_len, &rdata->iter); + length =copy_to_iter (buf + data_offset, data_len, &rdata->subreq.io_iter);if (length <0 )return length; rdata->got_bytes = data_len;
fs/smb/client/smb2pdu.c +26 -26
153 lines not on this page · raw message
fs/smb/client/transport.c +3 -3
@@ -1702,8 +1702,8 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)unsigned int buflen = server->pdu_size +HEADER_PREAMBLE_SIZE (server);bool use_rdma_mr = false; -cifs_dbg (FYI ,"%s: mid=%llu offset=%llu bytes=%u\n" , - __func__, mid->mid, rdata->offset, rdata->bytes); +cifs_dbg (FYI ,"%s: mid=%llu offset=%llu bytes=%zu\n" , + __func__, mid->mid, rdata->subreq.start, rdata->subreq.len);/* * read the rest of READ_RSP header (sans Data array), or whatever we
@@ -1808,7 +1808,7 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) length = data_len;/* An RDMA read is already done. */ else#endif - length =cifs_read_iter_from_socket (server, &rdata->iter, + length =cifs_read_iter_from_socket (server, &rdata->subreq.io_iter, data_len);if (length >0 ) rdata->got_bytes += length;
David Howells
maintainerPATCH v6 4/15 cifs: Make wait_mtu_credits take size_t args
In reply to David HowellsMake the wait_mtu_credits functions use size_t for the size and num arguments rather than unsigned int as netfslib uses size_t/ssize_t for arguments and return values to allow for extra capacity.
--- fs/smb/client/cifsglob.h | 4 ++-- fs/smb/client/cifsproto.h | 2 +- fs/smb/client/file.c | 17 ++++++++++------- fs/smb/client/smb2ops.c | 4 ++-- fs/smb/client/transport.c | 4 ++-- 5 files changed, 17 insertions(+), 14 deletions(-)
fs/smb/client/cifsglob.h +2 -2
@@ -546,8 +546,8 @@ struct smb_version_operations {/* writepages retry size */ unsigned int (*wp_retry_size)(struct inode *);/* get mtu credits */ -int (*wait_mtu_credits)(struct TCP_Server_Info *,unsigned int , -unsigned int *,struct cifs_credits *); +int (*wait_mtu_credits)(struct TCP_Server_Info *,size_t , +size_t *,struct cifs_credits *);/* adjust previously taken mtu credits to request size */ int (*adjust_credits)(struct TCP_Server_Info *server, struct cifs_credits *credits,
fs/smb/client/cifsproto.h +1 -1
@@ -121,7 +121,7 @@ extern struct mid_q_entry *cifs_setup_async_request(struct TCP_Server_Info *,extern int cifs_check_receive (struct mid_q_entry *mid,struct TCP_Server_Info *server,bool log_error);extern int cifs_wait_mtu_credits (struct TCP_Server_Info *server, -unsigned int size,unsigned int *num, +size_t size,size_t *num,struct cifs_credits *credits); extern int SendReceive2(const unsigned int /* xid */ , struct cifs_ses *, struct kvec *, int /* nvec to send */,
fs/smb/client/file.c +10 -7
@@ -2704,7 +2704,8 @@ static ssize_t cifs_write_back_from_locked_folio(struct address_space *mapping,struct cifs_credits *credits = &credits_on_stack;struct cifsFileInfo *cfile =NULL ;unsigned long long i_size =i_size_read (inode), max_len; -unsigned int xid, wsize; +unsigned int xid; +size_t wsize;size_t len =folio_size (folio);long count = wbc->nr_to_write;int rc;
@@ -3206,7 +3207,7 @@ static int cifs_resend_wdata(struct cifs_io_subrequest *wdata, struct list_head *wdata_list, struct cifs_aio_ctx *ctx) { - unsigned int wsize; + size_t wsize;struct cifs_credits credits;int rc;struct TCP_Server_Info *server = wdata->server;
@@ -3341,7 +3342,8 @@ cifs_write_from_iter(loff_t fpos, size_t len, struct iov_iter *from, do { struct cifs_credits credits_on_stack; struct cifs_credits *credits = &credits_on_stack; - unsigned int wsize, nsegs = 0; + unsigned int nsegs = 0; + size_t wsize; if (signal_pending(current)) { rc = -EINTR;
@@ -3778,7 +3780,7 @@ static int cifs_resend_rdata(struct cifs_io_subrequest *rdata,struct list_head *rdata_list, struct cifs_aio_ctx *ctx) { - unsigned int rsize; + size_t rsize;struct cifs_credits credits;int rc;struct TCP_Server_Info *server;
@@ -3852,10 +3854,10 @@ cifs_send_async_read(loff_t fpos, size_t len, struct cifsFileInfo *open_file, struct cifs_aio_ctx *ctx) {struct cifs_io_subrequest *rdata; -unsigned int rsize, nsegs, max_segs =INT_MAX ; +unsigned int nsegs, max_segs =INT_MAX ;struct cifs_credits credits_on_stack;struct cifs_credits *credits = &credits_on_stack; -size_t cur_len, max_len; +size_t cur_len, max_len, rsize;int rc;pid_t pid;struct TCP_Server_Info *server;
@@ -4451,12 +4453,13 @@ static void cifs_readahead(struct readahead_control *ractl)* Chop the readahead request up into rsize-sized read requests. */ while ((nr_pages = ra_pages)) { -unsigned int i, rsize; +unsigned int i;struct cifs_io_subrequest *rdata;struct cifs_credits credits_on_stack;struct cifs_credits *credits = &credits_on_stack;struct folio *folio;pgoff_t fsize; +size_t rsize;/* * Find out if we have anything cached in the range of
fs/smb/client/smb2ops.c +2 -2
@@ -217,8 +217,8 @@ smb2_get_credits(struct mid_q_entry *mid) }static int -smb2_wait_mtu_credits (struct TCP_Server_Info *server,unsigned int size, -unsigned int *num,struct cifs_credits *credits) +smb2_wait_mtu_credits (struct TCP_Server_Info *server,size_t size, +size_t *num,struct cifs_credits *credits) {int rc =0 ;unsigned int scredits, in_flight;
fs/smb/client/transport.c +2 -2
@@ -691,8 +691,8 @@ wait_for_compound_request(struct TCP_Server_Info *server, int num, }int -cifs_wait_mtu_credits (struct TCP_Server_Info *server,unsigned int size, -unsigned int *num,struct cifs_credits *credits) +cifs_wait_mtu_credits (struct TCP_Server_Info *server,size_t size, +size_t *num,struct cifs_credits *credits) { *num = size; credits->value =0 ;
David Howells
maintainerPATCH v6 5/15 cifs: Replace the writedata replay bool with a netfs sreq flag
In reply to David HowellsReplace the 'replay' bool in cifs_writedata (now cifs_io_subrequest) with a flag in the netfs_io_subrequest flags.
--- fs/smb/client/file.c | 2 +- fs/smb/client/smb2pdu.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/smb/client/file.c +1 -1
@@ -3246,7 +3246,7 @@ cifs_resend_wdata(struct cifs_io_subrequest *wdata, struct list_head *wdata_listif (wdata->cfile->invalidHandle) rc = -EAGAIN ;else { - wdata->replay = true; +set_bit (NETFS_SREQ_RETRYING , &wdata->subreq.flags);#ifdef CONFIG_CIFS_SMB_DIRECT if (wdata->mr) { wdata->mr->need_invalidate = true;
fs/smb/client/smb2pdu.c +2 -2
@@ -4819,7 +4819,7 @@ smb2_async_writev(struct cifs_io_subrequest *wdata)struct cifs_io_parms *io_parms =NULL ;int credit_request; -if (!wdata->server || wdata->replay) +if (!wdata->server ||test_bit (NETFS_SREQ_RETRYING , &wdata->subreq.flags)) server = wdata->server =cifs_pick_channel (tcon->ses);/*
@@ -4904,7 +4904,7 @@ smb2_async_writev(struct cifs_io_subrequest *wdata) rqst.rq_nvec =1 ; rqst.rq_iter = wdata->subreq.io_iter; rqst.rq_iter_size =iov_iter_count (&rqst.rq_iter); -if (wdata->replay) +if (test_bit (NETFS_SREQ_RETRYING , &wdata->subreq.flags))smb2_set_replay (server, &rqst);#ifdef CONFIG_CIFS_SMB_DIRECT if (wdata->mr)
David Howells
maintainerPATCH v6 6/15 cifs: Move cifs_loose_read_iter() and cifs_file_write_iter() to file.c
In reply to David HowellsMove cifs_loose_read_iter() and cifs_file_write_iter() to file.c so that they are colocated with similar functions rather than being split with cifsfs.c.
--- fs/smb/client/cifsfs.c | 55 ------------------------------------------ fs/smb/client/cifsfs.h | 2 ++ fs/smb/client/file.c | 53 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 55 deletions(-)
fs/smb/client/cifsfs.c +0 -55
@@ -982,61 +982,6 @@ cifs_smb3_do_mount(struct file_system_type *fs_type,return root; } - -static ssize_t -cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter) -{ -ssize_t rc; -struct inode *inode =file_inode (iocb->ki_filp); - -if (iocb->ki_flags &IOCB_DIRECT ) -return cifs_user_readv (iocb, iter); - - rc =cifs_revalidate_mapping (inode); -if (rc) -return rc; - -return generic_file_read_iter (iocb, iter); -} - -static ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) -{ -struct inode *inode =file_inode (iocb->ki_filp); -struct cifsInodeInfo *cinode =CIFS_I (inode); -ssize_t written; -int rc; - -if (iocb->ki_filp->f_flags &O_DIRECT ) { - written =cifs_user_writev (iocb, from); -if (written >0 &&CIFS_CACHE_READ (cinode)) { -cifs_zap_mapping (inode); -cifs_dbg (FYI , -"Set no oplock for inode=%p after a write operation\n" , - inode); - cinode->oplock =0 ; - } -return written; - } - - written =cifs_get_writer (cinode); -if (written) -return written; - - written =generic_file_write_iter (iocb, from); - -if (CIFS_CACHE_WRITE (CIFS_I (inode))) - goto out; - - rc =filemap_fdatawrite (inode->i_mapping); -if (rc) -cifs_dbg (FYI ,"cifs_file_write_iter: %d rc on %p inode\n" , - rc, inode); - -out: -cifs_put_writer (cinode); -return written; -} -static loff_t cifs_llseek (struct file *file,loff_t offset,int whence) {struct cifsFileInfo *cfile = file->private_data;
fs/smb/client/cifsfs.h +2 -0
@@ -99,6 +99,8 @@ extern ssize_t cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to);extern ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_strict_writev (struct kiocb *iocb,struct iov_iter *from); +ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from); +ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter);extern int cifs_flock (struct file *pfile,int cmd,struct file_lock *plock);extern int cifs_lock (struct file *,int ,struct file_lock *);extern int cifs_fsync (struct file *,loff_t ,loff_t ,int );
fs/smb/client/file.c +53 -0
59 lines not on this page · raw message
David Howells
maintainerPATCH v6 7/15 cifs: Set zero_point in the copy_file_range() and remap_file_range()
In reply to David HowellsSet zero_point in the copy_file_range() and remap_file_range() implementations so that we don't skip reading data modified on a server-side copy.
--- fs/smb/client/cifsfs.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/smb/client/cifsfs.c +6 -0
@@ -1283,6 +1283,8 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off, rc =cifs_flush_folio (target_inode, destend, &fstart, &fend, false);if (rc) goto unlock; +if (fend > target_cifsi->netfs.zero_point) + target_cifsi->netfs.zero_point = fend +1 ;/* Discard all the folios that overlap the destination region. */ cifs_dbg (FYI ,"about to discard pages %llx-%llx\n" , fstart, fend);
@@ -1301,6 +1303,8 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,fscache_resize_cookie (cifs_inode_cookie (target_inode), new_size); } +if (rc ==0 && new_size > target_cifsi->netfs.zero_point) + target_cifsi->netfs.zero_point = new_size; }/* force revalidate of size and timestamps of target file now
@@ -1392,6 +1396,8 @@ ssize_t cifs_file_copychunk_range(unsigned int xid, rc =cifs_flush_folio (target_inode, destend, &fstart, &fend, false);if (rc) goto unlock; +if (fend > target_cifsi->netfs.zero_point) + target_cifsi->netfs.zero_point = fend +1 ;/* Discard all the folios that overlap the destination region. */ truncate_inode_pages_range (&target_inode->i_data, fstart, fend);
David Howells
maintainerPATCH v6 8/15 cifs: Add mempools for cifs_io_request and cifs_io_subrequest structs
In reply to David HowellsAdd mempools for the allocation of cifs_io_request and cifs_io_subrequest structs for netfslib to use so that it can guarantee eventual allocation in writeback.
--- fs/smb/client/cifsfs.c | 55 +++++++++++++++++++++++++++++++++++++++- fs/smb/client/cifsglob.h | 2 ++ 2 files changed, 56 insertions(+), 1 deletion(-)
fs/smb/client/cifsfs.c +54 -1
@@ -370,9 +370,13 @@ static struct kmem_cache *cifs_inode_cachep;static struct kmem_cache *cifs_req_cachep;static struct kmem_cache *cifs_mid_cachep;static struct kmem_cache *cifs_sm_req_cachep; +static struct kmem_cache *cifs_io_request_cachep; +static struct kmem_cache *cifs_io_subrequest_cachep;mempool_t *cifs_sm_req_poolp;mempool_t *cifs_req_poolp;mempool_t *cifs_mid_poolp; +mempool_t cifs_io_request_pool; +mempool_t cifs_io_subrequest_pool;static struct inode *cifs_alloc_inode (struct super_block *sb)
@@ -1746,6 +1750,48 @@ static void destroy_mids(void)kmem_cache_destroy (cifs_mid_cachep); } +static int cifs_init_netfs (void ) +{ + cifs_io_request_cachep = +kmem_cache_create ("cifs_io_request" , +sizeof (struct netfs_io_request ),0 , +SLAB_HWCACHE_ALIGN ,NULL ); +if (!cifs_io_request_cachep) + goto nomem_req; + +if (mempool_init_slab_pool (&cifs_io_request_pool,100 , cifs_io_request_cachep) <0 ) + goto nomem_reqpool; + + cifs_io_subrequest_cachep = +kmem_cache_create ("cifs_io_subrequest" , +sizeof (struct cifs_io_subrequest ),0 , +SLAB_HWCACHE_ALIGN ,NULL ); +if (!cifs_io_subrequest_cachep) + goto nomem_subreq; + +if (mempool_init_slab_pool (&cifs_io_subrequest_pool,100 , cifs_io_subrequest_cachep) <0 ) + goto nomem_subreqpool; + +return 0 ; + +nomem_subreqpool: +kmem_cache_destroy (cifs_io_subrequest_cachep); +nomem_subreq: +mempool_destroy (&cifs_io_request_pool); +nomem_reqpool: +kmem_cache_destroy (cifs_io_request_cachep); +nomem_req: +return -ENOMEM ; +} + +static void cifs_destroy_netfs (void ) +{ +mempool_destroy (&cifs_io_subrequest_pool); +kmem_cache_destroy (cifs_io_subrequest_cachep); +mempool_destroy (&cifs_io_request_pool); +kmem_cache_destroy (cifs_io_request_cachep); +} +static int __init init_cifs (void ) {
@@ -1843,10 +1889,14 @@ init_cifs(void)if (rc) goto out_destroy_deferredclose_wq; - rc =init_mids (); + rc =cifs_init_netfs ();if (rc) goto out_destroy_inodecache; + rc =init_mids (); +if (rc) + goto out_destroy_netfs; + rc =cifs_init_request_bufs ();if (rc) goto out_destroy_mids;
@@ -1901,6 +1951,8 @@ init_cifs(void)cifs_destroy_request_bufs (); out_destroy_mids:destroy_mids (); +out_destroy_netfs: +cifs_destroy_netfs (); out_destroy_inodecache:cifs_destroy_inodecache (); out_destroy_deferredclose_wq:
@@ -1937,6 +1989,7 @@ exit_cifs(void)#endif cifs_destroy_request_bufs ();destroy_mids (); +cifs_destroy_netfs ();cifs_destroy_inodecache ();destroy_workqueue (deferredclose_wq);destroy_workqueue (cifsoplockd_wq);
fs/smb/client/cifsglob.h +2 -0
@@ -2089,6 +2089,8 @@ extern __u32 cifs_lock_secret;extern mempool_t *cifs_sm_req_poolp;extern mempool_t *cifs_req_poolp;extern mempool_t *cifs_mid_poolp; +extern mempool_t cifs_io_request_pool; +extern mempool_t cifs_io_subrequest_pool;/* Operations for different SMB versions */ #define SMB1_VERSION_STRING "1.0"
David Howells
maintainerPATCH v6 9/15 cifs: Make add_credits_and_wake_if() clear deducted credits
In reply to David HowellsMake add_credits_and_wake_if() clear the amount of credits in the cifs_credits struct after it has returned them to the overall counter. This allows add_credits_and_wake_if() to be called multiple times during the error handling and cleanup without accidentally returning the credits again and again.
Note that the wake_up() in add_credits_and_wake_if() may also be superfluous as ->add_credits() also does a wake on the request_q.
--- fs/smb/client/cifsglob.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/smb/client/cifsglob.h +2 -1
@@ -881,11 +881,12 @@ add_credits(struct TCP_Server_Info *server, const struct cifs_credits *credits,static inline void add_credits_and_wake_if (struct TCP_Server_Info *server, -const struct cifs_credits *credits,const int optype) +struct cifs_credits *credits,const int optype) {if (credits->value) { server->ops->add_credits (server, credits, optype);wake_up (&server->request_q); + credits->value =0 ; } }
David Howells
maintainerPATCH v6 10/15 cifs: Implement netfslib hooks
In reply to David HowellsProvide implementation of the netfslib hooks that will be used by netfslib to ask cifs to set up and perform operations. Of particular note are
(*) cifs_clamp_length() - This is used to negotiate the size of the next
subrequest in a read request, taking into account the credit available and the rsize. The credits are attached to the subrequest.
(*) cifs_req_issue_read() - This is used to issue a subrequest that has
been set up and clamped.
(*) cifs_prepare_write() - This prepares to fill a subrequest by picking a
channel, reopening the file and requesting credits so that we can set the maximum size of the subrequest and also sets the maximum number of segments if we're doing RDMA.
(*) cifs_issue_write() - This releases any unneeded credits and issues an
asynchronous data write for the contiguous slice of file covered by the subrequest. This should possibly be folded in to all ->async_writev() ops and that called directly.
(*) cifs_begin_writeback() - This gets the cached writable handle through
which we do writeback (this does not affect writethrough, unbuffered or direct writes).
At this point, cifs is not wired up to actually *use* netfslib; that will be done in a subsequent patch.
--- fs/netfs/buffered_write.c | 6 + fs/smb/client/Kconfig | 1 + fs/smb/client/cifsfs.c | 2 +- fs/smb/client/cifsfs.h | 1 + fs/smb/client/cifsglob.h | 28 +++- fs/smb/client/file.c | 315 +++++++++++++++++++++++++++++++++++ include/linux/netfs.h | 1 + include/trace/events/netfs.h | 1 + 8 files changed, 345 insertions(+), 10 deletions(-)
fs/netfs/buffered_write.c +6 -0
@@ -407,6 +407,9 @@ ssize_t netfs_perform_write(struct kiocb *iocb, struct iov_iter *iter, }while (iov_iter_count (iter)); out: +if (likely (written) && ctx->ops->post_modify) + ctx->ops->post_modify (inode); +if (unlikely (wreq)) { ret2 =netfs_end_writethrough (wreq, &wbc, writethrough);wbc_detach_inode (&wbc);
@@ -523,6 +526,7 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grstruct folio *folio =page_folio (vmf->page);struct file *file = vmf->vma->vm_file;struct inode *inode =file_inode (file); +struct netfs_inode *ictx =netfs_inode (inode);vm_fault_t ret =VM_FAULT_RETRY ;int err;
@@ -569,6 +573,8 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_grtrace_netfs_folio (folio, netfs_folio_trace_mkwrite);netfs_set_group (folio, netfs_group);file_update_time (file); +if (ictx->ops->post_modify) + ictx->ops->post_modify (inode); ret =VM_FAULT_LOCKED ; out:sb_end_pagefault (inode->i_sb);
fs/smb/client/Kconfig +1 -0
@@ -2,6 +2,7 @@ config CIFS tristate "SMB3 and CIFS support (advanced network filesystem)" depends on INET + select NETFS_SUPPORT select NLS select NLS_UCS2_UTILS select CRYPTO
fs/smb/client/cifsfs.c +1 -1
@@ -1754,7 +1754,7 @@ static int cifs_init_netfs(void) { cifs_io_request_cachep =kmem_cache_create ("cifs_io_request" , -sizeof (struct netfs_io_request ),0 , +sizeof (struct cifs_io_request ),0 ,SLAB_HWCACHE_ALIGN ,NULL );if (!cifs_io_request_cachep) goto nomem_req;
fs/smb/client/cifsfs.h +1 -0
@@ -84,6 +84,7 @@ extern const struct inode_operations cifs_namespace_inode_operations;/* Functions related to files and directories */ +extern const struct netfs_request_ops cifs_req_ops;extern const struct file_operations cifs_file_ops;extern const struct file_operations cifs_file_direct_ops;/* if directio mnt */ extern const struct file_operations cifs_file_strict_ops;/* if strictio mnt */
fs/smb/client/cifsglob.h +19 -9
@@ -1486,15 +1486,24 @@ struct cifs_aio_ctx {bool direct_io; }; +struct cifs_io_request { +struct netfs_io_request rreq; +struct cifsFileInfo *cfile; +}; +/* asynchronous read support */ struct cifs_io_subrequest { -struct netfs_io_subrequest subreq; -struct cifsFileInfo *cfile; -struct address_space *mapping; -struct cifs_aio_ctx *ctx; +union { +struct netfs_io_subrequest subreq; +struct netfs_io_request *rreq; +struct cifs_io_request *req; + };ssize_t got_bytes;pid_t pid; +unsigned int xid;int result; +bool have_xid; +bool replay;struct kvec iov[2 ];struct TCP_Server_Info *server;#ifdef CONFIG_CIFS_SMB_DIRECT
@@ -1502,15 +1511,16 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -enum writeback_sync_modes sync_mode; -bool uncached; -bool replay; -struct bio_vec *bv; -// TODO: Remove following elements struct list_head list;struct completion done;struct work_struct work; +struct cifsFileInfo *cfile; +struct address_space *mapping; +struct cifs_aio_ctx *ctx; +enum writeback_sync_modes sync_mode; +bool uncached; +struct bio_vec *bv; };/*
fs/smb/client/file.c +315 -0
321 lines not on this page · raw message
include/linux/netfs.h +1 -0
@@ -302,6 +302,7 @@ struct netfs_request_ops {/* Modification handling */ void (*update_i_size)(struct inode *inode,loff_t i_size); +void (*post_modify)(struct inode *inode);/* Write request handling */ void (*begin_writeback)(struct netfs_io_request *wreq);
include/trace/events/netfs.h +1 -0
@@ -112,6 +112,7 @@#define netfs_sreq_ref_traces \ EM(netfs_sreq_trace_get_copy_to_cache, "GET COPY2C ") \ EM(netfs_sreq_trace_get_resubmit, "GET RESUBMIT") \ + EM(netfs_sreq_trace_get_submit, "GET SUBMIT") \ EM(netfs_sreq_trace_get_short_read, "GET SHORTRD") \ EM(netfs_sreq_trace_new, "NEW ") \ EM(netfs_sreq_trace_put_cancel, "PUT CANCEL ") \
David Howells
maintainerPATCH v6 11/15 cifs: When caching, try to open O_WRONLY file rdwr on server
In reply to David HowellsWhen we're engaged in local caching of a cifs filesystem, we cannot perform caching of a partially written cache granule unless we can read the rest of the granule. To deal with this, if a file is opened O_WRONLY locally, but the mount was given the "-o fsc" flag, try first opening the remote file with GENERIC_READ|GENERIC_WRITE and if that returns -EACCES, try dropping the GENERIC_READ and doing the open again. If that last succeeds, invalidate the cache for that file as for O_DIRECT.
--- fs/smb/client/dir.c | 15 ++++++++++++ fs/smb/client/file.c | 51 +++++++++++++++++++++++++++++++++-------- fs/smb/client/fscache.h | 6 +++++ 3 files changed, 62 insertions(+), 10 deletions(-)
fs/smb/client/dir.c +15 -0
@@ -189,6 +189,7 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsignedint disposition;struct TCP_Server_Info *server = tcon->ses->server;struct cifs_open_parms oparms; +int rdwr_for_fscache =0 ; *oplock =0 ;if (tcon->ses->server->oplocks)
@@ -200,6 +201,10 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsignedreturn PTR_ERR (full_path); } +/* If we're caching, we need to be able to fill in around partial writes. */ +if (cifs_fscache_enabled (inode) && (oflags &O_ACCMODE ) ==O_WRONLY ) + rdwr_for_fscache =1 ; +#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
@@ -276,6 +281,8 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned desired_access |=GENERIC_READ ;/* is this too little? */ if (OPEN_FMODE (oflags) &FMODE_WRITE ) desired_access |=GENERIC_WRITE ; +if (rdwr_for_fscache ==1 ) + desired_access |=GENERIC_READ ; disposition =FILE_OVERWRITE_IF ;if ((oflags & (O_CREAT |O_EXCL )) == (O_CREAT |O_EXCL ))
@@ -304,6 +311,7 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsignedif (!tcon->unix_ext && (mode &S_IWUGO ) ==0 ) create_options |=CREATE_OPTION_READONLY ; +retry_open: oparms = (struct cifs_open_parms ) { .tcon = tcon, .cifs_sb = cifs_sb,
@@ -317,8 +325,15 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned rc = server->ops->open (xid, &oparms, oplock, buf);if (rc) {cifs_dbg (FYI ,"cifs_create returned 0x%x\n" , rc); +if (rc == -EACCES && rdwr_for_fscache ==1 ) { + desired_access &= ~GENERIC_READ ; + rdwr_for_fscache =2 ; + goto retry_open; + } goto out; } +if (rdwr_for_fscache ==2 ) +cifs_invalidate_cache (inode,FSCACHE_INVAL_DIO_WRITE );#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY /*
fs/smb/client/file.c +41 -10
120 lines not on this page · raw message
fs/smb/client/fscache.h +6 -0
@@ -109,6 +109,11 @@ static inline void cifs_readahead_to_fscache(struct inode *inode,__cifs_readahead_to_fscache (inode, pos, len); } +static inline bool cifs_fscache_enabled (struct inode *inode) +{ +return fscache_cookie_enabled (cifs_inode_cookie (inode)); +} +#else /* CONFIG_CIFS_FSCACHE */ static inline void cifs_fscache_fill_coherency(struct inode *inode,
@@ -124,6 +129,7 @@ static inline void cifs_fscache_release_inode_cookie(struct inode *inode) {}static inline void cifs_fscache_unuse_inode_cookie (struct inode *inode,bool update) {}static inline struct fscache_cookie *cifs_inode_cookie (struct inode *inode) {return NULL ; }static inline void cifs_invalidate_cache (struct inode *inode,unsigned int flags) {} +static inline bool cifs_fscache_enabled (struct inode *inode) {return false; } static inline int cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages,
RE: [PATCH v6 11/15] cifs: When caching, try to open O_WRONLY file rdwr on server
Quoted 173 lines
-----Original Message-----
From: David Howells <[email protected]>
Sent: Thursday, March 28, 2024 10:28 PM
To: Steve French <[email protected]>
Cc: David Howells <[email protected]>; Jeff Layton <[email protected]>; Matthew Wilcox <[email protected]>; Paulo Alcantara <[email protected]>; Shyam Prasad N <[email protected]>; Tom Talpey <[email protected]>; Christian Brauner <[email protected]>; [email protected]; linux- [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; Steve French <[email protected]>; Shyam Prasad N <[email protected]>; Rohith Surabattula <[email protected]>
Subject: [PATCH v6 11/15] cifs: When caching, try to openO_WRONLYfile rdwr on serverWhen we're engaged in local caching of a cifs filesystem, we cannot perform caching of a partially written cache granule unless we can read the rest of the granule. To deal with this, if a file is opened
O_WRONLYlocally, but the mount was given the "-o fsc" flag, try first opening the remote file with GENERIC_READ|GENERIC_WRITE and if that returns-EACCES, try dropping theGENERIC_READand doing the open again. If that last succeeds, invalidate the cache for that file as forO_DIRECT.Signed-off-by David Howells <[email protected]>cc Steve French <[email protected]>cc Shyam Prasad N <[email protected]>cc Rohith Surabattula <[email protected]>cc Jeff Layton <[email protected]>--- fs/smb/client/dir.c | 15 ++++++++++++ fs/smb/client/file.c | 51 +++++++++++++++++++++++++++++++++-------- fs/smb/client/fscache.h | 6 +++++ 3 files changed, 62 insertions(+), 10 deletions(-)fs/smb/client/dir.c index renamed from fs/smb/client/dir.c +0
-0
89333d9bce36..37897b919dd5100644fs/smb/client/dir.c +1
-0@@ -189,6 +189,7 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsignedint disposition;struct TCP_Server_Info *server = tcon->ses->server;struct cifs_open_parms oparms; +int rdwr_for_fscache =0 ; *oplock =0 ;fs/smb/client/dir.c +0
-0if (tcon->ses->server->oplocks)@@ -200,6 +201,10 @@ static int cifs_do_create(struct inode *inode, structdentry *direntry, unsigned
fs/smb/client/dir.c +2
-0return PTR_ERR (full_path); } +/* If we're caching, we need to be able to fill in around partial writes. */ + if (cifs_fscache_enabled(inode) && (oflags & O_ACCMODE) ==
O_WRONLY)fs/smb/client/dir.c +2
-0+ rdwr_for_fscache =1 ; +#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open&&
fs/smb/client/dir.c +2
-0(CIFS_UNIX_POSIX_PATH_OPS_CAP &@@ -276,6 +281,8 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned desired_access |=GENERIC_READ ;/* is this too little? */ if (OPEN_FMODE (oflags) &FMODE_WRITE ) desired_access |=GENERIC_WRITE ; +if (rdwr_for_fscache ==1 ) + desired_access |=GENERIC_READ ; disposition =FILE_OVERWRITE_IF ;if ((oflags & (
O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL)) @@ -
304,6 +311,7 @@ static int cifs_do_create(struct inode *inode, struct dentry *direntry, unsignedfs/smb/client/dir.c +1
-0if (!tcon->unix_ext && (mode &S_IWUGO ) ==0 ) create_options |=CREATE_OPTION_READONLY ; +retry_open: oparms = (struct cifs_open_parms ) { .tcon = tcon, .cifs_sb = cifs_sb,@@ -317,8 +325,15 @@ static int cifs_do_create(struct inode *inode, structdentry *direntry, unsigned
fs/smb/client/dir.c +7
-0rc = server->ops->open (xid, &oparms, oplock, buf);if (rc) {cifs_dbg (FYI ,"cifs_create returned 0x%x\n" , rc); +if (rc == -EACCES && rdwr_for_fscache ==1 ) { + desired_access &= ~GENERIC_READ ; + rdwr_for_fscache =2 ; + goto retry_open; + } goto out; } +if (rdwr_for_fscache ==2 ) +cifs_invalidate_cache (inode,FSCACHE_INVAL_DIO_WRITE );#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY /* fs/smb/client/file.c index renamed from fs/smb/client/file.c +0
-0
73573dadf90e..761a80963f76100644fs/smb/client/file.c +3
-2@@ -521,12 +521,12 @@ cifs_mark_open_files_invalid(struct cifs_tcon *tcon)*/ } -static inline int cifs_convert_flags (unsigned int flags) +static inline int cifs_convert_flags (unsigned int flags,int +rdwr_for_fscache) {if ((flags &O_ACCMODE ) ==O_RDONLY )return GENERIC_READ ;else if ((flags &O_ACCMODE ) ==O_WRONLY ) -return GENERIC_WRITE ; + return rdwr_for_fscache == 1 ? (GENERIC_READ |
GENERIC_WRITE) :fs/smb/client/file.c +1
-0+GENERIC_WRITE ; else if ((flags & O_ACCMODE) == O_RDWR) {/* GENERIC_ALL is too much permission to request can cause unnecessary access denied on create */ @@ -663,11 +663,16 @@ static int cifs_nt_open(const char
*full_path, struct inode *inode, structcifs_fs/smb/client/file.c +3
-1int create_options =CREATE_NOT_DIR ;struct TCP_Server_Info *server = tcon->ses->server;struct cifs_open_parms oparms; +int rdwr_for_fscache =0 ;if (!server->ops->open)return -ENOSYS ; - desired_access =cifs_convert_flags (f_flags); +/* If we're caching, we need to be able to fill in around partial writes. */ + if (cifs_fscache_enabled(inode) && (f_flags & O_ACCMODE) ==
O_WRONLY)fs/smb/client/file.c +4
-0+ rdwr_for_fscache =1 ; + + desired_access =cifs_convert_flags (f_flags, rdwr_for_fscache);/********************************************************************* * open flag mapping table: @@ -704,6 +709,7 @@ static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_if (f_flags &O_DIRECT ) create_options |=CREATE_NO_BUFFER ; +retry_open: oparms = (struct cifs_open_parms ) { .tcon = tcon,fs/smb/client/file.c +9
-1.cifs_sb = cifs_sb,@@ -715,8 +721,16 @@ static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_ }; rc = server->ops->open (xid, &oparms, oplock, buf); -if (rc) +if (rc) { +if (rc == -EACCES && rdwr_for_fscache ==1 ) { + desired_access =cifs_convert_flags (f_flags,0 ); + rdwr_for_fscache =2 ; + goto retry_open; + }return rc; + } +if (rdwr_for_fscache ==2 ) +cifs_invalidate_cache (inode,FSCACHE_INVAL_DIO_WRITE );/* TODO: Add support for calling posix query info but with passing in fid */ fs/smb/client/file.c +0
-0if (tcon->unix_ext)
fs/smb/client/file.c int cifs_open(struct inode *inode, struct file *file) · line 1167
Quoted 10 lines
fs/smb/client/file.c +2
-5@@ -1149,11 +1163,14 @@ int cifs_open(struct inode *inode, struct file *file) use_cache:fscache_use_cookie (cifs_inode_cookie (file_inode (file)), file->f_mode &FMODE_WRITE ); -if (file->f_flags &O_DIRECT && - (!((file->f_flags &O_ACCMODE ) !=O_RDONLY ) || - file->f_flags &O_APPEND )) -cifs_invalidate_cache (file_inode (file), -FSCACHE_INVAL_DIO_WRITE ); +//if ((file->f_flags & O_ACCMODE) == O_WRONLY) +// goto inval;
Why to keep unused code?
Thanks,
Naveen
Quoted 93 lines
fs/smb/client/file.c +7
-0+if (!(file->f_flags &O_DIRECT )) + goto out; +if ((file->f_flags & (O_ACCMODE |O_APPEND )) ==O_RDONLY ) + goto out; +//inval: +cifs_invalidate_cache (file_inode (file),FSCACHE_INVAL_DIO_WRITE ); out:free_dentry_path (page);@@ -1218,6 +1235,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)int disposition =FILE_OPEN ;int create_options =CREATE_NOT_DIR ;struct cifs_open_parms oparms; +int rdwr_for_fscache =0 ; xid =get_xid ();fs/smb/client/file.c +5
-1mutex_lock (&cfile->fh_mutex);@@ -1281,7 +1299,11 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush) }#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ - desired_access =cifs_convert_flags (cfile->f_flags); +/* If we're caching, we need to be able to fill in around partial writes. */ +if (cifs_fscache_enabled (inode) && (cfile->f_flags &O_ACCMODE ) ==O_WRONLY ) + rdwr_for_fscache =1 ; + + desired_access =cifs_convert_flags (cfile->f_flags, rdwr_for_fscache);/*
O_SYNCalso has bit forO_DSYNCso following check picks up either
*/fs/smb/client/file.c +1
-0if (cfile->f_flags &O_SYNC )@@ -1293,6 +1315,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)if (server->ops->get_lease_key) server->ops->get_lease_key (inode, &cfile->fid); +retry_open: oparms = (struct cifs_open_parms ) { .tcon = tcon,fs/smb/client/file.c +5
-0.cifs_sb = cifs_sb,@@ -1318,6 +1341,11 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)/* indicate that we need to relock the file */ oparms.reconnect = true; } +if (rc == -EACCES && rdwr_for_fscache ==1 ) { + desired_access =cifs_convert_flags (cfile->f_flags,0 ); + rdwr_for_fscache =2 ; + goto retry_open; + }if (rc) {fs/smb/client/file.c +3
-0mutex_unlock (&cfile->fh_mutex);@@ -1326,6 +1354,9 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush) goto reopen_error_exit; } +if (rdwr_for_fscache ==2 ) +cifs_invalidate_cache (inode,FSCACHE_INVAL_DIO_WRITE ); +#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY reopen_success:#endif /*
CONFIG_CIFS_ALLOW_INSECURE_LEGACY*/ diff --gita/fs/smb/client/fscache.hb/fs/smb/client/fscache.hindexa3d73720914f..1f2ea9f5cc9a100644fs/smb/client/fscache.h +4
-0@@ -109,6 +109,11 @@ static inline void cifs_readahead_to_fscache(structinode *inode, __cifs_readahead_to_fscache(inode, pos, len); } +static inline bool cifs_fscache_enabled (struct inode *inode) { +return fscache_cookie_enabled (cifs_inode_cookie (inode)); +} +#else /* CONFIG_CIFS_FSCACHE */ static inline void cifs_fscache_fill_coherency(struct inode *inode, @@ -124,6 +129,7 @@static inline void
cifs_fscache_release_inode_cookie(struct inode *inode){} static inline voidcifs_fscache_unuse_inode_cookie(struct inode *inode, bool update){} static inline structfscache_cookie*cifs_inode_cookie(struct inode *inode) { return NULL; } static inline voidcifs_invalidate_cache(struct inode *inode, unsigned int flags){}fs/smb/client/fscache.h +2
-0+static inline bool cifs_fscache_enabled (struct inode *inode) {return +false; } static inline int cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages,
David Howells
maintainerPATCH v6 12/15 cifs: Cut over to using netfslib
In reply to David HowellsMake the cifs filesystem use netfslib to handle reading and writing on behalf of cifs. The changes include:
(1) Various read_iter/write_iter type functions are turned into wrappers around netfslib API functions or are pointed directly at those functions:
cifs_file_direct{,_nobrl}_ops switch to use netfs_unbuffered_read_iter and netfs_unbuffered_write_iter.
Large pieces of code that will be removed are #if'd out and will be removed in subsequent patches.
[?] Why does cifs mark the page dirty in the destination buffer of a DIO
read? Should that happen automatically? Does netfs need to do that?
--- fs/netfs/io.c | 7 +- fs/smb/client/cifsfs.c | 8 +- fs/smb/client/cifsfs.h | 7 -- fs/smb/client/cifsglob.h | 5 +- fs/smb/client/cifsproto.h | 8 +- fs/smb/client/cifssmb.c | 54 +++++++------ fs/smb/client/file.c | 161 ++++++++++++++++++++------------------ fs/smb/client/fscache.c | 2 + fs/smb/client/fscache.h | 4 + fs/smb/client/inode.c | 19 ++++- fs/smb/client/smb2pdu.c | 117 ++++++++++++++++----------- fs/smb/client/smb2proto.h | 2 +- fs/smb/client/trace.h | 144 +++++++++++++++++++++++++++++----- fs/smb/client/transport.c | 3 + 14 files changed, 361 insertions(+), 180 deletions(-)
fs/netfs/io.c +6 -1
@@ -213,8 +213,13 @@ static void netfs_rreq_assess_dio(struct netfs_io_request *rreq)unsigned int i;size_t transferred =0 ; -for (i =0 ; i < rreq->direct_bv_count; i++) +for (i =0 ; i < rreq->direct_bv_count; i++) {flush_dcache_page (rreq->direct_bv[i].bv_page); +// TODO: cifs marks pages in the destination buffer +// dirty under some circumstances after a read. Do we +// need to do that too? +set_page_dirty (rreq->direct_bv[i].bv_page); + }list_for_each_entry (subreq, &rreq->subrequests, rreq_link) {if (subreq->error || subreq->transferred ==0 )
fs/smb/client/cifsfs.c +4 -4
@@ -1518,8 +1518,8 @@ const struct file_operations cifs_file_strict_ops = { };const struct file_operations cifs_file_direct_ops = { - .read_iter = cifs_direct_readv, - .write_iter = cifs_direct_writev, + .read_iter = netfs_unbuffered_read_iter, + .write_iter = netfs_file_write_iter, .open = cifs_open, .release = cifs_close, .lock = cifs_lock,
@@ -1574,8 +1574,8 @@ const struct file_operations cifs_file_strict_nobrl_ops = { };const struct file_operations cifs_file_direct_nobrl_ops = { - .read_iter = cifs_direct_readv, - .write_iter = cifs_direct_writev, + .read_iter = netfs_unbuffered_read_iter, + .write_iter = netfs_file_write_iter, .open = cifs_open, .release = cifs_close, .fsync = cifs_fsync,
fs/smb/client/cifsfs.h +0 -7
@@ -94,11 +94,7 @@ extern const struct file_operations cifs_file_strict_nobrl_ops;extern int cifs_open (struct inode *inode,struct file *file);extern int cifs_close (struct inode *inode,struct file *file);extern int cifs_closedir (struct inode *inode,struct file *file); -extern ssize_t cifs_user_readv (struct kiocb *iocb,struct iov_iter *to); -extern ssize_t cifs_direct_readv (struct kiocb *iocb,struct iov_iter *to);extern ssize_t cifs_strict_readv (struct kiocb *iocb,struct iov_iter *to); -extern ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from); -extern ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from);extern ssize_t cifs_strict_writev (struct kiocb *iocb,struct iov_iter *from);ssize_t cifs_file_write_iter (struct kiocb *iocb,struct iov_iter *from);ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter);
@@ -112,9 +108,6 @@ extern int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma);extern const struct file_operations cifs_dir_ops;extern int cifs_dir_open (struct inode *inode,struct file *file);extern int cifs_readdir (struct file *file,struct dir_context *ctx); -extern void cifs_pages_written_back (struct inode *inode,loff_t start,unsigned int len); -extern void cifs_pages_write_failed (struct inode *inode,loff_t start,unsigned int len); -extern void cifs_pages_write_redirty (struct inode *inode,loff_t start,unsigned int len);/* Functions related to dir entries */ extern const struct dentry_operations cifs_dentry_ops;
fs/smb/client/cifsglob.h +3 -2
@@ -451,7 +451,7 @@ struct smb_version_operations {/* async read from the server */ int (*async_readv)(struct cifs_io_subrequest *);/* async write to the server */ -int (*async_writev)(struct cifs_io_subrequest *); +void (*async_writev)(struct cifs_io_subrequest *);/* sync read from the server */ int (*sync_read)(const unsigned int, struct cifs_fid *, struct cifs_io_parms *, unsigned int *, char **,
@@ -1511,7 +1511,7 @@ struct cifs_io_subrequest {#endif struct cifs_credits credits; -// TODO: Remove following elements +#if 0 // TODO: Remove following elements struct list_head list;struct completion done;struct work_struct work;
@@ -1521,6 +1521,7 @@ struct cifs_io_subrequest {enum writeback_sync_modes sync_mode;bool uncached;struct bio_vec *bv; +#endif };/*
fs/smb/client/cifsproto.h +7 -1
@@ -148,6 +148,8 @@ extern bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 eof, bool from_readdir);extern void cifs_update_eof (struct cifsInodeInfo *cifsi,loff_t offset,unsigned int bytes_written); +void cifs_write_subrequest_terminated (struct cifs_io_subrequest *wdata,ssize_t result, +bool was_async);extern struct cifsFileInfo *find_writable_file (struct cifsInodeInfo *,int ); extern int cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags,
@@ -598,6 +600,7 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); +#if 0 // TODO Remove void cifs_readdata_release (struct cifs_io_subrequest *rdata);static inline void cifs_get_readdata (struct cifs_io_subrequest *rdata) {
@@ -608,11 +611,13 @@ static inline void cifs_put_readdata(struct cifs_io_subrequest *rdata)if (refcount_dec_and_test (&rdata->subreq.ref)) cifs_readdata_release(rdata); } +#endif int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid); -int cifs_async_writev (struct cifs_io_subrequest *wdata); +void cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); +#if 0 // TODO Remove struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete);void cifs_writedata_release (struct cifs_io_subrequest *rdata);static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata)
@@ -624,6 +629,7 @@ static inline void cifs_put_writedata(struct cifs_io_subrequest *wdata)if (refcount_dec_and_test (&wdata->subreq.ref))cifs_writedata_release (wdata); } +#endif int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/cifssmb.c +32 -22
139 lines not on this page · raw message
fs/smb/client/file.c +86 -75
370 lines not on this page · raw message
fs/smb/client/fscache.c +2 -0
@@ -151,6 +151,7 @@ void cifs_fscache_release_inode_cookie(struct inode *inode) } } +#if 0 // TODO remove /* * Fallback page reading interface. */
@@ -259,3 +260,4 @@ int __cifs_fscache_query_occupancy(struct inode *inode,fscache_end_operation (&cres); return ret; } +#endif
fs/smb/client/fscache.h +4 -0
@@ -74,6 +74,7 @@ static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags i_size_read(inode), flags); } +#if 0 // TODO remove extern int __cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages, pgoff_t *_data_first,
@@ -108,6 +109,7 @@ static inline void cifs_readahead_to_fscache(struct inode *inode,if (cifs_inode_cookie (inode)) __cifs_readahead_to_fscache(inode, pos, len); } +#endif static inline bool cifs_fscache_enabled (struct inode *inode) {
@@ -131,6 +133,7 @@ static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode) { restatic inline void cifs_invalidate_cache (struct inode *inode,unsigned int flags) {}static inline bool cifs_fscache_enabled (struct inode *inode) {return false; } +#if 0 // TODO remove static inline int cifs_fscache_query_occupancy(struct inode *inode, pgoff_t first, unsigned int nr_pages, pgoff_t *_data_first,
@@ -149,6 +152,7 @@ cifs_readpage_from_fscache(struct inode *inode, struct page *page)static inline void cifs_readahead_to_fscache (struct inode *inode,loff_t pos,size_t len) {} +#endif #endif /* CONFIG_CIFS_FSCACHE */
fs/smb/client/inode.c +18 -1
@@ -28,14 +28,29 @@#include "cached_dir.h" #include "reparse.h" +/* +* Set parameters for the netfs library +*/ +static void cifs_set_netfs_context (struct inode *inode) +{ +struct cifsInodeInfo *cifs_i =CIFS_I (inode); +struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); + +netfs_inode_init (&cifs_i->netfs, &cifs_req_ops, true); +if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_STRICT_IO ) +__set_bit (NETFS_ICTX_WRITETHROUGH , &cifs_i->netfs.flags); +} +static void cifs_set_ops (struct inode *inode) {struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); +struct netfs_inode *ictx =netfs_inode (inode);switch (inode->i_mode &S_IFMT ) {case S_IFREG : inode->i_op = &cifs_file_inode_ops;if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_DIRECT_IO ) { +set_bit (NETFS_ICTX_UNBUFFERED , &ictx->flags);if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_NO_BRL ) inode->i_fop = &cifs_file_direct_nobrl_ops;else
@@ -221,8 +236,10 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,if (fattr->cf_flags &CIFS_FATTR_JUNCTION ) inode->i_flags |=S_AUTOMOUNT ; -if (inode->i_state &I_NEW ) +if (inode->i_state &I_NEW ) { +cifs_set_netfs_context (inode);cifs_set_ops (inode); + }return 0 ; }
fs/smb/client/smb2pdu.c +70 -47
287 lines not on this page · raw message
fs/smb/client/smb2proto.h +1 -1
@@ -213,7 +213,7 @@ extern int SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon,extern int smb2_async_readv (struct cifs_io_subrequest *rdata);extern int SMB2_read (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,char **buf,int *buf_type); -extern int smb2_async_writev (struct cifs_io_subrequest *wdata); +extern void smb2_async_writev (struct cifs_io_subrequest *wdata);extern int SMB2_write (const unsigned int xid,struct cifs_io_parms *io_parms,unsigned int *nbytes,struct kvec *iov,int n_vec);extern int SMB2_echo (struct TCP_Server_Info *server);
fs/smb/client/trace.h +125 -19
178 lines not on this page · raw message
fs/smb/client/transport.c +3 -0
@@ -1808,8 +1808,11 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid) length = data_len;/* An RDMA read is already done. */ else#endif + { length =cifs_read_iter_from_socket (server, &rdata->subreq.io_iter, data_len); +iov_iter_revert (&rdata->subreq.io_iter, data_len); + }if (length >0 ) rdata->got_bytes += length; server->total_read += length;
David Howells
maintainerPATCH v6 13/15 cifs: Remove some code that's no longer used, part 1
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/cifsglob.h | 12 - fs/smb/client/cifsproto.h | 25 -- fs/smb/client/file.c | 619 -------------------------------------- fs/smb/client/fscache.c | 111 ------- fs/smb/client/fscache.h | 58 ---- 5 files changed, 825 deletions(-)
fs/smb/client/cifsglob.h +0 -12
@@ -1510,18 +1510,6 @@ struct cifs_io_subrequest {struct smbd_mr *mr;#endif struct cifs_credits credits; - -#if 0 // TODO: Remove following elements -struct list_head list; -struct completion done; -struct work_struct work; -struct cifsFileInfo *cfile; -struct address_space *mapping; -struct cifs_aio_ctx *ctx; -enum writeback_sync_modes sync_mode; -bool uncached; -struct bio_vec *bv; -#endif };/*
fs/smb/client/cifsproto.h +0 -25
@@ -600,36 +600,11 @@ void __cifs_put_smb_ses(struct cifs_ses *ses);extern struct cifs_ses *cifs_get_smb_ses (struct TCP_Server_Info *server,struct smb3_fs_context *ctx); -#if 0 // TODO Remove -void cifs_readdata_release (struct cifs_io_subrequest *rdata); -static inline void cifs_get_readdata (struct cifs_io_subrequest *rdata) -{ -refcount_inc (&rdata->subreq.ref); -} -static inline void cifs_put_readdata (struct cifs_io_subrequest *rdata) -{ -if (refcount_dec_and_test (&rdata->subreq.ref)) -cifs_readdata_release (rdata); -} -#endif int cifs_async_readv (struct cifs_io_subrequest *rdata);int cifs_readv_receive (struct TCP_Server_Info *server,struct mid_q_entry *mid);void cifs_async_writev (struct cifs_io_subrequest *wdata);void cifs_writev_complete (struct work_struct *work); -#if 0 // TODO Remove -struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete); -void cifs_writedata_release (struct cifs_io_subrequest *rdata); -static inline void cifs_get_writedata (struct cifs_io_subrequest *wdata) -{ -refcount_inc (&wdata->subreq.ref); -} -static inline void cifs_put_writedata (struct cifs_io_subrequest *wdata) -{ -if (refcount_dec_and_test (&wdata->subreq.ref)) -cifs_writedata_release (wdata); -} -#endif int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon, struct cifs_sb_info *cifs_sb, const unsigned char *path, char *pbuf,
fs/smb/client/file.c +0 -619
649 lines not on this page · raw message
fs/smb/client/fscache.c +0 -111
114 lines not on this page · raw message
fs/smb/client/fscache.h +0 -58
70 lines not on this page · raw message
David Howells
maintainerPATCH v6 14/15 cifs: Remove some code that's no longer used, part 2
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/file.c | 634 +------------------------------------------ 1 file changed, 1 insertion(+), 633 deletions(-)
fs/smb/client/file.c +1 -633
@@ -2569,639 +2569,6 @@ cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,return -ENOENT ; } -#if 0 // TODO remove 2773 -void -cifs_writedata_release (struct cifs_io_subrequest *wdata) -{ -if (wdata->uncached) -kref_put (&wdata->ctx->refcount, cifs_aio_ctx_release); -#ifdef CONFIG_CIFS_SMB_DIRECT -if (wdata->mr) { -smbd_deregister_mr (wdata->mr); - wdata->mr =NULL ; - } -#endif - -if (wdata->cfile) -cifsFileInfo_put (wdata->cfile); - -kfree (wdata); -} - -/* -* Write failed with a retryable error. Resend the write request. It's also -* possible that the page was redirtied so re-clean the page. -*/ -static void -cifs_writev_requeue (struct cifs_io_subrequest *wdata) -{ -int rc =0 ; -struct inode *inode =d_inode (wdata->cfile->dentry); -struct TCP_Server_Info *server; -unsigned int rest_len = wdata->subreq.len; -loff_t fpos = wdata->subreq.start; - - server =tlink_tcon (wdata->cfile->tlink)->ses->server; -do { -struct cifs_io_subrequest *wdata2; -unsigned int wsize, cur_len; - - wsize = server->ops->wp_retry_size (inode); -if (wsize < rest_len) { -if (wsize <PAGE_SIZE ) { - rc = -EOPNOTSUPP ; -break ; - } - cur_len =min (round_down (wsize,PAGE_SIZE ), rest_len); - }else { - cur_len = rest_len; - } - - wdata2 =cifs_writedata_alloc (cifs_writev_complete); -if (!wdata2) { - rc = -ENOMEM ; -break ; - } - - wdata2->sync_mode = wdata->sync_mode; - wdata2->subreq.start = fpos; - wdata2->subreq.len = cur_len; - wdata2->subreq.io_iter = wdata->subreq.io_iter; - -iov_iter_advance (&wdata2->subreq.io_iter, fpos - wdata->subreq.start); -iov_iter_truncate (&wdata2->subreq.io_iter, wdata2->subreq.len); - -if (iov_iter_is_xarray (&wdata2->subreq.io_iter)) -/* Check for pages having been redirtied and clean -* them. We can do this by walking the xarray. If -* it's not an xarray, then it's a DIO and we shouldn't -* be mucking around with the page bits. -*/ -cifs_undirty_folios (inode, fpos, cur_len); - - rc =cifs_get_writable_file (CIFS_I (inode),FIND_WR_ANY , - &wdata2->cfile); -if (!wdata2->cfile) { -cifs_dbg (VFS ,"No writable handle to retry writepages rc=%d\n" , - rc); -if (!is_retryable_error (rc)) - rc = -EBADF ; - }else { - wdata2->pid = wdata2->cfile->pid; - rc = server->ops->async_writev (wdata2); - } - -cifs_put_writedata (wdata2); -if (rc) { -if (is_retryable_error (rc)) -continue ; - fpos += cur_len; - rest_len -= cur_len; -break ; - } - - fpos += cur_len; - rest_len -= cur_len; - }while (rest_len >0 ); - -/* Clean up remaining pages from the original wdata */ -if (iov_iter_is_xarray (&wdata->subreq.io_iter)) -cifs_pages_write_failed (inode, fpos, rest_len); - -if (rc !=0 && !is_retryable_error (rc)) -mapping_set_error (inode->i_mapping, rc); -cifs_put_writedata (wdata); -} - -void -cifs_writev_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *wdata =container_of (work, - struct cifs_io_subrequest, work); -struct inode *inode =d_inode (wdata->cfile->dentry); - -if (wdata->result ==0 ) { -spin_lock (&inode->i_lock); -cifs_update_eof (CIFS_I (inode), wdata->subreq.start, wdata->subreq.len); -spin_unlock (&inode->i_lock); -cifs_stats_bytes_written (tlink_tcon (wdata->cfile->tlink), - wdata->subreq.len); - }else if (wdata->sync_mode ==WB_SYNC_ALL && wdata->result == -EAGAIN ) -return cifs_writev_requeue (wdata); - -if (wdata->result == -EAGAIN ) -cifs_pages_write_redirty (inode, wdata->subreq.start, wdata->subreq.len); -else if (wdata->result <0 ) -cifs_pages_write_failed (inode, wdata->subreq.start, wdata->subreq.len); -else -cifs_pages_written_back (inode, wdata->subreq.start, wdata->subreq.len); - -if (wdata->result != -EAGAIN ) -mapping_set_error (inode->i_mapping, wdata->result); -cifs_put_writedata (wdata); -} - -struct cifs_io_subrequest *cifs_writedata_alloc (work_func_t complete) -{ -struct cifs_io_subrequest *wdata; - - wdata =kzalloc (sizeof (*wdata),GFP_NOFS ); -if (wdata !=NULL ) { -refcount_set (&wdata->subreq.ref,1 ); -INIT_LIST_HEAD (&wdata->list); -init_completion (&wdata->done); -INIT_WORK (&wdata->work, complete); - } -return wdata; -} - -/* -* Extend the region to be written back to include subsequent contiguously -* dirty pages if possible, but don't sleep while doing so. -*/ -static void cifs_extend_writeback (struct address_space *mapping, -struct xa_state *xas, -long *_count, -loff_t start, -int max_pages, -loff_t max_len, -size_t *_len) -{ -struct folio_batch batch; -struct folio *folio; -unsigned int nr_pages; -pgoff_t index = (start + *_len) /PAGE_SIZE ; -size_t len; -bool stop = true; -unsigned int i; - -folio_batch_init (&batch); - -do { -/* Firstly, we gather up a batch of contiguous dirty pages -* under the RCU read lock - but we can't clear the dirty flags -* there if any of those pages are mapped. -*/ -rcu_read_lock (); - -xas_for_each (xas, folio,ULONG_MAX ) { - stop = true; -if (xas_retry (xas, folio)) -continue ; -if (xa_is_value (folio)) -break ; -if (folio->index != index) { -xas_reset (xas); -break ; - } - -if (!folio_try_get_rcu (folio)) { -xas_reset (xas); -continue ; - } - nr_pages =folio_nr_pages (folio); -if (nr_pages > max_pages) { -xas_reset (xas); -break ; - } - -/* Has the page moved or been split? */ -if (unlikely (folio !=xas_reload (xas))) { -folio_put (folio); -xas_reset (xas); -break ; - } - -if (!folio_trylock (folio)) { -folio_put (folio); -xas_reset (xas); -break ; - } -if (!folio_test_dirty (folio) || -folio_test_writeback (folio)) { -folio_unlock (folio); -folio_put (folio); -xas_reset (xas); -break ; - } - - max_pages -= nr_pages; - len =folio_size (folio); - stop = false; - - index += nr_pages; - *_count -= nr_pages; - *_len += len; -if (max_pages <=0 || *_len >= max_len || *_count <=0 ) - stop = true; - -if (!folio_batch_add (&batch, folio)) -break ; -if (stop) -break ; - } - -xas_pause (xas); -rcu_read_unlock (); - -/* Now, if we obtained any pages, we can shift them to being -* writable and mark them for caching. -*/ -if (!folio_batch_count (&batch)) -break ; - -for (i =0 ; i <folio_batch_count (&batch); i++) { - folio = batch.folios[i]; -/* The folio should be locked, dirty and not undergoing -* writeback from the loop above. -*/ -if (!folio_clear_dirty_for_io (folio)) -WARN_ON (1 ); -folio_start_writeback (folio); -folio_unlock (folio); - } - -folio_batch_release (&batch); -cond_resched (); - }while (!stop); -} - -/* -* Write back the locked page and any subsequent non-locked dirty pages. -*/ -static ssize_t cifs_write_back_from_locked_folio (struct address_space *mapping, -struct writeback_control *wbc, -struct xa_state *xas, -struct folio *folio, -unsigned long long start, -unsigned long long end) -{ -struct inode *inode = mapping->host; -struct TCP_Server_Info *server; -struct cifs_io_subrequest *wdata; -struct cifs_sb_info *cifs_sb =CIFS_SB (inode->i_sb); -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -struct cifsFileInfo *cfile =NULL ; -unsigned long long i_size =i_size_read (inode), max_len; -unsigned int xid; -size_t wsize; -size_t len =folio_size (folio); -long count = wbc->nr_to_write; -int rc; - -/* The folio should be locked, dirty and not undergoing writeback. */ -if (!folio_clear_dirty_for_io (folio)) -WARN_ON_ONCE (1 ); -folio_start_writeback (folio); - - count -=folio_nr_pages (folio); - - xid =get_xid (); - server =cifs_pick_channel (cifs_sb_master_tcon (cifs_sb)->ses); - - rc =cifs_get_writable_file (CIFS_I (inode),FIND_WR_ANY , &cfile); -if (rc) { -cifs_dbg (VFS ,"No writable handle in writepages rc=%d\n" , rc); - goto err_xid; - } - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->wsize, - &wsize, credits); -if (rc !=0 ) - goto err_close; - - wdata =cifs_writedata_alloc (cifs_writev_complete); -if (!wdata) { - rc = -ENOMEM ; - goto err_uncredit; - } - - wdata->sync_mode = wbc->sync_mode; - wdata->subreq.start =folio_pos (folio); - wdata->pid = cfile->pid; - wdata->credits = credits_on_stack; - wdata->cfile = cfile; - wdata->server = server; - cfile =NULL ; - -/* Find all consecutive lockable dirty pages that have contiguous -* written regions, stopping when we find a page that is not -* immediately lockable, is not dirty or is missing, or we reach the -* end of the range. -*/ -if (start < i_size) { -/* Trim the write to the EOF; the extra data is ignored. Also -* put an upper limit on the size of a single storedata op. -*/ - max_len = wsize; - max_len = min_t(unsigned long long, max_len, end - start + 1); - max_len = min_t(unsigned long long, max_len, i_size - start); - -if (len < max_len) { -int max_pages =INT_MAX ; - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_pages = server->smbd_conn->max_frmr_depth; -#endif - max_pages -=folio_nr_pages (folio); - -if (max_pages >0 ) -cifs_extend_writeback (mapping, xas, &count, start, - max_pages, max_len, &len); - } - } - len = min_t(unsigned long long, len, i_size - start); - -/* We now have a contiguous set of dirty pages, each with writeback -* set; the first page is still locked at this point, but all the rest -* have been unlocked. -*/ -folio_unlock (folio); - wdata->subreq.len = len; - -if (start < i_size) { -iov_iter_xarray (&wdata->subreq.io_iter,ITER_SOURCE , &mapping->i_pages, - start, len); - - rc =adjust_credits (wdata->server, &wdata->credits, wdata->subreq.len); -if (rc) - goto err_wdata; - -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = wdata->server->ops->async_writev (wdata); -if (rc >=0 ) { -cifs_put_writedata (wdata); - goto err_close; - } - }else { -/* The dirty region was entirely beyond the EOF. */ -cifs_pages_written_back (inode, start, len); - rc =0 ; - } - -err_wdata: -cifs_put_writedata (wdata); -err_uncredit: -add_credits_and_wake_if (server, credits,0 ); -err_close: -if (cfile) -cifsFileInfo_put (cfile); -err_xid: -free_xid (xid); -if (rc ==0 ) { - wbc->nr_to_write = count; - rc = len; - }else if (is_retryable_error (rc)) { -cifs_pages_write_redirty (inode, start, len); - }else { -cifs_pages_write_failed (inode, start, len); -mapping_set_error (mapping, rc); - } -/* Indication to update ctime and mtime as close is deferred */ -set_bit (CIFS_INO_MODIFIED_ATTR , &CIFS_I (inode)->flags); -return rc; -} - -/* -* write a region of pages back to the server -*/ -static ssize_t cifs_writepages_begin (struct address_space *mapping, -struct writeback_control *wbc, -struct xa_state *xas, -unsigned long long *_start, -unsigned long long end) -{ -struct folio *folio; -unsigned long long start = *_start; -ssize_t ret; -int skips =0 ; - -search_again: -/* Find the first dirty page. */ -rcu_read_lock (); - -for (;;) { - folio =xas_find_marked (xas, end /PAGE_SIZE ,PAGECACHE_TAG_DIRTY ); -if (xas_retry (xas, folio) ||xa_is_value (folio)) -continue ; -if (!folio) -break ; - -if (!folio_try_get_rcu (folio)) { -xas_reset (xas); -continue ; - } - -if (unlikely (folio !=xas_reload (xas))) { -folio_put (folio); -xas_reset (xas); -continue ; - } - -xas_pause (xas); -break ; - } -rcu_read_unlock (); -if (!folio) -return 0 ; - - start =folio_pos (folio);/* May regress with THPs */ - -/* At this point we hold neither the i_pages lock nor the page lock: -* the page may be truncated or invalidated (changing page->mapping to -* NULL), or even swizzled back from swapper_space to tmpfs file -* mapping -*/ -lock_again: -if (wbc->sync_mode !=WB_SYNC_NONE ) { - ret =folio_lock_killable (folio); -if (ret <0 ) -return ret; - }else { -if (!folio_trylock (folio)) - goto search_again; - } - -if (folio->mapping != mapping || - !folio_test_dirty (folio)) { - start +=folio_size (folio); -folio_unlock (folio); - goto search_again; - } - -if (folio_test_writeback (folio) || -folio_test_private_2 (folio)) {/* [DEPRECATED] */ -folio_unlock (folio); -if (wbc->sync_mode !=WB_SYNC_NONE ) { -folio_wait_writeback (folio); -#ifdef CONFIG_CIFS_FSCACHE -folio_wait_private_2 (folio); -#endif - goto lock_again; - } - - start +=folio_size (folio); -if (wbc->sync_mode ==WB_SYNC_NONE ) { -if (skips >=5 ||need_resched ()) { - ret =0 ; - goto out; - } - skips++; - } - goto search_again; - } - - ret =cifs_write_back_from_locked_folio (mapping, wbc, xas, folio, start, end); -out: -if (ret >0 ) - *_start = start + ret; -return ret; -} - -/* -* Write a region of pages back to the server -*/ -static int cifs_writepages_region (struct address_space *mapping, -struct writeback_control *wbc, -unsigned long long *_start, -unsigned long long end) -{ -ssize_t ret; - -XA_STATE (xas, &mapping->i_pages, *_start /PAGE_SIZE ); - -do { - ret =cifs_writepages_begin (mapping, wbc, &xas, _start, end); -if (ret >0 && wbc->nr_to_write >0 ) -cond_resched (); - }while (ret >0 && wbc->nr_to_write >0 ); - -return ret >0 ?0 : ret; -} - -/* -* Write some of the pending data back to the server -*/ -static int cifs_writepages (struct address_space *mapping, -struct writeback_control *wbc) -{ -loff_t start, end; -int ret; - -/* We have to be careful as we can end up racing with setattr() -* truncating the pagecache since the caller doesn't take a lock here -* to prevent it. -*/ - -if (wbc->range_cyclic && mapping->writeback_index) { - start = mapping->writeback_index *PAGE_SIZE ; - ret =cifs_writepages_region (mapping, wbc, &start,LLONG_MAX ); -if (ret <0 ) - goto out; - -if (wbc->nr_to_write <=0 ) { - mapping->writeback_index = start /PAGE_SIZE ; - goto out; - } - - start =0 ; - end = mapping->writeback_index *PAGE_SIZE ; - mapping->writeback_index =0 ; - ret =cifs_writepages_region (mapping, wbc, &start, end); -if (ret ==0 ) - mapping->writeback_index = start /PAGE_SIZE ; - }else if (wbc->range_start ==0 && wbc->range_end ==LLONG_MAX ) { - start =0 ; - ret =cifs_writepages_region (mapping, wbc, &start,LLONG_MAX ); -if (wbc->nr_to_write >0 && ret ==0 ) - mapping->writeback_index = start /PAGE_SIZE ; - }else { - start = wbc->range_start; - ret =cifs_writepages_region (mapping, wbc, &start, wbc->range_end); - } - -out: -return ret; -} - -static int cifs_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -int rc; -struct inode *inode = mapping->host; -struct cifsFileInfo *cfile = file->private_data; -struct cifs_sb_info *cifs_sb =CIFS_SB (cfile->dentry->d_sb); -struct folio *folio =page_folio (page); -__u32 pid; - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = cfile->pid; -else - pid = current->tgid; - -cifs_dbg (FYI ,"write_end for page %p from pos %lld with %d bytes\n" , - page, pos, copied); - -if (folio_test_checked (folio)) { -if (copied == len) -folio_mark_uptodate (folio); -folio_clear_checked (folio); - }else if (!folio_test_uptodate (folio) && copied ==PAGE_SIZE ) -folio_mark_uptodate (folio); - -if (!folio_test_uptodate (folio)) { -char *page_data; -unsigned offset = pos & (PAGE_SIZE -1 ); -unsigned int xid; - - xid =get_xid (); -/* this is probably better than directly calling -partialpage_write since in this function the file handle is -known which we might as well leverage */ -/* BB check if anything else missing out of ppw -such as updating last write time */ - page_data =kmap (page); - rc =cifs_write (cfile, pid, page_data + offset, copied, &pos); -/* if (rc < 0) should we set writebehind rc? */ -kunmap (page); - -free_xid (xid); - }else { - rc = copied; - pos += copied; -set_page_dirty (page); - } - -if (rc >0 ) { -spin_lock (&inode->i_lock); -if (pos > inode->i_size) { -loff_t additional_blocks = (512 -1 + copied) >>9 ; - -i_size_write (inode, pos); -/* -* Estimate new allocation size based on the amount written. -* This will be updated from server on close (and on queryinfo) -*/ - inode->i_blocks =min_t (blkcnt_t, (512 -1 + pos) >>9 , - inode->i_blocks + additional_blocks); - } -spin_unlock (&inode->i_lock); - } - -unlock_page (page); -put_page (page); -/* Indication to update ctime and mtime as close is deferred */ -set_bit (CIFS_INO_MODIFIED_ATTR , &CIFS_I (inode)->flags); - -return rc; -} -#endif // End netfs removal 2773 -/* * Flush data on a strict file. */
@@ -4517,6 +3884,7 @@ cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset) }#endif // end netfslib remove 4633 +static vm_fault_t cifs_page_mkwrite (struct vm_fault *vmf) {return netfs_page_mkwrite (vmf,NULL );
David Howells
maintainerPATCH v6 15/15 cifs: Remove some code that's no longer used, part 3
In reply to David HowellsRemove some code that was #if'd out with the netfslib conversion. This is split into parts for file.c as the diff generator otherwise produces a hard to read diff for part of it where a big chunk is cut out.
--- fs/smb/client/file.c | 1004 ------------------------------------------ 1 file changed, 1004 deletions(-)
fs/smb/client/file.c +0 -1004
@@ -2695,471 +2695,6 @@ int cifs_flush(struct file *file, fl_owner_t id)return rc; } -#if 0 // TODO remove 3594 -static void collect_uncached_write_data (struct cifs_aio_ctx *ctx); - -static void -cifs_uncached_writev_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *wdata =container_of (work, - struct cifs_io_subrequest, work); -struct inode *inode =d_inode (wdata->cfile->dentry); -struct cifsInodeInfo *cifsi =CIFS_I (inode); - -spin_lock (&inode->i_lock); -cifs_update_eof (cifsi, wdata->subreq.start, wdata->subreq.len); -if (cifsi->netfs.remote_i_size > inode->i_size) -i_size_write (inode, cifsi->netfs.remote_i_size); -spin_unlock (&inode->i_lock); - -complete (&wdata->done); -collect_uncached_write_data (wdata->ctx); -/* the below call can possibly free the last ref to aio ctx */ -cifs_put_writedata (wdata); -} - -static int -cifs_resend_wdata (struct cifs_io_subrequest *wdata,struct list_head *wdata_list, -struct cifs_aio_ctx *ctx) -{ -size_t wsize; -struct cifs_credits credits; -int rc; -struct TCP_Server_Info *server = wdata->server; - -do { -if (wdata->cfile->invalidHandle) { - rc =cifs_reopen_file (wdata->cfile, false); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - - -/* -* Wait for credits to resend this wdata. -* Note: we are attempting to resend the whole wdata not in -* segments -*/ -do { - rc = server->ops->wait_mtu_credits (server, wdata->subreq.len, - &wsize, &credits); -if (rc) - goto fail; - -if (wsize < wdata->subreq.len) { -add_credits_and_wake_if (server, &credits,0 ); -msleep (1000 ); - } - }while (wsize < wdata->subreq.len); - wdata->credits = credits; - - rc =adjust_credits (server, &wdata->credits, wdata->subreq.len); - -if (!rc) { -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else { -set_bit (NETFS_SREQ_RETRYING , &wdata->subreq.flags); -#ifdef CONFIG_CIFS_SMB_DIRECT -if (wdata->mr) { - wdata->mr->need_invalidate = true; -smbd_deregister_mr (wdata->mr); - wdata->mr =NULL ; - } -#endif - rc = server->ops->async_writev (wdata); - } - } - -/* If the write was successfully sent, we are done */ -if (!rc) { -list_add_tail (&wdata->list, wdata_list); -return 0 ; - } - -/* Roll back credits and retry if needed */ -add_credits_and_wake_if (server, &wdata->credits,0 ); - }while (rc == -EAGAIN ); - -fail: -cifs_put_writedata (wdata); -return rc; -} - -/* -* Select span of a bvec iterator we're going to use. Limit it by both maximum -* size and maximum number of segments. -*/ -static size_t cifs_limit_bvec_subset (const struct iov_iter *iter,size_t max_size, -size_t max_segs,unsigned int *_nsegs) -{ -const struct bio_vec *bvecs = iter->bvec; -unsigned int nbv = iter->nr_segs, ix =0 , nsegs =0 ; -size_t len, span =0 , n = iter->count; -size_t skip = iter->iov_offset; - -if (WARN_ON (!iov_iter_is_bvec (iter)) || n ==0 ) -return 0 ; - -while (n && ix < nbv && skip) { - len = bvecs[ix].bv_len; -if (skip < len) -break ; - skip -= len; - n -= len; - ix++; - } - -while (n && ix < nbv) { - len =min3 (n, bvecs[ix].bv_len - skip, max_size); - span += len; - max_size -= len; - nsegs++; - ix++; -if (max_size ==0 || nsegs >= max_segs) -break ; - skip =0 ; - n -= len; - } - - *_nsegs = nsegs; -return span; -} - -static int -cifs_write_from_iter (loff_t fpos,size_t len,struct iov_iter *from, -struct cifsFileInfo *open_file, -struct cifs_sb_info *cifs_sb,struct list_head *wdata_list, -struct cifs_aio_ctx *ctx) -{ -int rc =0 ; -size_t cur_len, max_len; -struct cifs_io_subrequest *wdata; -pid_t pid; -struct TCP_Server_Info *server; -unsigned int xid, max_segs =INT_MAX ; - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - - server =cifs_pick_channel (tlink_tcon (open_file->tlink)->ses); - xid =get_xid (); - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_segs = server->smbd_conn->max_frmr_depth; -#endif - -do { -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -unsigned int nsegs =0 ; -size_t wsize; - -if (signal_pending (current)) { - rc = -EINTR ; -break ; - } - -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, false); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->wsize, - &wsize, credits); -if (rc) -break ; - - max_len = min_t(const size_t, len, wsize); -if (!max_len) { - rc = -EAGAIN ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - cur_len =cifs_limit_bvec_subset (from, max_len, max_segs, &nsegs); -cifs_dbg (FYI ,"write_from_iter len=%zx/%zx nsegs=%u/%lu/%u\n" , - cur_len, max_len, nsegs, from->nr_segs, max_segs); -if (cur_len ==0 ) { - rc = -EIO ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - wdata =cifs_writedata_alloc (cifs_uncached_writev_complete); -if (!wdata) { - rc = -ENOMEM ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - wdata->uncached = true; - wdata->sync_mode =WB_SYNC_ALL ; - wdata->subreq.start = (__u64 )fpos; - wdata->cfile =cifsFileInfo_get (open_file); - wdata->server = server; - wdata->pid = pid; - wdata->subreq.len = cur_len; - wdata->credits = credits_on_stack; - wdata->subreq.io_iter = *from; - wdata->ctx = ctx; -kref_get (&ctx->refcount); - -iov_iter_truncate (&wdata->subreq.io_iter, cur_len); - - rc =adjust_credits (server, &wdata->credits, wdata->subreq.len); - -if (!rc) { -if (wdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = server->ops->async_writev (wdata); - } - -if (rc) { -add_credits_and_wake_if (server, &wdata->credits,0 ); -cifs_put_writedata (wdata); -if (rc == -EAGAIN ) -continue ; -break ; - } - -list_add_tail (&wdata->list, wdata_list); -iov_iter_advance (from, cur_len); - fpos += cur_len; - len -= cur_len; - }while (len >0 ); - -free_xid (xid); -return rc; -} - -static void collect_uncached_write_data (struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *wdata, *tmp; -struct cifs_tcon *tcon; -struct cifs_sb_info *cifs_sb; -struct dentry *dentry = ctx->cfile->dentry; -ssize_t rc; - - tcon =tlink_tcon (ctx->cfile->tlink); - cifs_sb =CIFS_SB (dentry->d_sb); - -mutex_lock (&ctx->aio_mutex); - -if (list_empty (&ctx->list)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - - rc = ctx->rc; -/* -* Wait for and collect replies for any successful sends in order of -* increasing offset. Once an error is hit, then return without waiting -* for any more replies. -*/ -restart_loop: -list_for_each_entry_safe (wdata, tmp, &ctx->list, list) { -if (!rc) { -if (!try_wait_for_completion (&wdata->done)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - -if (wdata->result) - rc = wdata->result; -else - ctx->total_len += wdata->subreq.len; - -/* resend call if it's a retryable error */ -if (rc == -EAGAIN ) { -struct list_head tmp_list; -struct iov_iter tmp_from = ctx->iter; - -INIT_LIST_HEAD (&tmp_list); -list_del_init (&wdata->list); - -if (ctx->direct_io) - rc =cifs_resend_wdata ( - wdata, &tmp_list, ctx); -else { -iov_iter_advance (&tmp_from, - wdata->subreq.start - ctx->pos); - - rc =cifs_write_from_iter (wdata->subreq.start, - wdata->subreq.len, &tmp_from, - ctx->cfile, cifs_sb, &tmp_list, - ctx); - -cifs_put_writedata (wdata); - } - -list_splice (&tmp_list, &ctx->list); - goto restart_loop; - } - } -list_del_init (&wdata->list); -cifs_put_writedata (wdata); - } - -cifs_stats_bytes_written (tcon, ctx->total_len); -set_bit (CIFS_INO_INVALID_MAPPING , &CIFS_I (dentry->d_inode)->flags); - - ctx->rc = (rc ==0 ) ? ctx->total_len : rc; - -mutex_unlock (&ctx->aio_mutex); - -if (ctx->iocb && ctx->iocb->ki_complete) - ctx->iocb->ki_complete (ctx->iocb, ctx->rc); -else -complete (&ctx->done); -} - -static ssize_t __cifs_writev ( -struct kiocb *iocb,struct iov_iter *from,bool direct) -{ -struct file *file = iocb->ki_filp; -ssize_t total_written =0 ; -struct cifsFileInfo *cfile; -struct cifs_tcon *tcon; -struct cifs_sb_info *cifs_sb; -struct cifs_aio_ctx *ctx; -int rc; - - rc =generic_write_checks (iocb, from); -if (rc <=0 ) -return rc; - - cifs_sb =CIFS_FILE_SB (file); - cfile = file->private_data; - tcon =tlink_tcon (cfile->tlink); - -if (!tcon->ses->server->ops->async_writev) -return -ENOSYS ; - - ctx =cifs_aio_ctx_alloc (); -if (!ctx) -return -ENOMEM ; - - ctx->cfile =cifsFileInfo_get (cfile); - -if (!is_sync_kiocb (iocb)) - ctx->iocb = iocb; - - ctx->pos = iocb->ki_pos; - ctx->direct_io = direct; - ctx->nr_pinned_pages =0 ; - -if (user_backed_iter (from)) { -/* -* Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as -* they contain references to the calling process's virtual -* memory layout which won't be available in an async worker -* thread. This also takes a pin on every folio involved. -*/ - rc =netfs_extract_user_iter (from,iov_iter_count (from), - &ctx->iter,0 ); -if (rc <0 ) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - - ctx->nr_pinned_pages = rc; - ctx->bv = (void *)ctx->iter.bvec; - ctx->bv_need_unpin =iov_iter_extract_will_pin (from); - }else if ((iov_iter_is_bvec (from) ||iov_iter_is_kvec (from)) && - !is_sync_kiocb (iocb)) { -/* -* If the op is asynchronous, we need to copy the list attached -* to a BVEC/KVEC-type iterator, but we assume that the storage -* will be pinned by the caller; in any case, we may or may not -* be able to pin the pages, so we don't try. -*/ - ctx->bv = (void *)dup_iter (&ctx->iter, from,GFP_KERNEL ); -if (!ctx->bv) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -ENOMEM ; - } - }else { -/* -* Otherwise, we just pass the iterator down as-is and rely on -* the caller to make sure the pages referred to by the -* iterator don't evaporate. -*/ - ctx->iter = *from; - } - - ctx->len =iov_iter_count (&ctx->iter); - -/* grab a lock here due to read response handlers can access ctx */ -mutex_lock (&ctx->aio_mutex); - - rc =cifs_write_from_iter (iocb->ki_pos, ctx->len, &ctx->iter, - cfile, cifs_sb, &ctx->list, ctx); - -/* -* If at least one write was successfully sent, then discard any rc -* value from the later writes. If the other write succeeds, then -* we'll end up returning whatever was written. If it fails, then -* we'll get a new rc value from that. -*/ -if (!list_empty (&ctx->list)) - rc =0 ; - -mutex_unlock (&ctx->aio_mutex); - -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - -if (!is_sync_kiocb (iocb)) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EIOCBQUEUED ; - } - - rc =wait_for_completion_killable (&ctx->done); -if (rc) { -mutex_lock (&ctx->aio_mutex); - ctx->rc = rc = -EINTR ; - total_written = ctx->total_len; -mutex_unlock (&ctx->aio_mutex); - }else { - rc = ctx->rc; - total_written = ctx->total_len; - } - -kref_put (&ctx->refcount, cifs_aio_ctx_release); - -if (unlikely (!total_written)) -return rc; - - iocb->ki_pos += total_written; -return total_written; -} - -ssize_t cifs_direct_writev (struct kiocb *iocb,struct iov_iter *from) -{ -struct file *file = iocb->ki_filp; - -cifs_revalidate_mapping (file->f_inode); -return __cifs_writev (iocb, from, true); -} - -ssize_t cifs_user_writev (struct kiocb *iocb,struct iov_iter *from) -{ -return __cifs_writev (iocb, from, false); -} -#endif // TODO remove 3594 -static ssize_t cifs_writev (struct kiocb *iocb,struct iov_iter *from) {
@@ -3248,450 +2783,6 @@ cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)return written; } -#if 0 // TODO remove 4143 -static struct cifs_io_subrequest *cifs_readdata_alloc (work_func_t complete) -{ -struct cifs_io_subrequest *rdata; - - rdata =kzalloc (sizeof (*rdata),GFP_KERNEL ); -if (rdata) { -refcount_set (&rdata->subreq.ref,1 ); -INIT_LIST_HEAD (&rdata->list); -init_completion (&rdata->done); -INIT_WORK (&rdata->work, complete); - } - -return rdata; -} - -void -cifs_readdata_release (struct cifs_io_subrequest *rdata) -{ -if (rdata->ctx) -kref_put (&rdata->ctx->refcount, cifs_aio_ctx_release); -#ifdef CONFIG_CIFS_SMB_DIRECT -if (rdata->mr) { -smbd_deregister_mr (rdata->mr); - rdata->mr =NULL ; - } -#endif -if (rdata->cfile) -cifsFileInfo_put (rdata->cfile); - -kfree (rdata); -} - -static void collect_uncached_read_data (struct cifs_aio_ctx *ctx); - -static void -cifs_uncached_readv_complete (struct work_struct *work) -{ -struct cifs_io_subrequest *rdata = - container_of(work, struct cifs_io_subrequest, work); - -complete (&rdata->done); -collect_uncached_read_data (rdata->ctx); -/* the below call can possibly free the last ref to aio ctx */ -cifs_put_readdata (rdata); -} - -static int cifs_resend_rdata (struct cifs_io_subrequest *rdata, -struct list_head *rdata_list, -struct cifs_aio_ctx *ctx) -{ -size_t rsize; -struct cifs_credits credits; -int rc; -struct TCP_Server_Info *server; - -/* XXX: should we pick a new channel here? */ - server = rdata->server; - -do { -if (rdata->cfile->invalidHandle) { - rc =cifs_reopen_file (rdata->cfile, true); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - -/* -* Wait for credits to resend this rdata. -* Note: we are attempting to resend the whole rdata not in -* segments -*/ -do { - rc = server->ops->wait_mtu_credits (server, rdata->subreq.len, - &rsize, &credits); - -if (rc) - goto fail; - -if (rsize < rdata->subreq.len) { -add_credits_and_wake_if (server, &credits,0 ); -msleep (1000 ); - } - }while (rsize < rdata->subreq.len); - rdata->credits = credits; - - rc =adjust_credits (server, &rdata->credits, rdata->subreq.len); -if (!rc) { -if (rdata->cfile->invalidHandle) - rc = -EAGAIN ; -else { -#ifdef CONFIG_CIFS_SMB_DIRECT -if (rdata->mr) { - rdata->mr->need_invalidate = true; -smbd_deregister_mr (rdata->mr); - rdata->mr =NULL ; - } -#endif - rc = server->ops->async_readv (rdata); - } - } - -/* If the read was successfully sent, we are done */ -if (!rc) { -/* Add to aio pending list */ -list_add_tail (&rdata->list, rdata_list); -return 0 ; - } - -/* Roll back credits and retry if needed */ -add_credits_and_wake_if (server, &rdata->credits,0 ); - }while (rc == -EAGAIN ); - -fail: -cifs_put_readdata (rdata); -return rc; -} - -static int -cifs_send_async_read (loff_t fpos,size_t len,struct cifsFileInfo *open_file, -struct cifs_sb_info *cifs_sb,struct list_head *rdata_list, -struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *rdata; -unsigned int nsegs, max_segs =INT_MAX ; -struct cifs_credits credits_on_stack; -struct cifs_credits *credits = &credits_on_stack; -size_t cur_len, max_len, rsize; -int rc; -pid_t pid; -struct TCP_Server_Info *server; - - server =cifs_pick_channel (tlink_tcon (open_file->tlink)->ses); - -#ifdef CONFIG_CIFS_SMB_DIRECT -if (server->smbd_conn) - max_segs = server->smbd_conn->max_frmr_depth; -#endif - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - -do { -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, true); -if (rc == -EAGAIN ) -continue ; -else if (rc) -break ; - } - -if (cifs_sb->ctx->rsize ==0 ) - cifs_sb->ctx->rsize = - server->ops->negotiate_rsize (tlink_tcon (open_file->tlink), - cifs_sb->ctx); - - rc = server->ops->wait_mtu_credits (server, cifs_sb->ctx->rsize, - &rsize, credits); -if (rc) -break ; - - max_len =min_t (size_t, len, rsize); - - cur_len =cifs_limit_bvec_subset (&ctx->iter, max_len, - max_segs, &nsegs); -cifs_dbg (FYI ,"read-to-iter len=%zx/%zx nsegs=%u/%lu/%u\n" , - cur_len, max_len, nsegs, ctx->iter.nr_segs, max_segs); -if (cur_len ==0 ) { - rc = -EIO ; -add_credits_and_wake_if (server, credits,0 ); -break ; - } - - rdata =cifs_readdata_alloc (cifs_uncached_readv_complete); -if (!rdata) { -add_credits_and_wake_if (server, credits,0 ); - rc = -ENOMEM ; -break ; - } - - rdata->server = server; - rdata->cfile =cifsFileInfo_get (open_file); - rdata->subreq.start = fpos; - rdata->subreq.len = cur_len; - rdata->pid = pid; - rdata->credits = credits_on_stack; - rdata->ctx = ctx; -kref_get (&ctx->refcount); - - rdata->subreq.io_iter = ctx->iter; -iov_iter_truncate (&rdata->subreq.io_iter, cur_len); - - rc =adjust_credits (server, &rdata->credits, rdata->subreq.len); - -if (!rc) { -if (rdata->cfile->invalidHandle) - rc = -EAGAIN ; -else - rc = server->ops->async_readv (rdata); - } - -if (rc) { -add_credits_and_wake_if (server, &rdata->credits,0 ); -cifs_put_readdata (rdata); -if (rc == -EAGAIN ) -continue ; -break ; - } - -list_add_tail (&rdata->list, rdata_list); -iov_iter_advance (&ctx->iter, cur_len); - fpos += cur_len; - len -= cur_len; - }while (len >0 ); - -return rc; -} - -static void -collect_uncached_read_data (struct cifs_aio_ctx *ctx) -{ -struct cifs_io_subrequest *rdata, *tmp; -struct cifs_sb_info *cifs_sb; -int rc; - - cifs_sb =CIFS_SB (ctx->cfile->dentry->d_sb); - -mutex_lock (&ctx->aio_mutex); - -if (list_empty (&ctx->list)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - - rc = ctx->rc; -/* the loop below should proceed in the order of increasing offsets */ -again: -list_for_each_entry_safe (rdata, tmp, &ctx->list, list) { -if (!rc) { -if (!try_wait_for_completion (&rdata->done)) { -mutex_unlock (&ctx->aio_mutex); -return ; - } - -if (rdata->result == -EAGAIN ) { -/* resend call if it's a retryable error */ -struct list_head tmp_list; -unsigned int got_bytes = rdata->got_bytes; - -list_del_init (&rdata->list); -INIT_LIST_HEAD (&tmp_list); - -if (ctx->direct_io) { -/* -* Re-use rdata as this is a -* direct I/O -*/ - rc =cifs_resend_rdata ( - rdata, - &tmp_list, ctx); - }else { - rc =cifs_send_async_read ( - rdata->subreq.start + got_bytes, - rdata->subreq.len - got_bytes, - rdata->cfile, cifs_sb, - &tmp_list, ctx); - -cifs_put_readdata (rdata); - } - -list_splice (&tmp_list, &ctx->list); - - goto again; - }else if (rdata->result) - rc = rdata->result; - -/* if there was a short read -- discard anything left */ -if (rdata->got_bytes && rdata->got_bytes < rdata->subreq.len) - rc = -ENODATA ; - - ctx->total_len += rdata->got_bytes; - } -list_del_init (&rdata->list); -cifs_put_readdata (rdata); - } - -/* mask nodata case */ -if (rc == -ENODATA ) - rc =0 ; - - ctx->rc = (rc ==0 ) ? (ssize_t )ctx->total_len : rc; - -mutex_unlock (&ctx->aio_mutex); - -if (ctx->iocb && ctx->iocb->ki_complete) - ctx->iocb->ki_complete (ctx->iocb, ctx->rc); -else -complete (&ctx->done); -} - -static ssize_t __cifs_readv ( -struct kiocb *iocb,struct iov_iter *to,bool direct) -{ -size_t len; -struct file *file = iocb->ki_filp; -struct cifs_sb_info *cifs_sb; -struct cifsFileInfo *cfile; -struct cifs_tcon *tcon; -ssize_t rc, total_read =0 ; -loff_t offset = iocb->ki_pos; -struct cifs_aio_ctx *ctx; - - len =iov_iter_count (to); -if (!len) -return 0 ; - - cifs_sb =CIFS_FILE_SB (file); - cfile = file->private_data; - tcon =tlink_tcon (cfile->tlink); - -if (!tcon->ses->server->ops->async_readv) -return -ENOSYS ; - -if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) -cifs_dbg (FYI ,"attempting read on write only file instance\n" ); - - ctx =cifs_aio_ctx_alloc (); -if (!ctx) -return -ENOMEM ; - - ctx->pos = offset; - ctx->direct_io = direct; - ctx->len = len; - ctx->cfile =cifsFileInfo_get (cfile); - ctx->nr_pinned_pages =0 ; - -if (!is_sync_kiocb (iocb)) - ctx->iocb = iocb; - -if (user_backed_iter (to)) { -/* -* Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as -* they contain references to the calling process's virtual -* memory layout which won't be available in an async worker -* thread. This also takes a pin on every folio involved. -*/ - rc =netfs_extract_user_iter (to,iov_iter_count (to), - &ctx->iter,0 ); -if (rc <0 ) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - - ctx->nr_pinned_pages = rc; - ctx->bv = (void *)ctx->iter.bvec; - ctx->bv_need_unpin =iov_iter_extract_will_pin (to); - ctx->should_dirty = true; - }else if ((iov_iter_is_bvec (to) ||iov_iter_is_kvec (to)) && - !is_sync_kiocb (iocb)) { -/* -* If the op is asynchronous, we need to copy the list attached -* to a BVEC/KVEC-type iterator, but we assume that the storage -* will be retained by the caller; in any case, we may or may -* not be able to pin the pages, so we don't try. -*/ - ctx->bv = (void *)dup_iter (&ctx->iter, to,GFP_KERNEL ); -if (!ctx->bv) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -ENOMEM ; - } - }else { -/* -* Otherwise, we just pass the iterator down as-is and rely on -* the caller to make sure the pages referred to by the -* iterator don't evaporate. -*/ - ctx->iter = *to; - } - -if (direct) { - rc =filemap_write_and_wait_range (file->f_inode->i_mapping, - offset, offset + len -1 ); -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EAGAIN ; - } - } - -/* grab a lock here due to read response handlers can access ctx */ -mutex_lock (&ctx->aio_mutex); - - rc =cifs_send_async_read (offset, len, cfile, cifs_sb, &ctx->list, ctx); - -/* if at least one read request send succeeded, then reset rc */ -if (!list_empty (&ctx->list)) - rc =0 ; - -mutex_unlock (&ctx->aio_mutex); - -if (rc) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return rc; - } - -if (!is_sync_kiocb (iocb)) { -kref_put (&ctx->refcount, cifs_aio_ctx_release); -return -EIOCBQUEUED ; - } - - rc =wait_for_completion_killable (&ctx->done); -if (rc) { -mutex_lock (&ctx->aio_mutex); - ctx->rc = rc = -EINTR ; - total_read = ctx->total_len; -mutex_unlock (&ctx->aio_mutex); - }else { - rc = ctx->rc; - total_read = ctx->total_len; - } - -kref_put (&ctx->refcount, cifs_aio_ctx_release); - -if (total_read) { - iocb->ki_pos += total_read; -return total_read; - } -return rc; -} - -ssize_t cifs_direct_readv (struct kiocb *iocb,struct iov_iter *to) -{ -return __cifs_readv (iocb, to, true); -} - -ssize_t cifs_user_readv (struct kiocb *iocb,struct iov_iter *to) -{ -return __cifs_readv (iocb, to, false); - -} -#endif // end netfslib removal 4143 -ssize_t cifs_loose_read_iter (struct kiocb *iocb,struct iov_iter *iter) {ssize_t rc;
@@ -3790,101 +2881,6 @@ cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)return rc; } -#if 0 // TODO remove 4633 -static ssize_t -cifs_read (struct file *file,char *read_data,size_t read_size,loff_t *offset) -{ -int rc = -EACCES ; -unsigned int bytes_read =0 ; -unsigned int total_read; -unsigned int current_read_size; -unsigned int rsize; -struct cifs_sb_info *cifs_sb; -struct cifs_tcon *tcon; -struct TCP_Server_Info *server; -unsigned int xid; -char *cur_offset; -struct cifsFileInfo *open_file; -struct cifs_io_parms io_parms = {0 }; -int buf_type =CIFS_NO_BUFFER ; -__u32 pid; - - xid =get_xid (); - cifs_sb =CIFS_FILE_SB (file); - -/* FIXME: set up handlers for larger reads and/or convert to async */ - rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize); - -if (file->private_data ==NULL ) { - rc = -EBADF ; -free_xid (xid); -return rc; - } - open_file = file->private_data; - tcon =tlink_tcon (open_file->tlink); - server =cifs_pick_channel (tcon->ses); - -if (!server->ops->sync_read) { -free_xid (xid); -return -ENOSYS ; - } - -if (cifs_sb->mnt_cifs_flags &CIFS_MOUNT_RWPIDFORWARD ) - pid = open_file->pid; -else - pid = current->tgid; - -if ((file->f_flags &O_ACCMODE ) ==O_WRONLY ) -cifs_dbg (FYI ,"attempting read on write only file instance\n" ); - -for (total_read =0 , cur_offset = read_data; read_size > total_read; - total_read += bytes_read, cur_offset += bytes_read) { -do { - current_read_size =min_t (uint, read_size - total_read, - rsize); -/* -* For windows me and 9x we do not want to request more -* than it negotiated since it will refuse the read -* then. -*/ -if (!(tcon->ses->capabilities & - tcon->ses->server->vals->cap_large_files)) { - current_read_size =min_t (uint, - current_read_size, CIFSMaxBufSize); - } -if (open_file->invalidHandle) { - rc =cifs_reopen_file (open_file, true); -if (rc !=0 ) -break ; - } - io_parms.pid = pid; - io_parms.tcon = tcon; - io_parms.offset = *offset; - io_parms.length = current_read_size; - io_parms.server = server; - rc = server->ops->sync_read (xid, &open_file->fid, &io_parms, - &bytes_read, &cur_offset, - &buf_type); - }while (rc == -EAGAIN ); - -if (rc || (bytes_read ==0 )) { -if (total_read) { -break ; - }else { -free_xid (xid); -return rc; - } - }else { -cifs_stats_bytes_read (tcon, total_read); - *offset += bytes_read; - } - } -free_xid (xid); -return total_read; -} -#endif // end netfslib remove 4633 - -static vm_fault_t cifs_page_mkwrite (struct vm_fault *vmf) {return netfs_page_mkwrite (vmf,NULL );