blob: dca42aa87d305e9d175b1344145ee6ddd2eae300 [file] [log] [blame]
Steve French929be902021-06-18 00:31:49 -05001// SPDX-License-Identifier: LGPL-2.1
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Steve French2b280fa2008-05-17 03:12:45 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Common Internet FileSystem (CIFS) client
8 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11/* Note that BB means BUGBUG (ie something to fix eventually) */
12
13#include <linux/module.h>
14#include <linux/fs.h>
15#include <linux/mount.h>
16#include <linux/slab.h>
17#include <linux/init.h>
18#include <linux/list.h>
19#include <linux/seq_file.h>
20#include <linux/vfs.h>
21#include <linux/mempool.h>
Steve French6ab16d22005-11-29 20:55:11 -080022#include <linux/delay.h>
Steve French45af7a02006-04-21 22:52:25 +000023#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080024#include <linux/freezer.h>
Al Virofec11dd2011-07-18 13:50:40 -040025#include <linux/namei.h>
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -070026#include <linux/random.h>
Andrew Lunnc6e970a2017-03-28 23:45:06 +020027#include <linux/uuid.h>
Andreas Gruenbachera9ae0082016-04-22 12:11:38 +020028#include <linux/xattr.h>
Ben Greear3eb9a882010-09-01 17:06:02 -070029#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "cifsfs.h"
31#include "cifspdu.h"
32#define DECLARE_GLOBALS_HERE
33#include "cifsglob.h"
34#include "cifsproto.h"
35#include "cifs_debug.h"
36#include "cifs_fs_sb.h"
37#include <linux/mm.h>
Jeff Layton84a15b92007-11-03 05:02:24 +000038#include <linux/key-type.h>
Jeff Laytone5459372007-11-03 05:11:06 +000039#include "cifs_spnego.h"
Suresh Jayaramanf579cf32010-07-05 18:11:50 +053040#include "fscache.h"
Paulo Alcantara1c780222018-11-14 16:24:03 -020041#ifdef CONFIG_CIFS_DFS_UPCALL
42#include "dfs_cache.h"
43#endif
Samuel Cabrero06f08da2020-11-30 19:02:49 +010044#ifdef CONFIG_CIFS_SWN_UPCALL
45#include "netlink.h"
46#endif
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -060047#include "fs_context.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Deepa Dinamanicb7a69e2019-03-22 14:32:35 -070049/*
50 * DOS dates from 1980/1/1 through 2107/12/31
51 * Protocol specifications indicate the range should be to 119, which
52 * limits maximum year to 2099. But this range has not been checked.
53 */
54#define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
55#define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
56#define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058int cifsFYI = 0;
Kees Cook14042972016-03-17 14:22:54 -070059bool traceSMB;
Steve Frenche7504732011-10-12 17:47:03 -050060bool enable_oplocks = true;
Kees Cook14042972016-03-17 14:22:54 -070061bool linuxExtEnabled = true;
62bool lookupCacheEnabled = true;
Steve Frenchf92a7202018-05-24 04:11:07 -050063bool disable_legacy_dialects; /* false by default */
Steve Frenchfee742b2021-04-27 23:07:19 -050064bool enable_gcm_256 = true;
Steve Frenchfbfd0b42020-09-11 16:19:28 -050065bool require_gcm_256; /* false by default */
Steve French53d31a32021-07-05 15:05:39 -050066bool enable_negotiate_signing; /* false by default */
Jeff Layton04912d62010-04-24 07:57:45 -040067unsigned int global_secflags = CIFSSEC_DEF;
Steve French39798772006-05-31 22:40:51 +000068/* unsigned int ntlmv2_support = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -070069unsigned int sign_CIFS_PDUs = 1;
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080070static const struct super_operations cifs_super_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
Germano Percossicb978ac2016-09-30 21:25:24 -050072module_param(CIFSMaxBufSize, uint, 0444);
Steve French11911b92018-05-24 02:09:20 -050073MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
74 "for CIFS requests. "
Steve French63135e02007-07-17 17:34:02 +000075 "Default: 16384 Range: 8192 to 130048");
Linus Torvalds1da177e2005-04-16 15:20:36 -070076unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
Germano Percossicb978ac2016-09-30 21:25:24 -050077module_param(cifs_min_rcv, uint, 0444);
Steve French63135e02007-07-17 17:34:02 +000078MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
79 "1 to 64");
Linus Torvalds1da177e2005-04-16 15:20:36 -070080unsigned int cifs_min_small = 30;
Germano Percossicb978ac2016-09-30 21:25:24 -050081module_param(cifs_min_small, uint, 0444);
Steve French63135e02007-07-17 17:34:02 +000082MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
83 "Range: 2 to 256");
Linus Torvalds1da177e2005-04-16 15:20:36 -070084unsigned int cifs_max_pending = CIFS_MAX_REQ;
Jeff Layton60654ce2012-11-25 08:00:34 -050085module_param(cifs_max_pending, uint, 0444);
Steve French11911b92018-05-24 02:09:20 -050086MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
87 "CIFS/SMB1 dialect (N/A for SMB3) "
Pavel Shilovsky10b9b982012-03-20 12:55:09 +030088 "Default: 32767 Range: 2 to 32767.");
Steve French00778e22018-09-18 14:05:18 -050089#ifdef CONFIG_CIFS_STATS2
90unsigned int slow_rsp_threshold = 1;
91module_param(slow_rsp_threshold, uint, 0644);
92MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
93 "before logging that a response is delayed. "
94 "Default: 1 (if set to 0 disables msg).");
95#endif /* STATS2 */
96
Steve Frenche7504732011-10-12 17:47:03 -050097module_param(enable_oplocks, bool, 0644);
Jeff Layton60654ce2012-11-25 08:00:34 -050098MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
Steve Frenche7504732011-10-12 17:47:03 -050099
Steve French29e27922020-10-14 20:24:09 -0500100module_param(enable_gcm_256, bool, 0644);
101MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
102
Steve Frenchfbfd0b42020-09-11 16:19:28 -0500103module_param(require_gcm_256, bool, 0644);
104MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
105
Steve French53d31a32021-07-05 15:05:39 -0500106module_param(enable_negotiate_signing, bool, 0644);
107MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
108
Steve Frenchf92a7202018-05-24 04:11:07 -0500109module_param(disable_legacy_dialects, bool, 0644);
110MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
111 "helpful to restrict the ability to "
112 "override the default dialects (SMB2.1, "
113 "SMB3 and SMB3.02) on mount with old "
114 "dialects (CIFS/SMB1 and SMB2) since "
115 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
116 " and less secure. Default: n/N/0");
117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118extern mempool_t *cifs_sm_req_poolp;
119extern mempool_t *cifs_req_poolp;
120extern mempool_t *cifs_mid_poolp;
121
Jeff Laytonda472fc2012-03-23 14:40:53 -0400122struct workqueue_struct *cifsiod_wq;
Steve French35cf94a2019-09-07 01:09:49 -0500123struct workqueue_struct *decrypt_wq;
Ronnie Sahlberg32546a92019-11-03 13:06:37 +1000124struct workqueue_struct *fileinfo_put_wq;
Rabin Vincent3998e6b82017-05-03 17:54:01 +0200125struct workqueue_struct *cifsoplockd_wq;
Rohith Surabattula860b69a2021-05-05 10:56:47 +0000126struct workqueue_struct *deferredclose_wq;
Jeff Layton3d224622016-05-24 06:27:44 -0400127__u32 cifs_lock_secret;
Jeff Laytonda472fc2012-03-23 14:40:53 -0400128
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100129/*
130 * Bumps refcount for cifs super block.
131 * Note that it should be only called if a referece to VFS super block is
132 * already held, e.g. in open-type syscalls context. Otherwise it can race with
133 * atomic_dec_and_test in deactivate_locked_super.
134 */
135void
136cifs_sb_active(struct super_block *sb)
137{
138 struct cifs_sb_info *server = CIFS_SB(sb);
139
140 if (atomic_inc_return(&server->active) == 1)
141 atomic_inc(&sb->s_active);
142}
143
144void
145cifs_sb_deactive(struct super_block *sb)
146{
147 struct cifs_sb_info *server = CIFS_SB(sb);
148
149 if (atomic_dec_and_test(&server->active))
150 deactivate_super(sb);
151}
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153static int
Al Viro97d11522011-06-17 09:29:57 -0400154cifs_read_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
156 struct inode *inode;
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400157 struct cifs_sb_info *cifs_sb;
Jan Klos2f6c9472013-10-06 21:08:20 +0200158 struct cifs_tcon *tcon;
Deepa Dinamanicb7a69e2019-03-22 14:32:35 -0700159 struct timespec64 ts;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +0000161
Pavel Shilovskyb2e5cd32011-05-25 13:35:34 +0400162 cifs_sb = CIFS_SB(sb);
Jan Klos2f6c9472013-10-06 21:08:20 +0200163 tcon = cifs_sb_master_tcon(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Al Viro2c6292a2011-06-17 09:05:48 -0400165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800166 sb->s_flags |= SB_POSIXACL;
Al Viro2c6292a2011-06-17 09:05:48 -0400167
Steve French8a69e962018-06-29 16:06:15 -0500168 if (tcon->snapshot_time)
169 sb->s_flags |= SB_RDONLY;
170
Jan Klos2f6c9472013-10-06 21:08:20 +0200171 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
Al Viro2c6292a2011-06-17 09:05:48 -0400172 sb->s_maxbytes = MAX_LFS_FILESIZE;
173 else
174 sb->s_maxbytes = MAX_NON_LFS;
175
Steve French553292a2019-10-11 17:36:13 -0700176 /*
177 * Some very old servers like DOS and OS/2 used 2 second granularity
178 * (while all current servers use 100ns granularity - see MS-DTYP)
179 * but 1 second is the maximum allowed granularity for the VFS
180 * so for old servers set time granularity to 1 second while for
181 * everything else (current servers) set it to 100ns.
182 */
Steve Frenchd4cfbf02019-10-08 00:27:14 -0500183 if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
184 ((tcon->ses->capabilities &
185 tcon->ses->server->vals->cap_nt_find) == 0) &&
186 !tcon->unix_ext) {
187 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
188 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
189 sb->s_time_min = ts.tv_sec;
190 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
191 cpu_to_le16(SMB_TIME_MAX), 0);
192 sb->s_time_max = ts.tv_sec;
193 } else {
194 /*
195 * Almost every server, including all SMB2+, uses DCE TIME
196 * ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC
197 */
198 sb->s_time_gran = 100;
Deepa Dinamanicb7a69e2019-03-22 14:32:35 -0700199 ts = cifs_NTtimeToUnix(0);
200 sb->s_time_min = ts.tv_sec;
201 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
202 sb->s_time_max = ts.tv_sec;
Deepa Dinamanicb7a69e2019-03-22 14:32:35 -0700203 }
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 sb->s_magic = CIFS_MAGIC_NUMBER;
206 sb->s_op = &cifs_super_ops;
Andreas Gruenbachera9ae0082016-04-22 12:11:38 +0200207 sb->s_xattr = cifs_xattr_handlers;
Jan Kara851ea082017-04-12 12:24:34 +0200208 rc = super_setup_bdi(sb);
209 if (rc)
210 goto out_no_root;
Steve Frenchb8d64f82021-04-24 21:46:23 -0500211 /* tune readahead according to rsize if readahead size not set on mount */
212 if (cifs_sb->ctx->rasize)
213 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
214 else
215 sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
Jan Kara851ea082017-04-12 12:24:34 +0200216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 sb->s_blocksize = CIFS_MAX_MSGSIZE;
218 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
Shirish Pargaonkar9b6763e2011-02-21 23:56:59 -0600219 inode = cifs_root_iget(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
David Howellsce634ab2008-02-07 00:15:33 -0800221 if (IS_ERR(inode)) {
222 rc = PTR_ERR(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 goto out_no_root;
224 }
225
Jan Klos2f6c9472013-10-06 21:08:20 +0200226 if (tcon->nocase)
Jeff Layton66ffd112013-07-30 11:38:44 -0400227 sb->s_d_op = &cifs_ci_dentry_ops;
228 else
229 sb->s_d_op = &cifs_dentry_ops;
230
Al Viro48fde702012-01-08 22:15:13 -0500231 sb->s_root = d_make_root(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 if (!sb->s_root) {
233 rc = -ENOMEM;
234 goto out_no_root;
235 }
Steve French50c2f752007-07-13 00:33:32 +0000236
Paul Bollef3a6a602011-10-12 14:14:04 +0200237#ifdef CONFIG_CIFS_NFSD_EXPORT
Steve French7521a3c2007-07-11 18:30:34 +0000238 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500239 cifs_dbg(FYI, "export ops supported\n");
Steve French7521a3c2007-07-11 18:30:34 +0000240 sb->s_export_op = &cifs_export_ops;
241 }
Paul Bollef3a6a602011-10-12 14:14:04 +0200242#endif /* CONFIG_CIFS_NFSD_EXPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 return 0;
245
246out_no_root:
Joe Perchesf96637b2013-05-04 22:12:25 -0500247 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return rc;
249}
250
Al Viro6d686172011-06-17 08:34:57 -0400251static void cifs_kill_sb(struct super_block *sb)
252{
253 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Ronnie Sahlberg5e9c89d2021-03-09 09:07:31 +1000254 struct cifs_tcon *tcon;
255 struct cached_fid *cfid;
Ronnie Sahlberg269f67e2021-03-09 09:07:30 +1000256
Ronnie Sahlberg5e9c89d2021-03-09 09:07:31 +1000257 /*
258 * We ned to release all dentries for the cached directories
259 * before we kill the sb.
260 */
Ronnie Sahlberg269f67e2021-03-09 09:07:30 +1000261 if (cifs_sb->root) {
262 dput(cifs_sb->root);
263 cifs_sb->root = NULL;
264 }
Ronnie Sahlberg5e9c89d2021-03-09 09:07:31 +1000265 tcon = cifs_sb_master_tcon(cifs_sb);
266 if (tcon) {
267 cfid = &tcon->crfid;
268 mutex_lock(&cfid->fid_mutex);
269 if (cfid->dentry) {
270
271 dput(cfid->dentry);
272 cfid->dentry = NULL;
273 }
274 mutex_unlock(&cfid->fid_mutex);
275 }
Ronnie Sahlberg269f67e2021-03-09 09:07:30 +1000276
Al Viro6d686172011-06-17 08:34:57 -0400277 kill_anon_super(sb);
Al Viro98ab4942011-06-17 09:32:10 -0400278 cifs_umount(cifs_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279}
280
281static int
David Howells726c3342006-06-23 02:02:58 -0700282cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
David Howells726c3342006-06-23 02:02:58 -0700284 struct super_block *sb = dentry->d_sb;
Steve French39da9842008-04-28 04:04:34 +0000285 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000286 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700287 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400288 unsigned int xid;
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700289 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400291 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Steve French21ba3842018-06-24 23:18:52 -0500293 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
294 buf->f_namelen =
295 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
296 else
297 buf->f_namelen = PATH_MAX;
298
299 buf->f_fsid.val[0] = tcon->vol_serial_number;
300 /* are using part of create time for more randomness, see man statfs */
301 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 buf->f_files = 0; /* undefined */
304 buf->f_ffree = 0; /* unlimited */
305
Pavel Shilovsky76ec5e32012-09-18 16:20:33 -0700306 if (server->ops->queryfs)
Amir Goldstein0f060932020-02-03 21:46:43 +0200307 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
Steve French39da9842008-04-28 04:04:34 +0000308
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400309 free_xid(xid);
Paulo Alcantara14302ee2021-03-08 12:00:49 -0300310 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
Steve French31742c52014-08-17 08:38:47 -0500313static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
314{
Al Viro7119e222014-10-22 00:25:12 -0400315 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
Steve French31742c52014-08-17 08:38:47 -0500316 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
317 struct TCP_Server_Info *server = tcon->ses->server;
318
319 if (server->ops->fallocate)
320 return server->ops->fallocate(file, tcon, mode, off, len);
321
322 return -EOPNOTSUPP;
323}
324
Christian Brauner549c7292021-01-21 14:19:43 +0100325static int cifs_permission(struct user_namespace *mnt_userns,
326 struct inode *inode, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
328 struct cifs_sb_info *cifs_sb;
329
330 cifs_sb = CIFS_SB(inode->i_sb);
331
Miklos Szeredif696a362008-07-31 13:41:58 +0200332 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
333 if ((mask & MAY_EXEC) && !execute_ok(inode))
334 return -EACCES;
335 else
336 return 0;
337 } else /* file mode might have been restricted at mount time
Steve French50c2f752007-07-13 00:33:32 +0000338 on the client (above and beyond ACL on servers) for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 servers which do not support setting and viewing mode bits,
Steve French50c2f752007-07-13 00:33:32 +0000340 so allowing client to check permissions is useful */
Christian Brauner47291ba2021-01-21 14:19:24 +0100341 return generic_permission(&init_user_ns, inode, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342}
343
Christoph Lametere18b8902006-12-06 20:33:20 -0800344static struct kmem_cache *cifs_inode_cachep;
345static struct kmem_cache *cifs_req_cachep;
346static struct kmem_cache *cifs_mid_cachep;
Christoph Lametere18b8902006-12-06 20:33:20 -0800347static struct kmem_cache *cifs_sm_req_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348mempool_t *cifs_sm_req_poolp;
349mempool_t *cifs_req_poolp;
350mempool_t *cifs_mid_poolp;
351
352static struct inode *
353cifs_alloc_inode(struct super_block *sb)
354{
355 struct cifsInodeInfo *cifs_inode;
Christoph Lametere94b1762006-12-06 20:33:17 -0800356 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 if (!cifs_inode)
358 return NULL;
359 cifs_inode->cifsAttrs = 0x20; /* default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 cifs_inode->time = 0;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700361 /*
362 * Until the file is open and we have gotten oplock info back from the
363 * server, can not assume caching of file data or metadata.
364 */
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300365 cifs_set_oplock_level(cifs_inode, 0);
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400366 cifs_inode->flags = 0;
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000367 spin_lock_init(&cifs_inode->writers_lock);
368 cifs_inode->writers = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 cifs_inode->vfs_inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400370 cifs_inode->server_eof = 0;
Jeff Layton20054bd2011-01-07 11:30:27 -0500371 cifs_inode->uniqueid = 0;
372 cifs_inode->createtime = 0;
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400373 cifs_inode->epoch = 0;
Ronnie Sahlberg487317c2019-06-05 10:38:38 +1000374 spin_lock_init(&cifs_inode->open_file_lock);
Steve Frenchfa70b872016-09-22 00:39:34 -0500375 generate_random_uuid(cifs_inode->lease_key);
Steve French2a38e122017-07-08 18:48:15 -0500376
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700377 /*
378 * Can not set i_flags here - they get immediately overwritten to zero
379 * by the VFS.
380 */
381 /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 INIT_LIST_HEAD(&cifs_inode->openFileList);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700383 INIT_LIST_HEAD(&cifs_inode->llist);
Rohith Surabattulac3f207a2021-04-13 00:26:42 -0500384 INIT_LIST_HEAD(&cifs_inode->deferred_closes);
385 spin_lock_init(&cifs_inode->deferred_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return &cifs_inode->vfs_inode;
387}
388
389static void
Al Viroc2e68022019-04-14 23:18:35 -0400390cifs_free_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
Al Viroc2e68022019-04-14 23:18:35 -0400392 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
Jeff Layton61f98ff2009-06-11 10:27:32 -0400395static void
Al Virob57922d2010-06-07 14:34:48 -0400396cifs_evict_inode(struct inode *inode)
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530397{
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700398 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +0200399 clear_inode(inode);
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530400}
401
402static void
Jeff Layton61f98ff2009-06-11 10:27:32 -0400403cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
404{
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300405 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
406 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
407
Fabian Frederick571d5972014-05-13 18:04:17 +0200408 seq_puts(s, ",addr=");
Jeff Layton61f98ff2009-06-11 10:27:32 -0400409
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300410 switch (server->dstaddr.ss_family) {
Jeff Layton61f98ff2009-06-11 10:27:32 -0400411 case AF_INET:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300412 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400413 break;
414 case AF_INET6:
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300415 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
416 if (sa6->sin6_scope_id)
417 seq_printf(s, "%%%u", sa6->sin6_scope_id);
Jeff Layton61f98ff2009-06-11 10:27:32 -0400418 break;
419 default:
Fabian Frederick571d5972014-05-13 18:04:17 +0200420 seq_puts(s, "(unknown)");
Jeff Layton61f98ff2009-06-11 10:27:32 -0400421 }
Long Li8339dd32017-11-07 01:54:55 -0700422 if (server->rdma)
423 seq_puts(s, ",rdma");
Jeff Layton61f98ff2009-06-11 10:27:32 -0400424}
425
Jeff Layton3e715512011-06-13 11:50:41 -0400426static void
Jeff Layton28e11bd2013-05-26 07:01:00 -0400427cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
Jeff Layton3e715512011-06-13 11:50:41 -0400428{
Steve Frencheda21162015-09-11 19:24:19 -0500429 if (ses->sectype == Unspecified) {
430 if (ses->user_name == NULL)
431 seq_puts(s, ",sec=none");
Jeff Layton28e11bd2013-05-26 07:01:00 -0400432 return;
Steve Frencheda21162015-09-11 19:24:19 -0500433 }
Jeff Layton28e11bd2013-05-26 07:01:00 -0400434
Fabian Frederick571d5972014-05-13 18:04:17 +0200435 seq_puts(s, ",sec=");
Jeff Layton3e715512011-06-13 11:50:41 -0400436
Jeff Layton28e11bd2013-05-26 07:01:00 -0400437 switch (ses->sectype) {
Jeff Layton3e715512011-06-13 11:50:41 -0400438 case NTLMv2:
Fabian Frederick571d5972014-05-13 18:04:17 +0200439 seq_puts(s, "ntlmv2");
Jeff Layton3e715512011-06-13 11:50:41 -0400440 break;
Jeff Layton3e715512011-06-13 11:50:41 -0400441 case Kerberos:
Petr Pavlu3f6166a2020-02-10 10:38:14 +0100442 seq_puts(s, "krb5");
Jeff Layton3e715512011-06-13 11:50:41 -0400443 break;
444 case RawNTLMSSP:
Fabian Frederick571d5972014-05-13 18:04:17 +0200445 seq_puts(s, "ntlmssp");
Jeff Layton3e715512011-06-13 11:50:41 -0400446 break;
447 default:
448 /* shouldn't ever happen */
Fabian Frederick571d5972014-05-13 18:04:17 +0200449 seq_puts(s, "unknown");
Jeff Layton3e715512011-06-13 11:50:41 -0400450 break;
451 }
452
Jeff Layton28e11bd2013-05-26 07:01:00 -0400453 if (ses->sign)
Fabian Frederick571d5972014-05-13 18:04:17 +0200454 seq_puts(s, "i");
Petr Pavlu3f6166a2020-02-10 10:38:14 +0100455
456 if (ses->sectype == Kerberos)
457 seq_printf(s, ",cruid=%u",
458 from_kuid_munged(&init_user_ns, ses->cred_uid));
Jeff Layton3e715512011-06-13 11:50:41 -0400459}
460
Jeff Laytond06b5052012-05-16 07:53:01 -0400461static void
462cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
463{
Fabian Frederick571d5972014-05-13 18:04:17 +0200464 seq_puts(s, ",cache=");
Jeff Laytond06b5052012-05-16 07:53:01 -0400465
466 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
Fabian Frederick571d5972014-05-13 18:04:17 +0200467 seq_puts(s, "strict");
Jeff Laytond06b5052012-05-16 07:53:01 -0400468 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
Fabian Frederick571d5972014-05-13 18:04:17 +0200469 seq_puts(s, "none");
Steve French41e033f2019-08-30 02:12:41 -0500470 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
471 seq_puts(s, "singleclient"); /* assume only one client access */
Steve French83bbfa72019-08-27 23:58:54 -0500472 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
473 seq_puts(s, "ro"); /* read only caching assumed */
Jeff Laytond06b5052012-05-16 07:53:01 -0400474 else
Fabian Frederick571d5972014-05-13 18:04:17 +0200475 seq_puts(s, "loose");
Jeff Laytond06b5052012-05-16 07:53:01 -0400476}
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478/*
Steve French653a5ef2020-12-14 20:08:10 -0600479 * cifs_show_devname() is used so we show the mount device name with correct
480 * format (e.g. forward slashes vs. back slashes) in /proc/mounts
481 */
482static int cifs_show_devname(struct seq_file *m, struct dentry *root)
483{
484 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
Ronnie Sahlbergaf1a3d22021-02-11 16:06:16 +1000485 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
Steve French653a5ef2020-12-14 20:08:10 -0600486
487 if (devname == NULL)
488 seq_puts(m, "none");
489 else {
490 convert_delimiter(devname, '/');
Maciek Borzecki0fc93222021-04-06 17:02:29 +0200491 /* escape all spaces in share names */
492 seq_escape(m, devname, " \t");
Steve French653a5ef2020-12-14 20:08:10 -0600493 kfree(devname);
494 }
495 return 0;
496}
497
498/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 * cifs_show_options() is for displaying mount options in /proc/mounts.
500 * Not all settable options are displayed but most of the important
501 * ones are.
502 */
503static int
Al Viro34c80b12011-12-08 21:32:45 -0500504cifs_show_options(struct seq_file *s, struct dentry *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Al Viro34c80b12011-12-08 21:32:45 -0500506 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
Steve French96daf2b2011-05-27 04:34:02 +0000507 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
Ben Greear3eb9a882010-09-01 17:06:02 -0700508 struct sockaddr *srcaddr;
509 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Kees Cooka068acf2015-09-04 15:44:57 -0700511 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
Jeff Layton28e11bd2013-05-26 07:01:00 -0400512 cifs_show_security(s, tcon->ses);
Jeff Laytond06b5052012-05-16 07:53:01 -0400513 cifs_show_cache_flavor(s, cifs_sb);
Jeff Layton3e715512011-06-13 11:50:41 -0400514
Steve French3e7a02d2019-09-11 21:46:20 -0500515 if (tcon->no_lease)
516 seq_puts(s, ",nolease");
Ronnie Sahlberg9ccecae2020-12-14 16:40:19 +1000517 if (cifs_sb->ctx->multiuser)
Fabian Frederick571d5972014-05-13 18:04:17 +0200518 seq_puts(s, ",multiuser");
Steve French8727c8a2011-02-25 01:11:56 -0600519 else if (tcon->ses->user_name)
Kees Cooka068acf2015-09-04 15:44:57 -0700520 seq_show_option(s, "username", tcon->ses->user_name);
Jeff Layton29e07c82010-09-29 19:51:12 -0400521
Ronnie Sahlberge55954a2018-08-10 11:31:10 +1000522 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
Kees Cooka068acf2015-09-04 15:44:57 -0700523 seq_show_option(s, "domain", tcon->ses->domainName);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400524
Ben Greear3eb9a882010-09-01 17:06:02 -0700525 if (srcaddr->sa_family != AF_UNSPEC) {
526 struct sockaddr_in *saddr4;
527 struct sockaddr_in6 *saddr6;
528 saddr4 = (struct sockaddr_in *)srcaddr;
529 saddr6 = (struct sockaddr_in6 *)srcaddr;
530 if (srcaddr->sa_family == AF_INET6)
531 seq_printf(s, ",srcaddr=%pI6c",
532 &saddr6->sin6_addr);
533 else if (srcaddr->sa_family == AF_INET)
534 seq_printf(s, ",srcaddr=%pI4",
535 &saddr4->sin_addr.s_addr);
536 else
537 seq_printf(s, ",srcaddr=BAD-AF:%i",
538 (int)(srcaddr->sa_family));
539 }
540
Eric W. Biederman1f682332013-02-06 01:20:20 -0800541 seq_printf(s, ",uid=%u",
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600542 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
Jeff Layton340481a32009-06-11 10:27:29 -0400543 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
Fabian Frederick571d5972014-05-13 18:04:17 +0200544 seq_puts(s, ",forceuid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400545 else
Fabian Frederick571d5972014-05-13 18:04:17 +0200546 seq_puts(s, ",noforceuid");
Jeff Layton340481a32009-06-11 10:27:29 -0400547
Eric W. Biederman1f682332013-02-06 01:20:20 -0800548 seq_printf(s, ",gid=%u",
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600549 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
Jeff Layton340481a32009-06-11 10:27:29 -0400550 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
Fabian Frederick571d5972014-05-13 18:04:17 +0200551 seq_puts(s, ",forcegid");
Jeff Layton4486d6e2009-08-03 12:45:10 -0400552 else
Fabian Frederick571d5972014-05-13 18:04:17 +0200553 seq_puts(s, ",noforcegid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400554
Jeff Layton61f98ff2009-06-11 10:27:32 -0400555 cifs_show_address(s, tcon->ses->server);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400556
557 if (!tcon->unix_ext)
Al Viro5206efd2011-07-26 03:22:14 -0400558 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600559 cifs_sb->ctx->file_mode,
560 cifs_sb->ctx->dir_mode);
Ronnie Sahlberg7c7ee622020-12-14 16:40:22 +1000561 if (cifs_sb->ctx->iocharset)
562 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
Jeff Layton8616e0f2009-06-11 10:27:28 -0400563 if (tcon->seal)
Fabian Frederick571d5972014-05-13 18:04:17 +0200564 seq_puts(s, ",seal");
Steve Frenchec570102020-02-19 23:59:32 -0600565 else if (tcon->ses->server->ignore_signature)
566 seq_puts(s, ",signloosely");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400567 if (tcon->nocase)
Fabian Frederick571d5972014-05-13 18:04:17 +0200568 seq_puts(s, ",nocase");
Steve French82e93672020-05-19 03:06:57 -0500569 if (tcon->nodelete)
570 seq_puts(s, ",nodelete");
Kenneth D'souzac8b6ac12019-01-21 11:51:59 +1000571 if (tcon->local_lease)
572 seq_puts(s, ",locallease");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400573 if (tcon->retry)
Fabian Frederick571d5972014-05-13 18:04:17 +0200574 seq_puts(s, ",hard");
Ronnie Sahlberg6e82e922017-09-20 13:09:23 +1000575 else
576 seq_puts(s, ",soft");
Steve Frenchf16dfa72015-09-30 21:07:59 -0500577 if (tcon->use_persistent)
578 seq_puts(s, ",persistenthandles");
Steve French592fafe2015-11-03 10:08:53 -0600579 else if (tcon->use_resilient)
580 seq_puts(s, ",resilienthandles");
Steve Frenchb3266142018-05-20 23:41:10 -0500581 if (tcon->posix_extensions)
582 seq_puts(s, ",posix");
583 else if (tcon->unix_ext)
584 seq_puts(s, ",unix");
585 else
586 seq_puts(s, ",nounix");
Aurelien Aptel83930722018-09-20 18:10:25 -0700587 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
588 seq_puts(s, ",nodfs");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400589 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
Fabian Frederick571d5972014-05-13 18:04:17 +0200590 seq_puts(s, ",posixpaths");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400591 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
Fabian Frederick571d5972014-05-13 18:04:17 +0200592 seq_puts(s, ",setuids");
Steve French95932652016-09-23 01:36:34 -0500593 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
594 seq_puts(s, ",idsfromsid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400595 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
Fabian Frederick571d5972014-05-13 18:04:17 +0200596 seq_puts(s, ",serverino");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000597 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
Fabian Frederick571d5972014-05-13 18:04:17 +0200598 seq_puts(s, ",rwpidforward");
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000599 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
Fabian Frederick571d5972014-05-13 18:04:17 +0200600 seq_puts(s, ",forcemand");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400601 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
Fabian Frederick571d5972014-05-13 18:04:17 +0200602 seq_puts(s, ",nouser_xattr");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400603 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
Fabian Frederick571d5972014-05-13 18:04:17 +0200604 seq_puts(s, ",mapchars");
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +0900605 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
606 seq_puts(s, ",mapposix");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400607 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
Fabian Frederick571d5972014-05-13 18:04:17 +0200608 seq_puts(s, ",sfu");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400609 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
Fabian Frederick571d5972014-05-13 18:04:17 +0200610 seq_puts(s, ",nobrl");
Steve French3d4ef9a2018-04-25 22:19:09 -0500611 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
612 seq_puts(s, ",nohandlecache");
Steve French412094a2019-06-24 02:01:42 -0500613 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
614 seq_puts(s, ",modefromsid");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400615 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
Fabian Frederick571d5972014-05-13 18:04:17 +0200616 seq_puts(s, ",cifsacl");
Jeff Layton8616e0f2009-06-11 10:27:28 -0400617 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
Fabian Frederick571d5972014-05-13 18:04:17 +0200618 seq_puts(s, ",dynperm");
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800619 if (root->d_sb->s_flags & SB_POSIXACL)
Fabian Frederick571d5972014-05-13 18:04:17 +0200620 seq_puts(s, ",acl");
Stefan Metzmacher736a33202010-07-30 14:56:00 +0200621 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
Fabian Frederick571d5972014-05-13 18:04:17 +0200622 seq_puts(s, ",mfsymlinks");
Suresh Jayaraman476428f2010-11-24 17:49:07 +0530623 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
Fabian Frederick571d5972014-05-13 18:04:17 +0200624 seq_puts(s, ",fsc");
Steve French71c424b2011-10-19 20:44:48 -0500625 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
Fabian Frederick571d5972014-05-13 18:04:17 +0200626 seq_puts(s, ",nostrictsync");
Steve French71c424b2011-10-19 20:44:48 -0500627 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
Fabian Frederick571d5972014-05-13 18:04:17 +0200628 seq_puts(s, ",noperm");
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +0100629 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
Eric W. Biederman1f682332013-02-06 01:20:20 -0800630 seq_printf(s, ",backupuid=%u",
631 from_kuid_munged(&init_user_ns,
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600632 cifs_sb->ctx->backupuid));
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +0100633 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
Eric W. Biederman1f682332013-02-06 01:20:20 -0800634 seq_printf(s, ",backupgid=%u",
635 from_kgid_munged(&init_user_ns,
Ronnie Sahlberg8401e932020-12-12 13:40:50 -0600636 cifs_sb->ctx->backupgid));
Steve French2b280fa2008-05-17 03:12:45 +0000637
Steve French0c2b5f72020-12-15 13:28:50 -0600638 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
639 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
640 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
Steve Frenchb8d64f82021-04-24 21:46:23 -0500641 if (cifs_sb->ctx->rasize)
642 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
Steve French563317e2019-09-08 23:22:02 -0500643 if (tcon->ses->server->min_offload)
644 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600645 seq_printf(s, ",echo_interval=%lu",
646 tcon->ses->server->echo_interval / HZ);
Steve Frenchdc179262019-06-17 17:34:57 -0500647
648 /* Only display max_credits if it was overridden on mount */
649 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
650 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
651
Steve French8a69e962018-06-29 16:06:15 -0500652 if (tcon->snapshot_time)
653 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
Steve Frenchca567eb2019-03-29 16:31:07 -0500654 if (tcon->handle_timeout)
655 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
Steve French57804642021-02-24 12:12:53 -0600656
657 /*
658 * Display file and directory attribute timeout in seconds.
659 * If file and directory attribute timeout the same then actimeo
660 * was likely specified on mount
661 */
662 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
663 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
664 else {
665 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
666 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
667 }
Jeff Layton8616e0f2009-06-11 10:27:28 -0400668
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200669 if (tcon->ses->chan_max > 1)
Steve French7866c172020-06-09 19:50:40 -0500670 seq_printf(s, ",multichannel,max_channels=%zu",
Aurelien Aptelbcc88802019-09-20 04:32:20 +0200671 tcon->ses->chan_max);
672
Samuel Cabrero0ac4e292020-12-11 22:59:29 -0600673 if (tcon->use_witness)
674 seq_puts(s, ",witness");
Samuel Cabrero0ac4e292020-12-11 22:59:29 -0600675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return 0;
677}
678
Al Viro42faad92008-04-24 07:21:56 -0400679static void cifs_umount_begin(struct super_block *sb)
Steve French68058e72005-10-10 10:34:22 -0700680{
Al Viro42faad92008-04-24 07:21:56 -0400681 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve French96daf2b2011-05-27 04:34:02 +0000682 struct cifs_tcon *tcon;
Steve French68058e72005-10-10 10:34:22 -0700683
Steve French4523cc32007-04-30 20:13:06 +0000684 if (cifs_sb == NULL)
Steve French9e2e85f2005-10-10 14:28:38 -0700685 return;
686
Jeff Layton0d424ad2010-09-20 16:01:35 -0700687 tcon = cifs_sb_master_tcon(cifs_sb);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500688
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530689 spin_lock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000690 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
691 /* we have other mounts to same share or we have
692 already tried to force umount this and woken up
693 all waiting network requests, nothing to do */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530694 spin_unlock(&cifs_tcp_ses_lock);
Steve Frenchad8034f2009-06-26 03:25:49 +0000695 return;
696 } else if (tcon->tc_count == 1)
Steve French5e1253b2005-10-10 14:06:37 -0700697 tcon->tidStatus = CifsExiting;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530698 spin_unlock(&cifs_tcp_ses_lock);
Steve French5e1253b2005-10-10 14:06:37 -0700699
Steve French3a5ff612006-07-14 22:37:11 +0000700 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
Steve French7b7abfe2005-11-09 15:21:09 -0800701 /* cancel_notify_requests(tcon); */
Steve French50c2f752007-07-13 00:33:32 +0000702 if (tcon->ses && tcon->ses->server) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500703 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
Steve French9e2e85f2005-10-10 14:28:38 -0700704 wake_up_all(&tcon->ses->server->request_q);
Steve French6ab16d22005-11-29 20:55:11 -0800705 wake_up_all(&tcon->ses->server->response_q);
706 msleep(1); /* yield */
707 /* we have to kick the requests once more */
708 wake_up_all(&tcon->ses->server->response_q);
709 msleep(1);
Steve French5e1253b2005-10-10 14:06:37 -0700710 }
Steve French68058e72005-10-10 10:34:22 -0700711
712 return;
713}
Steve French68058e72005-10-10 10:34:22 -0700714
Steve Frenchbf97d282006-09-28 21:34:06 +0000715#ifdef CONFIG_CIFS_STATS2
Al Viro64132372011-12-08 20:51:13 -0500716static int cifs_show_stats(struct seq_file *s, struct dentry *root)
Steve Frenchbf97d282006-09-28 21:34:06 +0000717{
718 /* BB FIXME */
719 return 0;
720}
721#endif
722
Al Viro45321ac2010-06-07 13:43:19 -0400723static int cifs_drop_inode(struct inode *inode)
Jeff Layton12420ac2010-06-01 14:47:40 -0400724{
725 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
726
Al Viro45321ac2010-06-07 13:43:19 -0400727 /* no serverino => unconditional eviction */
728 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
729 generic_drop_inode(inode);
Jeff Layton12420ac2010-06-01 14:47:40 -0400730}
731
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800732static const struct super_operations cifs_super_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 .statfs = cifs_statfs,
734 .alloc_inode = cifs_alloc_inode,
Al Viroc2e68022019-04-14 23:18:35 -0400735 .free_inode = cifs_free_inode,
Jeff Layton12420ac2010-06-01 14:47:40 -0400736 .drop_inode = cifs_drop_inode,
Al Virob57922d2010-06-07 14:34:48 -0400737 .evict_inode = cifs_evict_inode,
Steve French653a5ef2020-12-14 20:08:10 -0600738/* .show_path = cifs_show_path, */ /* Would we ever need show path? */
739 .show_devname = cifs_show_devname,
Jeff Layton12420ac2010-06-01 14:47:40 -0400740/* .delete_inode = cifs_delete_inode, */ /* Do not need above
741 function unless later we add lazy close of inodes or unless the
Steve French50c2f752007-07-13 00:33:32 +0000742 kernel forgets to call us with the same number of releases (closes)
743 as opens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 .show_options = cifs_show_options,
Steve French7b7abfe2005-11-09 15:21:09 -0800745 .umount_begin = cifs_umount_begin,
Steve Frenchbf97d282006-09-28 21:34:06 +0000746#ifdef CONFIG_CIFS_STATS2
Steve Frenchf46d3e12006-09-30 01:08:55 +0000747 .show_stats = cifs_show_stats,
Steve Frenchbf97d282006-09-28 21:34:06 +0000748#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749};
750
Steve Frenchf87d39d2011-05-27 03:50:55 +0000751/*
752 * Get root dentry from superblock according to prefix path mount option.
753 * Return dentry with refcount + 1 on success and NULL otherwise.
754 */
755static struct dentry *
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600756cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
Steve Frenchf87d39d2011-05-27 03:50:55 +0000757{
Al Virofec11dd2011-07-18 13:50:40 -0400758 struct dentry *dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000759 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Al Virofec11dd2011-07-18 13:50:40 -0400760 char *full_path = NULL;
761 char *s, *p;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000762 char sep;
763
Sachin Prabhu348c1bf2016-07-29 22:38:21 +0100764 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
765 return dget(sb->s_root);
766
Ronnie Sahlberg3fa1c6d2020-12-09 23:07:12 -0600767 full_path = cifs_build_path_to_root(ctx, cifs_sb,
Sachin Prabhu374402a2016-12-15 12:31:19 +0530768 cifs_sb_master_tcon(cifs_sb), 0);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000769 if (full_path == NULL)
Al Viro9403c9c2011-06-17 10:02:59 -0400770 return ERR_PTR(-ENOMEM);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000771
Joe Perchesf96637b2013-05-04 22:12:25 -0500772 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
Steve Frenchf87d39d2011-05-27 03:50:55 +0000773
Steve Frenchf87d39d2011-05-27 03:50:55 +0000774 sep = CIFS_DIR_SEP(cifs_sb);
Al Virofec11dd2011-07-18 13:50:40 -0400775 dentry = dget(sb->s_root);
776 p = s = full_path;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000777
Al Virofec11dd2011-07-18 13:50:40 -0400778 do {
David Howells2b0143b2015-03-17 22:25:59 +0000779 struct inode *dir = d_inode(dentry);
Al Virofec11dd2011-07-18 13:50:40 -0400780 struct dentry *child;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000781
Jeff Laytonce2ac522013-02-01 15:11:01 -0500782 if (!S_ISDIR(dir->i_mode)) {
783 dput(dentry);
784 dentry = ERR_PTR(-ENOTDIR);
785 break;
786 }
Pavel Shilovsky5b980b02011-08-21 19:30:15 +0400787
Al Virofec11dd2011-07-18 13:50:40 -0400788 /* skip separators */
789 while (*s == sep)
790 s++;
791 if (!*s)
792 break;
793 p = s++;
794 /* next separator */
795 while (*s && *s != sep)
796 s++;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000797
Al Viro6c2d47982019-10-31 01:21:58 -0400798 child = lookup_positive_unlocked(p, dentry, s - p);
Al Virofec11dd2011-07-18 13:50:40 -0400799 dput(dentry);
800 dentry = child;
801 } while (!IS_ERR(dentry));
Steve Frenchf87d39d2011-05-27 03:50:55 +0000802 kfree(full_path);
Al Virofec11dd2011-07-18 13:50:40 -0400803 return dentry;
Steve Frenchf87d39d2011-05-27 03:50:55 +0000804}
805
Al Viroee01a142011-06-17 09:47:23 -0400806static int cifs_set_super(struct super_block *sb, void *data)
807{
808 struct cifs_mnt_data *mnt_data = data;
809 sb->s_fs_info = mnt_data->cifs_sb;
810 return set_anon_super(sb, NULL);
811}
812
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -0600813struct dentry *
Steve Frenchc7c137b2018-06-06 17:59:29 -0500814cifs_smb3_do_mount(struct file_system_type *fs_type,
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -0600815 int flags, struct smb3_fs_context *old_ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816{
817 int rc;
Jan Blunckdb719222010-08-15 22:51:10 +0200818 struct super_block *sb;
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000819 struct cifs_sb_info *cifs_sb = NULL;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400820 struct cifs_mnt_data mnt_data;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000821 struct dentry *root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Steve French8c1beb92018-10-07 13:52:18 -0500823 /*
824 * Prints in Kernel / CIFS log the attempted mount operation
825 * If CIFS_DEBUG && cifs_FYI
826 */
Rodrigo Freiref80eaed2018-10-07 12:21:26 -0300827 if (cifsFYI)
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -0600828 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
Rodrigo Freiref80eaed2018-10-07 12:21:26 -0300829 else
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -0600830 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000832 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
833 if (cifs_sb == NULL) {
834 root = ERR_PTR(-ENOMEM);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000835 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000836 }
837
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000838 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
839 if (!cifs_sb->ctx) {
Al Viro5d3bc602011-06-17 09:17:28 -0400840 root = ERR_PTR(-ENOMEM);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000841 goto out;
Al Viro5d3bc602011-06-17 09:17:28 -0400842 }
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000843 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
Sachin Prabhu4214ebf2016-07-29 22:38:19 +0100844 if (rc) {
845 root = ERR_PTR(rc);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000846 goto out;
Aurelien Aptela6b50582016-05-25 19:59:09 +0200847 }
848
Paulo Alcantara5c1acf32021-05-03 11:55:26 -0300849 rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000850 if (rc) {
851 root = ERR_PTR(rc);
852 goto out;
853 }
854
Ronnie Sahlberg51acd202020-12-14 16:40:24 +1000855 rc = cifs_setup_cifs_sb(cifs_sb);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000856 if (rc) {
857 root = ERR_PTR(rc);
858 goto out;
859 }
860
861 rc = cifs_mount(cifs_sb, cifs_sb->ctx);
Al Viro97d11522011-06-17 09:29:57 -0400862 if (rc) {
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800863 if (!(flags & SB_SILENT))
Joe Perchesf96637b2013-05-04 22:12:25 -0500864 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
865 rc);
Al Viro97d11522011-06-17 09:29:57 -0400866 root = ERR_PTR(rc);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000867 goto out;
Al Viro97d11522011-06-17 09:29:57 -0400868 }
869
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000870 mnt_data.ctx = cifs_sb->ctx;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400871 mnt_data.cifs_sb = cifs_sb;
872 mnt_data.flags = flags;
873
David Howells9249e172012-06-25 12:55:37 +0100874 /* BB should we make this contingent on mount parm? */
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800875 flags |= SB_NODIRATIME | SB_NOATIME;
David Howells9249e172012-06-25 12:55:37 +0100876
877 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000878 if (IS_ERR(sb)) {
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000879 root = ERR_CAST(sb);
Al Viro97d11522011-06-17 09:29:57 -0400880 cifs_umount(cifs_sb);
Ronnie Sahlberg6cf5abb2020-12-16 08:51:33 +1000881 cifs_sb = NULL;
Al Virod757d712011-06-17 09:42:43 -0400882 goto out;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000883 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
Al Viroee01a142011-06-17 09:47:23 -0400885 if (sb->s_root) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500886 cifs_dbg(FYI, "Use existing superblock\n");
Al Viro97d11522011-06-17 09:29:57 -0400887 cifs_umount(cifs_sb);
Ronnie Sahlberg6cf5abb2020-12-16 08:51:33 +1000888 cifs_sb = NULL;
Al Viro5c4f1ad2011-06-17 09:56:55 -0400889 } else {
Al Viro5c4f1ad2011-06-17 09:56:55 -0400890 rc = cifs_read_super(sb);
891 if (rc) {
892 root = ERR_PTR(rc);
893 goto out_super;
894 }
895
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800896 sb->s_flags |= SB_ACTIVE;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400897 }
898
Ronnie Sahlberg6cf5abb2020-12-16 08:51:33 +1000899 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
Al Viro9403c9c2011-06-17 10:02:59 -0400900 if (IS_ERR(root))
Al Virofa18f1b2011-06-17 09:50:44 -0400901 goto out_super;
Al Virofa18f1b2011-06-17 09:50:44 -0400902
Ronnie Sahlberg269f67e2021-03-09 09:07:30 +1000903 if (cifs_sb)
904 cifs_sb->root = dget(root);
905
Joe Perchesf96637b2013-05-04 22:12:25 -0500906 cifs_dbg(FYI, "dentry root is: %p\n", root);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000907 return root;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +0400908
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400909out_super:
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400910 deactivate_locked_super(sb);
Pavel Shilovsky641a58d2011-05-26 00:02:16 +0400911out:
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000912 if (cifs_sb) {
913 kfree(cifs_sb->prepath);
Ronnie Sahlbergc741cba2020-12-14 16:40:16 +1000914 smb3_cleanup_fs_context(cifs_sb->ctx);
Ronnie Sahlbergd17abdf72020-11-10 08:59:26 +1000915 kfree(cifs_sb);
916 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +0000917 return root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918}
919
Steve Frenchc7c137b2018-06-06 17:59:29 -0500920
Jeff Layton08bc0352014-05-23 06:50:21 -0400921static ssize_t
922cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
923{
924 ssize_t rc;
925 struct inode *inode = file_inode(iocb->ki_filp);
926
Ross Lagerwall882137c2015-12-02 14:46:07 +0000927 if (iocb->ki_filp->f_flags & O_DIRECT)
928 return cifs_user_readv(iocb, iter);
929
Jeff Layton08bc0352014-05-23 06:50:21 -0400930 rc = cifs_revalidate_mapping(inode);
931 if (rc)
932 return rc;
933
934 return generic_file_read_iter(iocb, iter);
935}
936
Al Viro3dae8752014-04-03 12:05:17 -0400937static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
Steve French87c89dd2005-11-17 17:03:00 -0800938{
Al Viro496ad9a2013-01-23 17:07:38 -0500939 struct inode *inode = file_inode(iocb->ki_filp);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000940 struct cifsInodeInfo *cinode = CIFS_I(inode);
Steve French87c89dd2005-11-17 17:03:00 -0800941 ssize_t written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500942 int rc;
Steve French87c89dd2005-11-17 17:03:00 -0800943
Ross Lagerwall882137c2015-12-02 14:46:07 +0000944 if (iocb->ki_filp->f_flags & O_DIRECT) {
945 written = cifs_user_writev(iocb, from);
946 if (written > 0 && CIFS_CACHE_READ(cinode)) {
947 cifs_zap_mapping(inode);
948 cifs_dbg(FYI,
949 "Set no oplock for inode=%p after a write operation\n",
950 inode);
951 cinode->oplock = 0;
952 }
953 return written;
954 }
955
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000956 written = cifs_get_writer(cinode);
957 if (written)
958 return written;
959
Al Viro3dae8752014-04-03 12:05:17 -0400960 written = generic_file_write_iter(iocb, from);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500961
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400962 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000963 goto out;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500964
965 rc = filemap_fdatawrite(inode->i_mapping);
966 if (rc)
Al Viro3dae8752014-04-03 12:05:17 -0400967 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
Joe Perchesf96637b2013-05-04 22:12:25 -0500968 rc, inode);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -0500969
Sachin Prabhuc11f1df2014-03-11 16:11:47 +0000970out:
971 cifs_put_writer(cinode);
Steve French87c89dd2005-11-17 17:03:00 -0800972 return written;
973}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974
Andrew Morton965c8e52012-12-17 15:59:39 -0800975static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
Steve Frenchc32a0b62006-01-12 14:41:28 -0800976{
Ronnie Sahlbergdece44e2019-05-15 07:17:02 +1000977 struct cifsFileInfo *cfile = file->private_data;
978 struct cifs_tcon *tcon;
979
Josef Bacik06222e42011-07-18 13:21:38 -0400980 /*
Andrew Morton965c8e52012-12-17 15:59:39 -0800981 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
Josef Bacik06222e42011-07-18 13:21:38 -0400982 * the cached file length
983 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800984 if (whence != SEEK_SET && whence != SEEK_CUR) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400985 int rc;
Al Viro496ad9a2013-01-23 17:07:38 -0500986 struct inode *inode = file_inode(file);
Steve French030e9d82007-02-01 04:27:59 +0000987
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400988 /*
989 * We need to be sure that all dirty pages are written and the
990 * server has the newest file length.
991 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +0400992 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400993 inode->i_mapping->nrpages != 0) {
994 rc = filemap_fdatawait(inode->i_mapping);
Steve French156ecb22011-05-20 17:00:01 +0000995 if (rc) {
996 mapping_set_error(inode->i_mapping, rc);
997 return rc;
998 }
Pavel Shilovsky6feb9892011-04-07 18:18:11 +0400999 }
1000 /*
1001 * Some applications poll for the file length in this strange
1002 * way so we must seek to end on non-oplocked files by
1003 * setting the revalidate time to zero.
1004 */
1005 CIFS_I(inode)->time = 0;
Steve French030e9d82007-02-01 04:27:59 +00001006
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001007 rc = cifs_revalidate_file_attr(file);
1008 if (rc < 0)
1009 return (loff_t)rc;
Steve Frenchc32a0b62006-01-12 14:41:28 -08001010 }
Ronnie Sahlbergdece44e2019-05-15 07:17:02 +10001011 if (cfile && cfile->tlink) {
1012 tcon = tlink_tcon(cfile->tlink);
1013 if (tcon->ses->server->ops->llseek)
1014 return tcon->ses->server->ops->llseek(file, tcon,
1015 offset, whence);
1016 }
Andrew Morton965c8e52012-12-17 15:59:39 -08001017 return generic_file_llseek(file, offset, whence);
Steve Frenchc32a0b62006-01-12 14:41:28 -08001018}
1019
Jeff Laytone6f5c782014-08-22 10:40:25 -04001020static int
1021cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
Steve French84210e92008-10-23 04:42:37 +00001022{
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001023 /*
1024 * Note that this is called by vfs setlease with i_lock held to
1025 * protect *lease from going away.
1026 */
Al Viro496ad9a2013-01-23 17:07:38 -05001027 struct inode *inode = file_inode(file);
Jeff Laytonba00ba642010-09-20 16:01:31 -07001028 struct cifsFileInfo *cfile = file->private_data;
Steve French84210e92008-10-23 04:42:37 +00001029
1030 if (!(S_ISREG(inode->i_mode)))
1031 return -EINVAL;
1032
Jeff Layton02440802014-08-09 10:16:44 -04001033 /* Check if file is oplocked if this is request for new lease */
1034 if (arg == F_UNLCK ||
1035 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001036 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
Jeff Laytone6f5c782014-08-22 10:40:25 -04001037 return generic_setlease(file, arg, lease, priv);
Jeff Layton13cfb732010-09-29 19:51:11 -04001038 else if (tlink_tcon(cfile->tlink)->local_lease &&
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001039 !CIFS_CACHE_READ(CIFS_I(inode)))
1040 /*
1041 * If the server claims to support oplock on this file, then we
1042 * still need to check oplock even if the local_lease mount
1043 * option is set, but there are servers which do not support
1044 * oplock for which this mount option may be useful if the user
1045 * knows that the file won't be changed on the server by anyone
1046 * else.
1047 */
Jeff Laytone6f5c782014-08-22 10:40:25 -04001048 return generic_setlease(file, arg, lease, priv);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -04001049 else
Steve French84210e92008-10-23 04:42:37 +00001050 return -EAGAIN;
1051}
Steve French84210e92008-10-23 04:42:37 +00001052
Igor Mammedove6ab1582008-01-11 01:49:48 +00001053struct file_system_type cifs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 .owner = THIS_MODULE,
1055 .name = "cifs",
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -06001056 .init_fs_context = smb3_init_fs_context,
1057 .parameters = smb3_fs_parameters,
Al Viro6d686172011-06-17 08:34:57 -04001058 .kill_sb = cifs_kill_sb,
Steve Frenchc7e9f782020-02-25 18:08:54 -06001059 .fs_flags = FS_RENAME_DOES_D_MOVE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060};
Eric W. Biederman3e64fe52013-03-11 07:05:42 -07001061MODULE_ALIAS_FS("cifs");
Steve French49218b42018-05-23 21:44:53 -05001062
1063static struct file_system_type smb3_fs_type = {
1064 .owner = THIS_MODULE,
1065 .name = "smb3",
Ronnie Sahlberg24e0a1e2020-12-10 00:06:02 -06001066 .init_fs_context = smb3_init_fs_context,
1067 .parameters = smb3_fs_parameters,
Steve French49218b42018-05-23 21:44:53 -05001068 .kill_sb = cifs_kill_sb,
Steve Frenchc7e9f782020-02-25 18:08:54 -06001069 .fs_flags = FS_RENAME_DOES_D_MOVE,
Steve French49218b42018-05-23 21:44:53 -05001070};
1071MODULE_ALIAS_FS("smb3");
1072MODULE_ALIAS("smb3");
1073
Arjan van de Ven754661f2007-02-12 00:55:38 -08001074const struct inode_operations cifs_dir_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 .create = cifs_create,
Miklos Szeredid2c12712012-06-05 15:10:23 +02001076 .atomic_open = cifs_atomic_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 .lookup = cifs_lookup,
1078 .getattr = cifs_getattr,
1079 .unlink = cifs_unlink,
1080 .link = cifs_hardlink,
1081 .mkdir = cifs_mkdir,
1082 .rmdir = cifs_rmdir,
Miklos Szeredi2773bf02016-09-27 11:03:58 +02001083 .rename = cifs_rename2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 .permission = cifs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 .setattr = cifs_setattr,
1086 .symlink = cifs_symlink,
1087 .mknod = cifs_mknod,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 .listxattr = cifs_listxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089};
1090
Arjan van de Ven754661f2007-02-12 00:55:38 -08001091const struct inode_operations cifs_file_inode_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 .setattr = cifs_setattr,
Steve French48a77aa2016-05-18 20:48:32 -05001093 .getattr = cifs_getattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 .permission = cifs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 .listxattr = cifs_listxattr,
Ronnie Sahlberg2f3ebab2019-04-25 16:45:29 +10001096 .fiemap = cifs_fiemap,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097};
1098
Arjan van de Ven754661f2007-02-12 00:55:38 -08001099const struct inode_operations cifs_symlink_inode_ops = {
Al Viro6b255392015-11-17 10:20:54 -05001100 .get_link = cifs_get_link,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 .permission = cifs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 .listxattr = cifs_listxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103};
1104
Darrick J. Wong42ec3d42018-10-30 10:41:49 +11001105static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1106 struct file *dst_file, loff_t destoff, loff_t len,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001107 unsigned int remap_flags)
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001108{
1109 struct inode *src_inode = file_inode(src_file);
1110 struct inode *target_inode = file_inode(dst_file);
1111 struct cifsFileInfo *smb_file_src = src_file->private_data;
Colin Ian King8c6c9bed82018-11-01 13:14:30 +00001112 struct cifsFileInfo *smb_file_target;
1113 struct cifs_tcon *target_tcon;
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001114 unsigned int xid;
1115 int rc;
1116
Xiaoli Fengb073a082019-03-16 12:11:54 +08001117 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001118 return -EINVAL;
1119
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001120 cifs_dbg(FYI, "clone range\n");
1121
1122 xid = get_xid();
1123
1124 if (!src_file->private_data || !dst_file->private_data) {
1125 rc = -EBADF;
1126 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1127 goto out;
1128 }
1129
Colin Ian King8c6c9bed82018-11-01 13:14:30 +00001130 smb_file_target = dst_file->private_data;
1131 target_tcon = tlink_tcon(smb_file_target->tlink);
1132
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001133 /*
1134 * Note: cifs case is easier than btrfs since server responsible for
1135 * checks for proper open modes and file type and if it wants
1136 * server could even support copy of range where source = target
1137 */
1138 lock_two_nondirectories(target_inode, src_inode);
1139
1140 if (len == 0)
1141 len = src_inode->i_size - off;
1142
1143 cifs_dbg(FYI, "about to flush pages\n");
1144 /* should we flush first and last page first */
1145 truncate_inode_pages_range(&target_inode->i_data, destoff,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001146 PAGE_ALIGN(destoff + len)-1);
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001147
1148 if (target_tcon->ses->server->ops->duplicate_extents)
1149 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1150 smb_file_src, smb_file_target, off, len, destoff);
1151 else
1152 rc = -EOPNOTSUPP;
1153
1154 /* force revalidate of size and timestamps of target file now
1155 that target is updated on the server */
1156 CIFS_I(target_inode)->time = 0;
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001157 /* although unlocking in the reverse order from locking is not
1158 strictly necessary here it is a little cleaner to be consistent */
1159 unlock_two_nondirectories(src_inode, target_inode);
1160out:
1161 free_xid(xid);
Darrick J. Wong42ec3d42018-10-30 10:41:49 +11001162 return rc < 0 ? rc : len;
Christoph Hellwig04b38d62015-12-03 12:59:50 +01001163}
1164
Sachin Prabhu620d8742017-02-10 16:03:51 +05301165ssize_t cifs_file_copychunk_range(unsigned int xid,
1166 struct file *src_file, loff_t off,
1167 struct file *dst_file, loff_t destoff,
1168 size_t len, unsigned int flags)
1169{
1170 struct inode *src_inode = file_inode(src_file);
1171 struct inode *target_inode = file_inode(dst_file);
1172 struct cifsFileInfo *smb_file_src;
1173 struct cifsFileInfo *smb_file_target;
1174 struct cifs_tcon *src_tcon;
1175 struct cifs_tcon *target_tcon;
1176 ssize_t rc;
1177
1178 cifs_dbg(FYI, "copychunk range\n");
1179
Sachin Prabhu620d8742017-02-10 16:03:51 +05301180 if (!src_file->private_data || !dst_file->private_data) {
1181 rc = -EBADF;
1182 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1183 goto out;
1184 }
1185
1186 rc = -EXDEV;
1187 smb_file_target = dst_file->private_data;
1188 smb_file_src = src_file->private_data;
1189 src_tcon = tlink_tcon(smb_file_src->tlink);
1190 target_tcon = tlink_tcon(smb_file_target->tlink);
1191
1192 if (src_tcon->ses != target_tcon->ses) {
1193 cifs_dbg(VFS, "source and target of copy not on same server\n");
1194 goto out;
1195 }
1196
Amir Goldsteinbf3c90e2019-06-10 20:36:57 +03001197 rc = -EOPNOTSUPP;
1198 if (!target_tcon->ses->server->ops->copychunk_range)
1199 goto out;
1200
Sachin Prabhu620d8742017-02-10 16:03:51 +05301201 /*
1202 * Note: cifs case is easier than btrfs since server responsible for
1203 * checks for proper open modes and file type and if it wants
1204 * server could even support copy of range where source = target
1205 */
1206 lock_two_nondirectories(target_inode, src_inode);
1207
1208 cifs_dbg(FYI, "about to flush pages\n");
1209 /* should we flush first and last page first */
1210 truncate_inode_pages(&target_inode->i_data, 0);
1211
Amir Goldsteinbf3c90e2019-06-10 20:36:57 +03001212 rc = file_modified(dst_file);
1213 if (!rc)
Sachin Prabhu620d8742017-02-10 16:03:51 +05301214 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1215 smb_file_src, smb_file_target, off, len, destoff);
Amir Goldsteinbf3c90e2019-06-10 20:36:57 +03001216
1217 file_accessed(src_file);
Sachin Prabhu620d8742017-02-10 16:03:51 +05301218
1219 /* force revalidate of size and timestamps of target file now
1220 * that target is updated on the server
1221 */
1222 CIFS_I(target_inode)->time = 0;
1223 /* although unlocking in the reverse order from locking is not
1224 * strictly necessary here it is a little cleaner to be consistent
1225 */
1226 unlock_two_nondirectories(src_inode, target_inode);
1227
1228out:
1229 return rc;
1230}
1231
Steve French6e70c262018-05-10 10:59:37 -05001232/*
1233 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1234 * is a dummy operation.
1235 */
1236static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1237{
1238 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1239 file, datasync);
1240
1241 return 0;
1242}
1243
Sachin Prabhu620d8742017-02-10 16:03:51 +05301244static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1245 struct file *dst_file, loff_t destoff,
1246 size_t len, unsigned int flags)
1247{
1248 unsigned int xid = get_xid();
1249 ssize_t rc;
Steve French4e8aea32020-04-09 21:42:18 -05001250 struct cifsFileInfo *cfile = dst_file->private_data;
1251
1252 if (cfile->swapfile)
1253 return -EOPNOTSUPP;
Sachin Prabhu620d8742017-02-10 16:03:51 +05301254
1255 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1256 len, flags);
1257 free_xid(xid);
Dave Chinner64bf5ff2019-06-05 08:04:47 -07001258
Amir Goldstein5dae2222019-06-05 08:04:50 -07001259 if (rc == -EOPNOTSUPP || rc == -EXDEV)
Dave Chinner64bf5ff2019-06-05 08:04:47 -07001260 rc = generic_copy_file_range(src_file, off, dst_file,
1261 destoff, len, flags);
Sachin Prabhu620d8742017-02-10 16:03:51 +05301262 return rc;
1263}
1264
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001265const struct file_operations cifs_file_ops = {
Jeff Layton08bc0352014-05-23 06:50:21 -04001266 .read_iter = cifs_loose_read_iter,
Al Viro3dae8752014-04-03 12:05:17 -04001267 .write_iter = cifs_file_write_iter,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 .open = cifs_open,
1269 .release = cifs_close,
1270 .lock = cifs_lock,
Steve Frenchd0677992019-07-16 18:55:38 -05001271 .flock = cifs_flock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 .fsync = cifs_fsync,
1273 .flush = cifs_flush,
1274 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001275 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001276 .splice_write = iter_file_splice_write,
Steve Frenchc32a0b62006-01-12 14:41:28 -08001277 .llseek = cifs_llseek,
Steve Frenchf9ddcca2008-05-15 05:51:55 +00001278 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301279 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001280 .remap_file_range = cifs_remap_file_range,
Steve French84210e92008-10-23 04:42:37 +00001281 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001282 .fallocate = cifs_fallocate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283};
1284
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001285const struct file_operations cifs_file_strict_ops = {
Al Viroe6a7bcb2014-04-02 19:53:36 -04001286 .read_iter = cifs_strict_readv,
Al Viro3dae8752014-04-03 12:05:17 -04001287 .write_iter = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001288 .open = cifs_open,
1289 .release = cifs_close,
1290 .lock = cifs_lock,
Steve Frenchd0677992019-07-16 18:55:38 -05001291 .flock = cifs_flock,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001292 .fsync = cifs_strict_fsync,
1293 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03001294 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001295 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001296 .splice_write = iter_file_splice_write,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001297 .llseek = cifs_llseek,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001298 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301299 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001300 .remap_file_range = cifs_remap_file_range,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001301 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001302 .fallocate = cifs_fallocate,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001303};
1304
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001305const struct file_operations cifs_file_direct_ops = {
Long Libe4eb682018-10-31 22:13:11 +00001306 .read_iter = cifs_direct_readv,
1307 .write_iter = cifs_direct_writev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 .open = cifs_open,
1309 .release = cifs_close,
1310 .lock = cifs_lock,
Steve Frenchd0677992019-07-16 18:55:38 -05001311 .flock = cifs_flock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 .fsync = cifs_fsync,
1313 .flush = cifs_flush,
Steve Frencha994b8f2009-12-07 05:44:46 +00001314 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001315 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001316 .splice_write = iter_file_splice_write,
Steve Frenchf9ddcca2008-05-15 05:51:55 +00001317 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301318 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001319 .remap_file_range = cifs_remap_file_range,
Steve Frenchc32a0b62006-01-12 14:41:28 -08001320 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +00001321 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001322 .fallocate = cifs_fallocate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323};
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001324
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001325const struct file_operations cifs_file_nobrl_ops = {
Jeff Layton08bc0352014-05-23 06:50:21 -04001326 .read_iter = cifs_loose_read_iter,
Al Viro3dae8752014-04-03 12:05:17 -04001327 .write_iter = cifs_file_write_iter,
Steve French87c89dd2005-11-17 17:03:00 -08001328 .open = cifs_open,
1329 .release = cifs_close,
1330 .fsync = cifs_fsync,
1331 .flush = cifs_flush,
1332 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001333 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001334 .splice_write = iter_file_splice_write,
Steve Frenchc32a0b62006-01-12 14:41:28 -08001335 .llseek = cifs_llseek,
Steve Frenchf9ddcca2008-05-15 05:51:55 +00001336 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301337 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001338 .remap_file_range = cifs_remap_file_range,
Steve French84210e92008-10-23 04:42:37 +00001339 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001340 .fallocate = cifs_fallocate,
Steve French8b94bcb2005-11-11 11:41:00 -08001341};
1342
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001343const struct file_operations cifs_file_strict_nobrl_ops = {
Al Viroe6a7bcb2014-04-02 19:53:36 -04001344 .read_iter = cifs_strict_readv,
Al Viro3dae8752014-04-03 12:05:17 -04001345 .write_iter = cifs_strict_writev,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001346 .open = cifs_open,
1347 .release = cifs_close,
1348 .fsync = cifs_strict_fsync,
1349 .flush = cifs_flush,
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03001350 .mmap = cifs_file_strict_mmap,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001351 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001352 .splice_write = iter_file_splice_write,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001353 .llseek = cifs_llseek,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001354 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301355 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001356 .remap_file_range = cifs_remap_file_range,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001357 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001358 .fallocate = cifs_fallocate,
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001359};
1360
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001361const struct file_operations cifs_file_direct_nobrl_ops = {
Long Libe4eb682018-10-31 22:13:11 +00001362 .read_iter = cifs_direct_readv,
1363 .write_iter = cifs_direct_writev,
Steve French87c89dd2005-11-17 17:03:00 -08001364 .open = cifs_open,
1365 .release = cifs_close,
1366 .fsync = cifs_fsync,
1367 .flush = cifs_flush,
Pavel Shilovsky810627a02010-03-27 02:00:49 +00001368 .mmap = cifs_file_mmap,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001369 .splice_read = generic_file_splice_read,
Andrés Soutocd1aca22017-12-28 14:23:08 +01001370 .splice_write = iter_file_splice_write,
Steve Frenchf9ddcca2008-05-15 05:51:55 +00001371 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301372 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001373 .remap_file_range = cifs_remap_file_range,
Steve Frenchc32a0b62006-01-12 14:41:28 -08001374 .llseek = cifs_llseek,
Steve French84210e92008-10-23 04:42:37 +00001375 .setlease = cifs_setlease,
Steve French31742c52014-08-17 08:38:47 -05001376 .fallocate = cifs_fallocate,
Steve French8b94bcb2005-11-11 11:41:00 -08001377};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001379const struct file_operations cifs_dir_ops = {
Al Viro3125d262016-04-20 17:40:47 -04001380 .iterate_shared = cifs_readdir,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 .release = cifs_closedir,
1382 .read = generic_read_dir,
Steve Frenchf9ddcca2008-05-15 05:51:55 +00001383 .unlocked_ioctl = cifs_ioctl,
Sachin Prabhu620d8742017-02-10 16:03:51 +05301384 .copy_file_range = cifs_copy_file_range,
Darrick J. Wong2e5dfc92018-10-30 10:41:21 +11001385 .remap_file_range = cifs_remap_file_range,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +02001386 .llseek = generic_file_llseek,
Steve French6e70c262018-05-10 10:59:37 -05001387 .fsync = cifs_dir_fsync,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388};
1389
1390static void
Alexey Dobriyan51cc5062008-07-25 19:45:34 -07001391cifs_init_once(void *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392{
1393 struct cifsInodeInfo *cifsi = inode;
1394
Christoph Lametera35afb82007-05-16 22:10:57 -07001395 inode_init_once(&cifsi->vfs_inode);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001396 init_rwsem(&cifsi->lock_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
1398
Fabian Frederick9ee108b2014-04-03 14:46:30 -07001399static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400cifs_init_inodecache(void)
1401{
1402 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
Steve French26f57362007-08-30 22:09:15 +00001403 sizeof(struct cifsInodeInfo),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08001404 0, (SLAB_RECLAIM_ACCOUNT|
Vladimir Davydov5d097052016-01-14 15:18:21 -08001405 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
Paul Mundt20c2df82007-07-20 10:11:58 +09001406 cifs_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 if (cifs_inode_cachep == NULL)
1408 return -ENOMEM;
1409
1410 return 0;
1411}
1412
1413static void
1414cifs_destroy_inodecache(void)
1415{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001416 /*
1417 * Make sure all delayed rcu free inodes are flushed before we
1418 * destroy cache.
1419 */
1420 rcu_barrier();
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001421 kmem_cache_destroy(cifs_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422}
1423
1424static int
1425cifs_init_request_bufs(void)
1426{
Pavel Shilovsky3792c172012-01-12 22:40:50 +04001427 /*
1428 * SMB2 maximum header size is bigger than CIFS one - no problems to
1429 * allocate some more bytes for CIFS.
1430 */
Steve French2a38e122017-07-08 18:48:15 -05001431 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1432
Steve French4523cc32007-04-30 20:13:06 +00001433 if (CIFSMaxBufSize < 8192) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1435 Unicode path name has to fit in any SMB/CIFS path based frames */
1436 CIFSMaxBufSize = 8192;
1437 } else if (CIFSMaxBufSize > 1024*127) {
1438 CIFSMaxBufSize = 1024 * 127;
1439 } else {
1440 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1441 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001442/*
1443 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1444 CIFSMaxBufSize, CIFSMaxBufSize);
1445*/
David Windsorde046442017-06-10 22:50:33 -04001446 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
Pavel Shilovsky3792c172012-01-12 22:40:50 +04001447 CIFSMaxBufSize + max_hdr_size, 0,
David Windsorde046442017-06-10 22:50:33 -04001448 SLAB_HWCACHE_ALIGN, 0,
1449 CIFSMaxBufSize + max_hdr_size,
1450 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 if (cifs_req_cachep == NULL)
1452 return -ENOMEM;
1453
Steve French4523cc32007-04-30 20:13:06 +00001454 if (cifs_min_rcv < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 cifs_min_rcv = 1;
1456 else if (cifs_min_rcv > 64) {
1457 cifs_min_rcv = 64;
Joe Perchesf96637b2013-05-04 22:12:25 -05001458 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 }
1460
Matthew Dobson93d23412006-03-26 01:37:50 -08001461 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1462 cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463
Steve French4523cc32007-04-30 20:13:06 +00001464 if (cifs_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 kmem_cache_destroy(cifs_req_cachep);
1466 return -ENOMEM;
1467 }
Steve Frenchec637e32005-12-12 20:53:18 -08001468 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 almost all handle based requests (but not write response, nor is it
1470 sufficient for path based requests). A smaller size would have
Steve French50c2f752007-07-13 00:33:32 +00001471 been more efficient (compacting multiple slab items on one 4k page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 for the case in which debug was on, but this larger size allows
1473 more SMBs to use small buffer alloc and is still much more
Steve French6dc0f872007-07-06 23:13:06 +00001474 efficient to alloc 1 per page off the slab compared to 17K (5page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 alloc of large cifs buffers even when page debugging is on */
David Windsorde046442017-06-10 22:50:33 -04001476 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
Steve French6dc0f872007-07-06 23:13:06 +00001477 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
David Windsorde046442017-06-10 22:50:33 -04001478 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (cifs_sm_req_cachep == NULL) {
1480 mempool_destroy(cifs_req_poolp);
1481 kmem_cache_destroy(cifs_req_cachep);
Steve French6dc0f872007-07-06 23:13:06 +00001482 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 }
1484
Steve French4523cc32007-04-30 20:13:06 +00001485 if (cifs_min_small < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 cifs_min_small = 2;
1487 else if (cifs_min_small > 256) {
1488 cifs_min_small = 256;
Joe Perchesf96637b2013-05-04 22:12:25 -05001489 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 }
1491
Matthew Dobson93d23412006-03-26 01:37:50 -08001492 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1493 cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Steve French4523cc32007-04-30 20:13:06 +00001495 if (cifs_sm_req_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 mempool_destroy(cifs_req_poolp);
1497 kmem_cache_destroy(cifs_req_cachep);
1498 kmem_cache_destroy(cifs_sm_req_cachep);
1499 return -ENOMEM;
1500 }
1501
1502 return 0;
1503}
1504
1505static void
1506cifs_destroy_request_bufs(void)
1507{
1508 mempool_destroy(cifs_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001509 kmem_cache_destroy(cifs_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 mempool_destroy(cifs_sm_req_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001511 kmem_cache_destroy(cifs_sm_req_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512}
1513
1514static int
1515cifs_init_mids(void)
1516{
1517 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
Steve French26f57362007-08-30 22:09:15 +00001518 sizeof(struct mid_q_entry), 0,
1519 SLAB_HWCACHE_ALIGN, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 if (cifs_mid_cachep == NULL)
1521 return -ENOMEM;
1522
Matthew Dobson93d23412006-03-26 01:37:50 -08001523 /* 3 is a reasonable minimum number of simultaneous operations */
1524 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
Steve French4523cc32007-04-30 20:13:06 +00001525 if (cifs_mid_poolp == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 kmem_cache_destroy(cifs_mid_cachep);
1527 return -ENOMEM;
1528 }
1529
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 return 0;
1531}
1532
1533static void
1534cifs_destroy_mids(void)
1535{
1536 mempool_destroy(cifs_mid_poolp);
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001537 kmem_cache_destroy(cifs_mid_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538}
1539
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540static int __init
1541init_cifs(void)
1542{
1543 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 cifs_proc_init();
Jeff Laytone7ddee92008-11-14 13:44:38 -05001545 INIT_LIST_HEAD(&cifs_tcp_ses_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546/*
1547 * Initialize Global counters
1548 */
1549 atomic_set(&sesInfoAllocCount, 0);
1550 atomic_set(&tconInfoAllocCount, 0);
Shyam Prasad N6d82c272021-02-03 23:20:46 -08001551 atomic_set(&tcpSesNextId, 0);
Steve French6dc0f872007-07-06 23:13:06 +00001552 atomic_set(&tcpSesAllocCount, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 atomic_set(&tcpSesReconnectCount, 0);
1554 atomic_set(&tconInfoReconnectCount, 0);
1555
1556 atomic_set(&bufAllocCount, 0);
Steve French4498eed52005-12-03 13:58:57 -08001557 atomic_set(&smBufAllocCount, 0);
1558#ifdef CONFIG_CIFS_STATS2
1559 atomic_set(&totBufAllocCount, 0);
1560 atomic_set(&totSmBufAllocCount, 0);
Steve French00778e22018-09-18 14:05:18 -05001561 if (slow_rsp_threshold < 1)
1562 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1563 else if (slow_rsp_threshold > 32767)
1564 cifs_dbg(VFS,
1565 "slow response threshold set higher than recommended (0 to 32767)\n");
Steve French4498eed52005-12-03 13:58:57 -08001566#endif /* CONFIG_CIFS_STATS2 */
1567
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 atomic_set(&midCount, 0);
1569 GlobalCurrentXid = 0;
1570 GlobalTotalActiveXid = 0;
1571 GlobalMaxActiveXid = 0;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05301572 spin_lock_init(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 spin_lock_init(&GlobalMid_Lock);
1574
Jason A. Donenfeld51b08172017-06-07 20:42:50 -04001575 cifs_lock_secret = get_random_u32();
Jeff Layton3d224622016-05-24 06:27:44 -04001576
Steve French4523cc32007-04-30 20:13:06 +00001577 if (cifs_max_pending < 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 cifs_max_pending = 2;
Joe Perchesf96637b2013-05-04 22:12:25 -05001579 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
Pavel Shilovsky10b9b982012-03-20 12:55:09 +03001580 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1581 cifs_max_pending = CIFS_MAX_REQ;
Joe Perchesf96637b2013-05-04 22:12:25 -05001582 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1583 CIFS_MAX_REQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585
Jeff Laytonda472fc2012-03-23 14:40:53 -04001586 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1587 if (!cifsiod_wq) {
1588 rc = -ENOMEM;
1589 goto out_clean_proc;
1590 }
1591
Steve French35cf94a2019-09-07 01:09:49 -05001592 /*
Steve French10328c42019-09-09 13:30:15 -05001593 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1594 * so that we don't launch too many worker threads but
Mauro Carvalho Chehab0ac624f2019-09-24 10:01:28 -03001595 * Documentation/core-api/workqueue.rst recommends setting it to 0
Steve French35cf94a2019-09-07 01:09:49 -05001596 */
Steve French10328c42019-09-09 13:30:15 -05001597
1598 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
Steve French35cf94a2019-09-07 01:09:49 -05001599 decrypt_wq = alloc_workqueue("smb3decryptd",
Steve French10328c42019-09-09 13:30:15 -05001600 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
Steve French35cf94a2019-09-07 01:09:49 -05001601 if (!decrypt_wq) {
1602 rc = -ENOMEM;
1603 goto out_destroy_cifsiod_wq;
1604 }
1605
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001606 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1607 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1608 if (!fileinfo_put_wq) {
1609 rc = -ENOMEM;
1610 goto out_destroy_decrypt_wq;
1611 }
1612
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001613 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1614 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1615 if (!cifsoplockd_wq) {
1616 rc = -ENOMEM;
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001617 goto out_destroy_fileinfo_put_wq;
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001618 }
1619
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001620 deferredclose_wq = alloc_workqueue("deferredclose",
1621 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1622 if (!deferredclose_wq) {
1623 rc = -ENOMEM;
1624 goto out_destroy_cifsoplockd_wq;
1625 }
1626
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301627 rc = cifs_fscache_register();
1628 if (rc)
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001629 goto out_destroy_deferredclose_wq;
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301630
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 rc = cifs_init_inodecache();
Steve French45af7a02006-04-21 22:52:25 +00001632 if (rc)
Steve Frenchd3bf5222010-09-22 19:15:36 +00001633 goto out_unreg_fscache;
Steve French45af7a02006-04-21 22:52:25 +00001634
1635 rc = cifs_init_mids();
1636 if (rc)
1637 goto out_destroy_inodecache;
1638
1639 rc = cifs_init_request_bufs();
1640 if (rc)
1641 goto out_destroy_mids;
1642
Paulo Alcantara1c780222018-11-14 16:24:03 -02001643#ifdef CONFIG_CIFS_DFS_UPCALL
1644 rc = dfs_cache_init();
1645 if (rc)
1646 goto out_destroy_request_bufs;
1647#endif /* CONFIG_CIFS_DFS_UPCALL */
Jeff Layton84a15b92007-11-03 05:02:24 +00001648#ifdef CONFIG_CIFS_UPCALL
Sachin Prabhub74cb9a2016-05-17 18:20:13 -05001649 rc = init_cifs_spnego();
Jeff Layton84a15b92007-11-03 05:02:24 +00001650 if (rc)
Paulo Alcantara1c780222018-11-14 16:24:03 -02001651 goto out_destroy_dfs_cache;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001652#endif /* CONFIG_CIFS_UPCALL */
Samuel Cabrero06f08da2020-11-30 19:02:49 +01001653#ifdef CONFIG_CIFS_SWN_UPCALL
1654 rc = cifs_genl_init();
1655 if (rc)
1656 goto out_register_key_type;
1657#endif /* CONFIG_CIFS_SWN_UPCALL */
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001658
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001659 rc = init_cifs_idmap();
1660 if (rc)
Samuel Cabrero06f08da2020-11-30 19:02:49 +01001661 goto out_cifs_swn_init;
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001662
1663 rc = register_filesystem(&cifs_fs_type);
1664 if (rc)
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001665 goto out_init_cifs_idmap;
Steve French45af7a02006-04-21 22:52:25 +00001666
Steve French49218b42018-05-23 21:44:53 -05001667 rc = register_filesystem(&smb3_fs_type);
1668 if (rc) {
1669 unregister_filesystem(&cifs_fs_type);
1670 goto out_init_cifs_idmap;
1671 }
1672
Steve French45af7a02006-04-21 22:52:25 +00001673 return 0;
1674
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001675out_init_cifs_idmap:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001676 exit_cifs_idmap();
Samuel Cabrero06f08da2020-11-30 19:02:49 +01001677out_cifs_swn_init:
1678#ifdef CONFIG_CIFS_SWN_UPCALL
1679 cifs_genl_exit();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001680out_register_key_type:
Samuel Cabrero06f08da2020-11-30 19:02:49 +01001681#endif
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001682#ifdef CONFIG_CIFS_UPCALL
Sachin Prabhub74cb9a2016-05-17 18:20:13 -05001683 exit_cifs_spnego();
Paulo Alcantara1c780222018-11-14 16:24:03 -02001684out_destroy_dfs_cache:
1685#endif
1686#ifdef CONFIG_CIFS_DFS_UPCALL
1687 dfs_cache_destroy();
Shirish Pargaonkarc4aca0c2011-05-06 02:35:00 -05001688out_destroy_request_bufs:
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001689#endif
Steve French45af7a02006-04-21 22:52:25 +00001690 cifs_destroy_request_bufs();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001691out_destroy_mids:
Steve French45af7a02006-04-21 22:52:25 +00001692 cifs_destroy_mids();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001693out_destroy_inodecache:
Steve French45af7a02006-04-21 22:52:25 +00001694 cifs_destroy_inodecache();
Steve Frenchd3bf5222010-09-22 19:15:36 +00001695out_unreg_fscache:
Suresh Jayaramanf579cf32010-07-05 18:11:50 +05301696 cifs_fscache_unregister();
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001697out_destroy_deferredclose_wq:
1698 destroy_workqueue(deferredclose_wq);
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001699out_destroy_cifsoplockd_wq:
1700 destroy_workqueue(cifsoplockd_wq);
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001701out_destroy_fileinfo_put_wq:
1702 destroy_workqueue(fileinfo_put_wq);
Steve French35cf94a2019-09-07 01:09:49 -05001703out_destroy_decrypt_wq:
1704 destroy_workqueue(decrypt_wq);
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001705out_destroy_cifsiod_wq:
Jeff Laytonda472fc2012-03-23 14:40:53 -04001706 destroy_workqueue(cifsiod_wq);
Steve Frenchd3bf5222010-09-22 19:15:36 +00001707out_clean_proc:
1708 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 return rc;
1710}
1711
1712static void __exit
1713exit_cifs(void)
1714{
Steve French49218b42018-05-23 21:44:53 -05001715 cifs_dbg(NOISY, "exit_smb3\n");
Jeff Layton3dd93302012-03-21 06:27:55 -04001716 unregister_filesystem(&cifs_fs_type);
Steve French49218b42018-05-23 21:44:53 -05001717 unregister_filesystem(&smb3_fs_type);
Igor Mammedov78d31a32008-04-24 12:56:07 +04001718 cifs_dfs_release_automount_timer();
Shirish Pargaonkar4d79dba2011-04-27 23:34:35 -05001719 exit_cifs_idmap();
Samuel Cabrero06f08da2020-11-30 19:02:49 +01001720#ifdef CONFIG_CIFS_SWN_UPCALL
1721 cifs_genl_exit();
1722#endif
Jeff Layton84a15b92007-11-03 05:02:24 +00001723#ifdef CONFIG_CIFS_UPCALL
Shu Wang94183332017-09-07 16:03:27 +08001724 exit_cifs_spnego();
Jeff Layton84a15b92007-11-03 05:02:24 +00001725#endif
Paulo Alcantara1c780222018-11-14 16:24:03 -02001726#ifdef CONFIG_CIFS_DFS_UPCALL
1727 dfs_cache_destroy();
1728#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 cifs_destroy_request_bufs();
Jeff Layton3dd93302012-03-21 06:27:55 -04001730 cifs_destroy_mids();
1731 cifs_destroy_inodecache();
1732 cifs_fscache_unregister();
Rohith Surabattulac3f207a2021-04-13 00:26:42 -05001733 destroy_workqueue(deferredclose_wq);
Rabin Vincent3998e6b82017-05-03 17:54:01 +02001734 destroy_workqueue(cifsoplockd_wq);
Steve French35cf94a2019-09-07 01:09:49 -05001735 destroy_workqueue(decrypt_wq);
Ronnie Sahlberg32546a92019-11-03 13:06:37 +10001736 destroy_workqueue(fileinfo_put_wq);
Jeff Laytonda472fc2012-03-23 14:40:53 -04001737 destroy_workqueue(cifsiod_wq);
Jeff Layton3dd93302012-03-21 06:27:55 -04001738 cifs_proc_clean();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739}
1740
Steve French1c3a13a2018-09-18 04:07:45 -05001741MODULE_AUTHOR("Steve French");
Steve French6dc0f872007-07-06 23:13:06 +00001742MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743MODULE_DESCRIPTION
Steve French1c3a13a2018-09-18 04:07:45 -05001744 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1745 "also older servers complying with the SNIA CIFS Specification)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746MODULE_VERSION(CIFS_VERSION);
Ronnie Sahlberg3591bb82019-10-31 13:55:14 +10001747MODULE_SOFTDEP("ecb");
1748MODULE_SOFTDEP("hmac");
Ronnie Sahlberg3591bb82019-10-31 13:55:14 +10001749MODULE_SOFTDEP("md5");
1750MODULE_SOFTDEP("nls");
1751MODULE_SOFTDEP("aes");
1752MODULE_SOFTDEP("cmac");
1753MODULE_SOFTDEP("sha256");
1754MODULE_SOFTDEP("sha512");
1755MODULE_SOFTDEP("aead2");
1756MODULE_SOFTDEP("ccm");
1757MODULE_SOFTDEP("gcm");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758module_init(init_cifs)
1759module_exit(exit_cifs)