1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Common Internet FileSystem (CIFS) client
8 *
9 */
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/filelock.h>
16 #include <linux/mount.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/list.h>
20 #include <linux/seq_file.h>
21 #include <linux/vfs.h>
22 #include <linux/mempool.h>
23 #include <linux/delay.h>
24 #include <linux/kthread.h>
25 #include <linux/freezer.h>
26 #include <linux/namei.h>
27 #include <linux/random.h>
28 #include <linux/uuid.h>
29 #include <linux/xattr.h>
30 #include <uapi/linux/magic.h>
31 #include <net/ipv6.h>
32 #include "cifsfs.h"
33 #include "cifspdu.h"
34 #define DECLARE_GLOBALS_HERE
35 #include "cifsglob.h"
36 #include "cifsproto.h"
37 #include "cifs_debug.h"
38 #include "cifs_fs_sb.h"
39 #include <linux/mm.h>
40 #include <linux/key-type.h>
41 #include "cifs_spnego.h"
42 #include "fscache.h"
43 #ifdef CONFIG_CIFS_DFS_UPCALL
44 #include "dfs_cache.h"
45 #endif
46 #ifdef CONFIG_CIFS_SWN_UPCALL
47 #include "netlink.h"
48 #endif
49 #include "fs_context.h"
50 #include "cached_dir.h"
51
52 /*
53 * DOS dates from 1980/1/1 through 2107/12/31
54 * Protocol specifications indicate the range should be to 119, which
55 * limits maximum year to 2099. But this range has not been checked.
56 */
57 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
58 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
59 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
60
61 int cifsFYI = 0;
62 bool traceSMB;
63 bool enable_oplocks = true;
64 bool linuxExtEnabled = true;
65 bool lookupCacheEnabled = true;
66 bool disable_legacy_dialects; /* false by default */
67 bool enable_gcm_256 = true;
68 bool require_gcm_256; /* false by default */
69 bool enable_negotiate_signing; /* false by default */
70 unsigned int global_secflags = CIFSSEC_DEF;
71 /* unsigned int ntlmv2_support = 0; */
72 unsigned int sign_CIFS_PDUs = 1;
73
74 /*
75 * Global transaction id (XID) information
76 */
77 unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
78 unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
79 unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
80 spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */
81
82 /*
83 * Global counters, updated atomically
84 */
85 atomic_t sesInfoAllocCount;
86 atomic_t tconInfoAllocCount;
87 atomic_t tcpSesNextId;
88 atomic_t tcpSesAllocCount;
89 atomic_t tcpSesReconnectCount;
90 atomic_t tconInfoReconnectCount;
91
92 atomic_t mid_count;
93 atomic_t buf_alloc_count;
94 atomic_t small_buf_alloc_count;
95 #ifdef CONFIG_CIFS_STATS2
96 atomic_t total_buf_alloc_count;
97 atomic_t total_small_buf_alloc_count;
98 #endif/* STATS2 */
99 struct list_head cifs_tcp_ses_list;
100 spinlock_t cifs_tcp_ses_lock;
101 static const struct super_operations cifs_super_ops;
102 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
103 module_param(CIFSMaxBufSize, uint, 0444);
104 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
105 "for CIFS requests. "
106 "Default: 16384 Range: 8192 to 130048");
107 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
108 module_param(cifs_min_rcv, uint, 0444);
109 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
110 "1 to 64");
111 unsigned int cifs_min_small = 30;
112 module_param(cifs_min_small, uint, 0444);
113 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
114 "Range: 2 to 256");
115 unsigned int cifs_max_pending = CIFS_MAX_REQ;
116 module_param(cifs_max_pending, uint, 0444);
117 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
118 "CIFS/SMB1 dialect (N/A for SMB3) "
119 "Default: 32767 Range: 2 to 32767.");
120 unsigned int dir_cache_timeout = 30;
121 module_param(dir_cache_timeout, uint, 0644);
122 MODULE_PARM_DESC(dir_cache_timeout, "Number of seconds to cache directory contents for which we have a lease. Default: 30 "
123 "Range: 1 to 65000 seconds, 0 to disable caching dir contents");
124 #ifdef CONFIG_CIFS_STATS2
125 unsigned int slow_rsp_threshold = 1;
126 module_param(slow_rsp_threshold, uint, 0644);
127 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
128 "before logging that a response is delayed. "
129 "Default: 1 (if set to 0 disables msg).");
130 #endif /* STATS2 */
131
132 module_param(enable_oplocks, bool, 0644);
133 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
134
135 module_param(enable_gcm_256, bool, 0644);
136 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
137
138 module_param(require_gcm_256, bool, 0644);
139 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
140
141 module_param(enable_negotiate_signing, bool, 0644);
142 MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
143
144 module_param(disable_legacy_dialects, bool, 0644);
145 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
146 "helpful to restrict the ability to "
147 "override the default dialects (SMB2.1, "
148 "SMB3 and SMB3.02) on mount with old "
149 "dialects (CIFS/SMB1 and SMB2) since "
150 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
151 " and less secure. Default: n/N/0");
152
153 extern mempool_t *cifs_sm_req_poolp;
154 extern mempool_t *cifs_req_poolp;
155 extern mempool_t *cifs_mid_poolp;
156
157 struct workqueue_struct *cifsiod_wq;
158 struct workqueue_struct *decrypt_wq;
159 struct workqueue_struct *fileinfo_put_wq;
160 struct workqueue_struct *cifsoplockd_wq;
161 struct workqueue_struct *deferredclose_wq;
162 __u32 cifs_lock_secret;
163
164 /*
165 * Bumps refcount for cifs super block.
166 * Note that it should be only called if a referece to VFS super block is
167 * already held, e.g. in open-type syscalls context. Otherwise it can race with
168 * atomic_dec_and_test in deactivate_locked_super.
169 */
170 void
cifs_sb_active(struct super_block * sb)171 cifs_sb_active(struct super_block *sb)
172 {
173 struct cifs_sb_info *server = CIFS_SB(sb);
174
175 if (atomic_inc_return(&server->active) == 1)
176 atomic_inc(&sb->s_active);
177 }
178
179 void
cifs_sb_deactive(struct super_block * sb)180 cifs_sb_deactive(struct super_block *sb)
181 {
182 struct cifs_sb_info *server = CIFS_SB(sb);
183
184 if (atomic_dec_and_test(&server->active))
185 deactivate_super(sb);
186 }
187
188 static int
cifs_read_super(struct super_block * sb)189 cifs_read_super(struct super_block *sb)
190 {
191 struct inode *inode;
192 struct cifs_sb_info *cifs_sb;
193 struct cifs_tcon *tcon;
194 struct timespec64 ts;
195 int rc = 0;
196
197 cifs_sb = CIFS_SB(sb);
198 tcon = cifs_sb_master_tcon(cifs_sb);
199
200 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
201 sb->s_flags |= SB_POSIXACL;
202
203 if (tcon->snapshot_time)
204 sb->s_flags |= SB_RDONLY;
205
206 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
207 sb->s_maxbytes = MAX_LFS_FILESIZE;
208 else
209 sb->s_maxbytes = MAX_NON_LFS;
210
211 /*
212 * Some very old servers like DOS and OS/2 used 2 second granularity
213 * (while all current servers use 100ns granularity - see MS-DTYP)
214 * but 1 second is the maximum allowed granularity for the VFS
215 * so for old servers set time granularity to 1 second while for
216 * everything else (current servers) set it to 100ns.
217 */
218 if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
219 ((tcon->ses->capabilities &
220 tcon->ses->server->vals->cap_nt_find) == 0) &&
221 !tcon->unix_ext) {
222 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
223 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
224 sb->s_time_min = ts.tv_sec;
225 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
226 cpu_to_le16(SMB_TIME_MAX), 0);
227 sb->s_time_max = ts.tv_sec;
228 } else {
229 /*
230 * Almost every server, including all SMB2+, uses DCE TIME
231 * ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC
232 */
233 sb->s_time_gran = 100;
234 ts = cifs_NTtimeToUnix(0);
235 sb->s_time_min = ts.tv_sec;
236 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
237 sb->s_time_max = ts.tv_sec;
238 }
239
240 sb->s_magic = CIFS_SUPER_MAGIC;
241 sb->s_op = &cifs_super_ops;
242 sb->s_xattr = cifs_xattr_handlers;
243 rc = super_setup_bdi(sb);
244 if (rc)
245 goto out_no_root;
246 /* tune readahead according to rsize if readahead size not set on mount */
247 if (cifs_sb->ctx->rsize == 0)
248 cifs_sb->ctx->rsize =
249 tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);
250 if (cifs_sb->ctx->rasize)
251 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
252 else
253 sb->s_bdi->ra_pages = 2 * (cifs_sb->ctx->rsize / PAGE_SIZE);
254
255 sb->s_blocksize = CIFS_MAX_MSGSIZE;
256 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
257 inode = cifs_root_iget(sb);
258
259 if (IS_ERR(inode)) {
260 rc = PTR_ERR(inode);
261 goto out_no_root;
262 }
263
264 if (tcon->nocase)
265 sb->s_d_op = &cifs_ci_dentry_ops;
266 else
267 sb->s_d_op = &cifs_dentry_ops;
268
269 sb->s_root = d_make_root(inode);
270 if (!sb->s_root) {
271 rc = -ENOMEM;
272 goto out_no_root;
273 }
274
275 #ifdef CONFIG_CIFS_NFSD_EXPORT
276 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
277 cifs_dbg(FYI, "export ops supported\n");
278 sb->s_export_op = &cifs_export_ops;
279 }
280 #endif /* CONFIG_CIFS_NFSD_EXPORT */
281
282 return 0;
283
284 out_no_root:
285 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
286 return rc;
287 }
288
cifs_kill_sb(struct super_block * sb)289 static void cifs_kill_sb(struct super_block *sb)
290 {
291 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
292
293 /*
294 * We ned to release all dentries for the cached directories
295 * before we kill the sb.
296 */
297 if (cifs_sb->root) {
298 close_all_cached_dirs(cifs_sb);
299
300 /* finally release root dentry */
301 dput(cifs_sb->root);
302 cifs_sb->root = NULL;
303 }
304
305 kill_anon_super(sb);
306 cifs_umount(cifs_sb);
307 }
308
309 static int
cifs_statfs(struct dentry * dentry,struct kstatfs * buf)310 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
311 {
312 struct super_block *sb = dentry->d_sb;
313 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
314 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
315 struct TCP_Server_Info *server = tcon->ses->server;
316 unsigned int xid;
317 int rc = 0;
318
319 xid = get_xid();
320
321 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
322 buf->f_namelen =
323 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
324 else
325 buf->f_namelen = PATH_MAX;
326
327 buf->f_fsid.val[0] = tcon->vol_serial_number;
328 /* are using part of create time for more randomness, see man statfs */
329 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
330
331 buf->f_files = 0; /* undefined */
332 buf->f_ffree = 0; /* unlimited */
333
334 if (server->ops->queryfs)
335 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
336
337 free_xid(xid);
338 return rc;
339 }
340
cifs_fallocate(struct file * file,int mode,loff_t off,loff_t len)341 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
342 {
343 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
344 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
345 struct TCP_Server_Info *server = tcon->ses->server;
346
347 if (server->ops->fallocate)
348 return server->ops->fallocate(file, tcon, mode, off, len);
349
350 return -EOPNOTSUPP;
351 }
352
cifs_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)353 static int cifs_permission(struct mnt_idmap *idmap,
354 struct inode *inode, int mask)
355 {
356 struct cifs_sb_info *cifs_sb;
357
358 cifs_sb = CIFS_SB(inode->i_sb);
359
360 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
361 if ((mask & MAY_EXEC) && !execute_ok(inode))
362 return -EACCES;
363 else
364 return 0;
365 } else /* file mode might have been restricted at mount time
366 on the client (above and beyond ACL on servers) for
367 servers which do not support setting and viewing mode bits,
368 so allowing client to check permissions is useful */
369 return generic_permission(&nop_mnt_idmap, inode, mask);
370 }
371
372 static struct kmem_cache *cifs_inode_cachep;
373 static struct kmem_cache *cifs_req_cachep;
374 static struct kmem_cache *cifs_mid_cachep;
375 static struct kmem_cache *cifs_sm_req_cachep;
376 mempool_t *cifs_sm_req_poolp;
377 mempool_t *cifs_req_poolp;
378 mempool_t *cifs_mid_poolp;
379
380 static struct inode *
cifs_alloc_inode(struct super_block * sb)381 cifs_alloc_inode(struct super_block *sb)
382 {
383 struct cifsInodeInfo *cifs_inode;
384 cifs_inode = alloc_inode_sb(sb, cifs_inode_cachep, GFP_KERNEL);
385 if (!cifs_inode)
386 return NULL;
387 cifs_inode->cifsAttrs = 0x20; /* default */
388 cifs_inode->time = 0;
389 /*
390 * Until the file is open and we have gotten oplock info back from the
391 * server, can not assume caching of file data or metadata.
392 */
393 cifs_set_oplock_level(cifs_inode, 0);
394 cifs_inode->flags = 0;
395 spin_lock_init(&cifs_inode->writers_lock);
396 cifs_inode->writers = 0;
397 cifs_inode->netfs.inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
398 cifs_inode->server_eof = 0;
399 cifs_inode->uniqueid = 0;
400 cifs_inode->createtime = 0;
401 cifs_inode->epoch = 0;
402 spin_lock_init(&cifs_inode->open_file_lock);
403 generate_random_uuid(cifs_inode->lease_key);
404 cifs_inode->symlink_target = NULL;
405
406 /*
407 * Can not set i_flags here - they get immediately overwritten to zero
408 * by the VFS.
409 */
410 /* cifs_inode->netfs.inode.i_flags = S_NOATIME | S_NOCMTIME; */
411 INIT_LIST_HEAD(&cifs_inode->openFileList);
412 INIT_LIST_HEAD(&cifs_inode->llist);
413 INIT_LIST_HEAD(&cifs_inode->deferred_closes);
414 spin_lock_init(&cifs_inode->deferred_lock);
415 return &cifs_inode->netfs.inode;
416 }
417
418 static void
cifs_free_inode(struct inode * inode)419 cifs_free_inode(struct inode *inode)
420 {
421 struct cifsInodeInfo *cinode = CIFS_I(inode);
422
423 if (S_ISLNK(inode->i_mode))
424 kfree(cinode->symlink_target);
425 kmem_cache_free(cifs_inode_cachep, cinode);
426 }
427
428 static void
cifs_evict_inode(struct inode * inode)429 cifs_evict_inode(struct inode *inode)
430 {
431 truncate_inode_pages_final(&inode->i_data);
432 if (inode->i_state & I_PINNING_FSCACHE_WB)
433 cifs_fscache_unuse_inode_cookie(inode, true);
434 cifs_fscache_release_inode_cookie(inode);
435 clear_inode(inode);
436 }
437
438 static void
cifs_show_address(struct seq_file * s,struct TCP_Server_Info * server)439 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
440 {
441 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
442 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
443
444 seq_puts(s, ",addr=");
445
446 switch (server->dstaddr.ss_family) {
447 case AF_INET:
448 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
449 break;
450 case AF_INET6:
451 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
452 if (sa6->sin6_scope_id)
453 seq_printf(s, "%%%u", sa6->sin6_scope_id);
454 break;
455 default:
456 seq_puts(s, "(unknown)");
457 }
458 if (server->rdma)
459 seq_puts(s, ",rdma");
460 }
461
462 static void
cifs_show_security(struct seq_file * s,struct cifs_ses * ses)463 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
464 {
465 if (ses->sectype == Unspecified) {
466 if (ses->user_name == NULL)
467 seq_puts(s, ",sec=none");
468 return;
469 }
470
471 seq_puts(s, ",sec=");
472
473 switch (ses->sectype) {
474 case NTLMv2:
475 seq_puts(s, "ntlmv2");
476 break;
477 case Kerberos:
478 seq_puts(s, "krb5");
479 break;
480 case RawNTLMSSP:
481 seq_puts(s, "ntlmssp");
482 break;
483 default:
484 /* shouldn't ever happen */
485 seq_puts(s, "unknown");
486 break;
487 }
488
489 if (ses->sign)
490 seq_puts(s, "i");
491
492 if (ses->sectype == Kerberos)
493 seq_printf(s, ",cruid=%u",
494 from_kuid_munged(&init_user_ns, ses->cred_uid));
495 }
496
497 static void
cifs_show_cache_flavor(struct seq_file * s,struct cifs_sb_info * cifs_sb)498 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
499 {
500 seq_puts(s, ",cache=");
501
502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
503 seq_puts(s, "strict");
504 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
505 seq_puts(s, "none");
506 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
507 seq_puts(s, "singleclient"); /* assume only one client access */
508 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
509 seq_puts(s, "ro"); /* read only caching assumed */
510 else
511 seq_puts(s, "loose");
512 }
513
514 /*
515 * cifs_show_devname() is used so we show the mount device name with correct
516 * format (e.g. forward slashes vs. back slashes) in /proc/mounts
517 */
cifs_show_devname(struct seq_file * m,struct dentry * root)518 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
519 {
520 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
521 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
522
523 if (devname == NULL)
524 seq_puts(m, "none");
525 else {
526 convert_delimiter(devname, '/');
527 /* escape all spaces in share names */
528 seq_escape(m, devname, " \t");
529 kfree(devname);
530 }
531 return 0;
532 }
533
534 /*
535 * cifs_show_options() is for displaying mount options in /proc/mounts.
536 * Not all settable options are displayed but most of the important
537 * ones are.
538 */
539 static int
cifs_show_options(struct seq_file * s,struct dentry * root)540 cifs_show_options(struct seq_file *s, struct dentry *root)
541 {
542 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
543 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
544 struct sockaddr *srcaddr;
545 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
546
547 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
548 cifs_show_security(s, tcon->ses);
549 cifs_show_cache_flavor(s, cifs_sb);
550
551 if (tcon->no_lease)
552 seq_puts(s, ",nolease");
553 if (cifs_sb->ctx->multiuser)
554 seq_puts(s, ",multiuser");
555 else if (tcon->ses->user_name)
556 seq_show_option(s, "username", tcon->ses->user_name);
557
558 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
559 seq_show_option(s, "domain", tcon->ses->domainName);
560
561 if (srcaddr->sa_family != AF_UNSPEC) {
562 struct sockaddr_in *saddr4;
563 struct sockaddr_in6 *saddr6;
564 saddr4 = (struct sockaddr_in *)srcaddr;
565 saddr6 = (struct sockaddr_in6 *)srcaddr;
566 if (srcaddr->sa_family == AF_INET6)
567 seq_printf(s, ",srcaddr=%pI6c",
568 &saddr6->sin6_addr);
569 else if (srcaddr->sa_family == AF_INET)
570 seq_printf(s, ",srcaddr=%pI4",
571 &saddr4->sin_addr.s_addr);
572 else
573 seq_printf(s, ",srcaddr=BAD-AF:%i",
574 (int)(srcaddr->sa_family));
575 }
576
577 seq_printf(s, ",uid=%u",
578 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
579 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
580 seq_puts(s, ",forceuid");
581 else
582 seq_puts(s, ",noforceuid");
583
584 seq_printf(s, ",gid=%u",
585 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
586 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
587 seq_puts(s, ",forcegid");
588 else
589 seq_puts(s, ",noforcegid");
590
591 cifs_show_address(s, tcon->ses->server);
592
593 if (!tcon->unix_ext)
594 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
595 cifs_sb->ctx->file_mode,
596 cifs_sb->ctx->dir_mode);
597 if (cifs_sb->ctx->iocharset)
598 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
599 if (tcon->seal)
600 seq_puts(s, ",seal");
601 else if (tcon->ses->server->ignore_signature)
602 seq_puts(s, ",signloosely");
603 if (tcon->nocase)
604 seq_puts(s, ",nocase");
605 if (tcon->nodelete)
606 seq_puts(s, ",nodelete");
607 if (cifs_sb->ctx->no_sparse)
608 seq_puts(s, ",nosparse");
609 if (tcon->local_lease)
610 seq_puts(s, ",locallease");
611 if (tcon->retry)
612 seq_puts(s, ",hard");
613 else
614 seq_puts(s, ",soft");
615 if (tcon->use_persistent)
616 seq_puts(s, ",persistenthandles");
617 else if (tcon->use_resilient)
618 seq_puts(s, ",resilienthandles");
619 if (tcon->posix_extensions)
620 seq_puts(s, ",posix");
621 else if (tcon->unix_ext)
622 seq_puts(s, ",unix");
623 else
624 seq_puts(s, ",nounix");
625 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
626 seq_puts(s, ",nodfs");
627 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
628 seq_puts(s, ",posixpaths");
629 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
630 seq_puts(s, ",setuids");
631 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
632 seq_puts(s, ",idsfromsid");
633 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
634 seq_puts(s, ",serverino");
635 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
636 seq_puts(s, ",rwpidforward");
637 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
638 seq_puts(s, ",forcemand");
639 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
640 seq_puts(s, ",nouser_xattr");
641 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
642 seq_puts(s, ",mapchars");
643 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
644 seq_puts(s, ",mapposix");
645 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
646 seq_puts(s, ",sfu");
647 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
648 seq_puts(s, ",nobrl");
649 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
650 seq_puts(s, ",nohandlecache");
651 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
652 seq_puts(s, ",modefromsid");
653 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
654 seq_puts(s, ",cifsacl");
655 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
656 seq_puts(s, ",dynperm");
657 if (root->d_sb->s_flags & SB_POSIXACL)
658 seq_puts(s, ",acl");
659 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
660 seq_puts(s, ",mfsymlinks");
661 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
662 seq_puts(s, ",fsc");
663 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
664 seq_puts(s, ",nostrictsync");
665 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
666 seq_puts(s, ",noperm");
667 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
668 seq_printf(s, ",backupuid=%u",
669 from_kuid_munged(&init_user_ns,
670 cifs_sb->ctx->backupuid));
671 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
672 seq_printf(s, ",backupgid=%u",
673 from_kgid_munged(&init_user_ns,
674 cifs_sb->ctx->backupgid));
675
676 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
677 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
678 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
679 if (cifs_sb->ctx->rasize)
680 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
681 if (tcon->ses->server->min_offload)
682 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
683 seq_printf(s, ",echo_interval=%lu",
684 tcon->ses->server->echo_interval / HZ);
685
686 /* Only display the following if overridden on mount */
687 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
688 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
689 if (tcon->ses->server->tcp_nodelay)
690 seq_puts(s, ",tcpnodelay");
691 if (tcon->ses->server->noautotune)
692 seq_puts(s, ",noautotune");
693 if (tcon->ses->server->noblocksnd)
694 seq_puts(s, ",noblocksend");
695 if (tcon->ses->server->nosharesock)
696 seq_puts(s, ",nosharesock");
697
698 if (tcon->snapshot_time)
699 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
700 if (tcon->handle_timeout)
701 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
702 if (tcon->max_cached_dirs != MAX_CACHED_FIDS)
703 seq_printf(s, ",max_cached_dirs=%u", tcon->max_cached_dirs);
704
705 /*
706 * Display file and directory attribute timeout in seconds.
707 * If file and directory attribute timeout the same then actimeo
708 * was likely specified on mount
709 */
710 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
711 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
712 else {
713 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
714 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
715 }
716 seq_printf(s, ",closetimeo=%lu", cifs_sb->ctx->closetimeo / HZ);
717
718 if (tcon->ses->chan_max > 1)
719 seq_printf(s, ",multichannel,max_channels=%zu",
720 tcon->ses->chan_max);
721
722 if (tcon->use_witness)
723 seq_puts(s, ",witness");
724
725 return 0;
726 }
727
cifs_umount_begin(struct super_block * sb)728 static void cifs_umount_begin(struct super_block *sb)
729 {
730 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
731 struct cifs_tcon *tcon;
732
733 if (cifs_sb == NULL)
734 return;
735
736 tcon = cifs_sb_master_tcon(cifs_sb);
737
738 spin_lock(&cifs_tcp_ses_lock);
739 spin_lock(&tcon->tc_lock);
740 if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {
741 /* we have other mounts to same share or we have
742 already tried to umount this and woken up
743 all waiting network requests, nothing to do */
744 spin_unlock(&tcon->tc_lock);
745 spin_unlock(&cifs_tcp_ses_lock);
746 return;
747 }
748 /*
749 * can not set tcon->status to TID_EXITING yet since we don't know if umount -f will
750 * fail later (e.g. due to open files). TID_EXITING will be set just before tdis req sent
751 */
752 spin_unlock(&tcon->tc_lock);
753 spin_unlock(&cifs_tcp_ses_lock);
754
755 cifs_close_all_deferred_files(tcon);
756 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
757 /* cancel_notify_requests(tcon); */
758 if (tcon->ses && tcon->ses->server) {
759 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
760 wake_up_all(&tcon->ses->server->request_q);
761 wake_up_all(&tcon->ses->server->response_q);
762 msleep(1); /* yield */
763 /* we have to kick the requests once more */
764 wake_up_all(&tcon->ses->server->response_q);
765 msleep(1);
766 }
767
768 return;
769 }
770
cifs_freeze(struct super_block * sb)771 static int cifs_freeze(struct super_block *sb)
772 {
773 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
774 struct cifs_tcon *tcon;
775
776 if (cifs_sb == NULL)
777 return 0;
778
779 tcon = cifs_sb_master_tcon(cifs_sb);
780
781 cifs_close_all_deferred_files(tcon);
782 return 0;
783 }
784
785 #ifdef CONFIG_CIFS_STATS2
cifs_show_stats(struct seq_file * s,struct dentry * root)786 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
787 {
788 /* BB FIXME */
789 return 0;
790 }
791 #endif
792
cifs_write_inode(struct inode * inode,struct writeback_control * wbc)793 static int cifs_write_inode(struct inode *inode, struct writeback_control *wbc)
794 {
795 fscache_unpin_writeback(wbc, cifs_inode_cookie(inode));
796 return 0;
797 }
798
cifs_drop_inode(struct inode * inode)799 static int cifs_drop_inode(struct inode *inode)
800 {
801 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
802
803 /* no serverino => unconditional eviction */
804 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
805 generic_drop_inode(inode);
806 }
807
808 static const struct super_operations cifs_super_ops = {
809 .statfs = cifs_statfs,
810 .alloc_inode = cifs_alloc_inode,
811 .write_inode = cifs_write_inode,
812 .free_inode = cifs_free_inode,
813 .drop_inode = cifs_drop_inode,
814 .evict_inode = cifs_evict_inode,
815 /* .show_path = cifs_show_path, */ /* Would we ever need show path? */
816 .show_devname = cifs_show_devname,
817 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
818 function unless later we add lazy close of inodes or unless the
819 kernel forgets to call us with the same number of releases (closes)
820 as opens */
821 .show_options = cifs_show_options,
822 .umount_begin = cifs_umount_begin,
823 .freeze_fs = cifs_freeze,
824 #ifdef CONFIG_CIFS_STATS2
825 .show_stats = cifs_show_stats,
826 #endif
827 };
828
829 /*
830 * Get root dentry from superblock according to prefix path mount option.
831 * Return dentry with refcount + 1 on success and NULL otherwise.
832 */
833 static struct dentry *
cifs_get_root(struct smb3_fs_context * ctx,struct super_block * sb)834 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
835 {
836 struct dentry *dentry;
837 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
838 char *full_path = NULL;
839 char *s, *p;
840 char sep;
841
842 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
843 return dget(sb->s_root);
844
845 full_path = cifs_build_path_to_root(ctx, cifs_sb,
846 cifs_sb_master_tcon(cifs_sb), 0);
847 if (full_path == NULL)
848 return ERR_PTR(-ENOMEM);
849
850 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
851
852 sep = CIFS_DIR_SEP(cifs_sb);
853 dentry = dget(sb->s_root);
854 s = full_path;
855
856 do {
857 struct inode *dir = d_inode(dentry);
858 struct dentry *child;
859
860 if (!S_ISDIR(dir->i_mode)) {
861 dput(dentry);
862 dentry = ERR_PTR(-ENOTDIR);
863 break;
864 }
865
866 /* skip separators */
867 while (*s == sep)
868 s++;
869 if (!*s)
870 break;
871 p = s++;
872 /* next separator */
873 while (*s && *s != sep)
874 s++;
875
876 child = lookup_positive_unlocked(p, dentry, s - p);
877 dput(dentry);
878 dentry = child;
879 } while (!IS_ERR(dentry));
880 kfree(full_path);
881 return dentry;
882 }
883
cifs_set_super(struct super_block * sb,void * data)884 static int cifs_set_super(struct super_block *sb, void *data)
885 {
886 struct cifs_mnt_data *mnt_data = data;
887 sb->s_fs_info = mnt_data->cifs_sb;
888 return set_anon_super(sb, NULL);
889 }
890
891 struct dentry *
cifs_smb3_do_mount(struct file_system_type * fs_type,int flags,struct smb3_fs_context * old_ctx)892 cifs_smb3_do_mount(struct file_system_type *fs_type,
893 int flags, struct smb3_fs_context *old_ctx)
894 {
895 struct cifs_mnt_data mnt_data;
896 struct cifs_sb_info *cifs_sb;
897 struct super_block *sb;
898 struct dentry *root;
899 int rc;
900
901 if (cifsFYI) {
902 cifs_dbg(FYI, "%s: devname=%s flags=0x%x\n", __func__,
903 old_ctx->source, flags);
904 } else {
905 cifs_info("Attempting to mount %s\n", old_ctx->source);
906 }
907
908 cifs_sb = kzalloc(sizeof(*cifs_sb), GFP_KERNEL);
909 if (!cifs_sb)
910 return ERR_PTR(-ENOMEM);
911
912 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
913 if (!cifs_sb->ctx) {
914 root = ERR_PTR(-ENOMEM);
915 goto out;
916 }
917 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
918 if (rc) {
919 root = ERR_PTR(rc);
920 goto out;
921 }
922
923 rc = cifs_setup_cifs_sb(cifs_sb);
924 if (rc) {
925 root = ERR_PTR(rc);
926 goto out;
927 }
928
929 rc = cifs_mount(cifs_sb, cifs_sb->ctx);
930 if (rc) {
931 if (!(flags & SB_SILENT))
932 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
933 rc);
934 root = ERR_PTR(rc);
935 goto out;
936 }
937
938 mnt_data.ctx = cifs_sb->ctx;
939 mnt_data.cifs_sb = cifs_sb;
940 mnt_data.flags = flags;
941
942 /* BB should we make this contingent on mount parm? */
943 flags |= SB_NODIRATIME | SB_NOATIME;
944
945 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
946 if (IS_ERR(sb)) {
947 cifs_umount(cifs_sb);
948 return ERR_CAST(sb);
949 }
950
951 if (sb->s_root) {
952 cifs_dbg(FYI, "Use existing superblock\n");
953 cifs_umount(cifs_sb);
954 cifs_sb = NULL;
955 } else {
956 rc = cifs_read_super(sb);
957 if (rc) {
958 root = ERR_PTR(rc);
959 goto out_super;
960 }
961
962 sb->s_flags |= SB_ACTIVE;
963 }
964
965 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
966 if (IS_ERR(root))
967 goto out_super;
968
969 if (cifs_sb)
970 cifs_sb->root = dget(root);
971
972 cifs_dbg(FYI, "dentry root is: %p\n", root);
973 return root;
974
975 out_super:
976 deactivate_locked_super(sb);
977 return root;
978 out:
979 kfree(cifs_sb->prepath);
980 smb3_cleanup_fs_context(cifs_sb->ctx);
981 kfree(cifs_sb);
982 return root;
983 }
984
985
986 static ssize_t
cifs_loose_read_iter(struct kiocb * iocb,struct iov_iter * iter)987 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
988 {
989 ssize_t rc;
990 struct inode *inode = file_inode(iocb->ki_filp);
991
992 if (iocb->ki_flags & IOCB_DIRECT)
993 return cifs_user_readv(iocb, iter);
994
995 rc = cifs_revalidate_mapping(inode);
996 if (rc)
997 return rc;
998
999 return generic_file_read_iter(iocb, iter);
1000 }
1001
cifs_file_write_iter(struct kiocb * iocb,struct iov_iter * from)1002 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1003 {
1004 struct inode *inode = file_inode(iocb->ki_filp);
1005 struct cifsInodeInfo *cinode = CIFS_I(inode);
1006 ssize_t written;
1007 int rc;
1008
1009 if (iocb->ki_filp->f_flags & O_DIRECT) {
1010 written = cifs_user_writev(iocb, from);
1011 if (written > 0 && CIFS_CACHE_READ(cinode)) {
1012 cifs_zap_mapping(inode);
1013 cifs_dbg(FYI,
1014 "Set no oplock for inode=%p after a write operation\n",
1015 inode);
1016 cinode->oplock = 0;
1017 }
1018 return written;
1019 }
1020
1021 written = cifs_get_writer(cinode);
1022 if (written)
1023 return written;
1024
1025 written = generic_file_write_iter(iocb, from);
1026
1027 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
1028 goto out;
1029
1030 rc = filemap_fdatawrite(inode->i_mapping);
1031 if (rc)
1032 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
1033 rc, inode);
1034
1035 out:
1036 cifs_put_writer(cinode);
1037 return written;
1038 }
1039
cifs_llseek(struct file * file,loff_t offset,int whence)1040 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1041 {
1042 struct cifsFileInfo *cfile = file->private_data;
1043 struct cifs_tcon *tcon;
1044
1045 /*
1046 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1047 * the cached file length
1048 */
1049 if (whence != SEEK_SET && whence != SEEK_CUR) {
1050 int rc;
1051 struct inode *inode = file_inode(file);
1052
1053 /*
1054 * We need to be sure that all dirty pages are written and the
1055 * server has the newest file length.
1056 */
1057 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1058 inode->i_mapping->nrpages != 0) {
1059 rc = filemap_fdatawait(inode->i_mapping);
1060 if (rc) {
1061 mapping_set_error(inode->i_mapping, rc);
1062 return rc;
1063 }
1064 }
1065 /*
1066 * Some applications poll for the file length in this strange
1067 * way so we must seek to end on non-oplocked files by
1068 * setting the revalidate time to zero.
1069 */
1070 CIFS_I(inode)->time = 0;
1071
1072 rc = cifs_revalidate_file_attr(file);
1073 if (rc < 0)
1074 return (loff_t)rc;
1075 }
1076 if (cfile && cfile->tlink) {
1077 tcon = tlink_tcon(cfile->tlink);
1078 if (tcon->ses->server->ops->llseek)
1079 return tcon->ses->server->ops->llseek(file, tcon,
1080 offset, whence);
1081 }
1082 return generic_file_llseek(file, offset, whence);
1083 }
1084
1085 static int
cifs_setlease(struct file * file,int arg,struct file_lock ** lease,void ** priv)1086 cifs_setlease(struct file *file, int arg, struct file_lock **lease, void **priv)
1087 {
1088 /*
1089 * Note that this is called by vfs setlease with i_lock held to
1090 * protect *lease from going away.
1091 */
1092 struct inode *inode = file_inode(file);
1093 struct cifsFileInfo *cfile = file->private_data;
1094
1095 if (!(S_ISREG(inode->i_mode)))
1096 return -EINVAL;
1097
1098 /* Check if file is oplocked if this is request for new lease */
1099 if (arg == F_UNLCK ||
1100 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1101 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1102 return generic_setlease(file, arg, lease, priv);
1103 else if (tlink_tcon(cfile->tlink)->local_lease &&
1104 !CIFS_CACHE_READ(CIFS_I(inode)))
1105 /*
1106 * If the server claims to support oplock on this file, then we
1107 * still need to check oplock even if the local_lease mount
1108 * option is set, but there are servers which do not support
1109 * oplock for which this mount option may be useful if the user
1110 * knows that the file won't be changed on the server by anyone
1111 * else.
1112 */
1113 return generic_setlease(file, arg, lease, priv);
1114 else
1115 return -EAGAIN;
1116 }
1117
1118 struct file_system_type cifs_fs_type = {
1119 .owner = THIS_MODULE,
1120 .name = "cifs",
1121 .init_fs_context = smb3_init_fs_context,
1122 .parameters = smb3_fs_parameters,
1123 .kill_sb = cifs_kill_sb,
1124 .fs_flags = FS_RENAME_DOES_D_MOVE,
1125 };
1126 MODULE_ALIAS_FS("cifs");
1127
1128 struct file_system_type smb3_fs_type = {
1129 .owner = THIS_MODULE,
1130 .name = "smb3",
1131 .init_fs_context = smb3_init_fs_context,
1132 .parameters = smb3_fs_parameters,
1133 .kill_sb = cifs_kill_sb,
1134 .fs_flags = FS_RENAME_DOES_D_MOVE,
1135 };
1136 MODULE_ALIAS_FS("smb3");
1137 MODULE_ALIAS("smb3");
1138
1139 const struct inode_operations cifs_dir_inode_ops = {
1140 .create = cifs_create,
1141 .atomic_open = cifs_atomic_open,
1142 .lookup = cifs_lookup,
1143 .getattr = cifs_getattr,
1144 .unlink = cifs_unlink,
1145 .link = cifs_hardlink,
1146 .mkdir = cifs_mkdir,
1147 .rmdir = cifs_rmdir,
1148 .rename = cifs_rename2,
1149 .permission = cifs_permission,
1150 .setattr = cifs_setattr,
1151 .symlink = cifs_symlink,
1152 .mknod = cifs_mknod,
1153 .listxattr = cifs_listxattr,
1154 .get_acl = cifs_get_acl,
1155 .set_acl = cifs_set_acl,
1156 };
1157
1158 const struct inode_operations cifs_file_inode_ops = {
1159 .setattr = cifs_setattr,
1160 .getattr = cifs_getattr,
1161 .permission = cifs_permission,
1162 .listxattr = cifs_listxattr,
1163 .fiemap = cifs_fiemap,
1164 .get_acl = cifs_get_acl,
1165 .set_acl = cifs_set_acl,
1166 };
1167
cifs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)1168 const char *cifs_get_link(struct dentry *dentry, struct inode *inode,
1169 struct delayed_call *done)
1170 {
1171 char *target_path;
1172
1173 target_path = kmalloc(PATH_MAX, GFP_KERNEL);
1174 if (!target_path)
1175 return ERR_PTR(-ENOMEM);
1176
1177 spin_lock(&inode->i_lock);
1178 if (likely(CIFS_I(inode)->symlink_target)) {
1179 strscpy(target_path, CIFS_I(inode)->symlink_target, PATH_MAX);
1180 } else {
1181 kfree(target_path);
1182 target_path = ERR_PTR(-EOPNOTSUPP);
1183 }
1184 spin_unlock(&inode->i_lock);
1185
1186 if (!IS_ERR(target_path))
1187 set_delayed_call(done, kfree_link, target_path);
1188
1189 return target_path;
1190 }
1191
1192 const struct inode_operations cifs_symlink_inode_ops = {
1193 .get_link = cifs_get_link,
1194 .setattr = cifs_setattr,
1195 .permission = cifs_permission,
1196 .listxattr = cifs_listxattr,
1197 };
1198
1199 /*
1200 * Advance the EOF marker to after the source range.
1201 */
cifs_precopy_set_eof(struct inode * src_inode,struct cifsInodeInfo * src_cifsi,struct cifs_tcon * src_tcon,unsigned int xid,loff_t src_end)1202 static int cifs_precopy_set_eof(struct inode *src_inode, struct cifsInodeInfo *src_cifsi,
1203 struct cifs_tcon *src_tcon,
1204 unsigned int xid, loff_t src_end)
1205 {
1206 struct cifsFileInfo *writeable_srcfile;
1207 int rc = -EINVAL;
1208
1209 writeable_srcfile = find_writable_file(src_cifsi, FIND_WR_FSUID_ONLY);
1210 if (writeable_srcfile) {
1211 if (src_tcon->ses->server->ops->set_file_size)
1212 rc = src_tcon->ses->server->ops->set_file_size(
1213 xid, src_tcon, writeable_srcfile,
1214 src_inode->i_size, true /* no need to set sparse */);
1215 else
1216 rc = -ENOSYS;
1217 cifsFileInfo_put(writeable_srcfile);
1218 cifs_dbg(FYI, "SetFSize for copychunk rc = %d\n", rc);
1219 }
1220
1221 if (rc < 0)
1222 goto set_failed;
1223
1224 netfs_resize_file(&src_cifsi->netfs, src_end);
1225 fscache_resize_cookie(cifs_inode_cookie(src_inode), src_end);
1226 return 0;
1227
1228 set_failed:
1229 return filemap_write_and_wait(src_inode->i_mapping);
1230 }
1231
1232 /*
1233 * Flush out either the folio that overlaps the beginning of a range in which
1234 * pos resides or the folio that overlaps the end of a range unless that folio
1235 * is entirely within the range we're going to invalidate. We extend the flush
1236 * bounds to encompass the folio.
1237 */
cifs_flush_folio(struct inode * inode,loff_t pos,loff_t * _fstart,loff_t * _fend,bool first)1238 static int cifs_flush_folio(struct inode *inode, loff_t pos, loff_t *_fstart, loff_t *_fend,
1239 bool first)
1240 {
1241 struct folio *folio;
1242 unsigned long long fpos, fend;
1243 pgoff_t index = pos / PAGE_SIZE;
1244 size_t size;
1245 int rc = 0;
1246
1247 folio = filemap_get_folio(inode->i_mapping, index);
1248 if (IS_ERR(folio))
1249 return 0;
1250
1251 size = folio_size(folio);
1252 fpos = folio_pos(folio);
1253 fend = fpos + size - 1;
1254 *_fstart = min_t(unsigned long long, *_fstart, fpos);
1255 *_fend = max_t(unsigned long long, *_fend, fend);
1256 if ((first && pos == fpos) || (!first && pos == fend))
1257 goto out;
1258
1259 rc = filemap_write_and_wait_range(inode->i_mapping, fpos, fend);
1260 out:
1261 folio_put(folio);
1262 return rc;
1263 }
1264
cifs_remap_file_range(struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,loff_t len,unsigned int remap_flags)1265 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1266 struct file *dst_file, loff_t destoff, loff_t len,
1267 unsigned int remap_flags)
1268 {
1269 struct inode *src_inode = file_inode(src_file);
1270 struct inode *target_inode = file_inode(dst_file);
1271 struct cifsInodeInfo *src_cifsi = CIFS_I(src_inode);
1272 struct cifsInodeInfo *target_cifsi = CIFS_I(target_inode);
1273 struct cifsFileInfo *smb_file_src = src_file->private_data;
1274 struct cifsFileInfo *smb_file_target = dst_file->private_data;
1275 struct cifs_tcon *target_tcon, *src_tcon;
1276 unsigned long long destend, fstart, fend, new_size;
1277 unsigned int xid;
1278 int rc;
1279
1280 if (remap_flags & REMAP_FILE_DEDUP)
1281 return -EOPNOTSUPP;
1282 if (remap_flags & ~REMAP_FILE_ADVISORY)
1283 return -EINVAL;
1284
1285 cifs_dbg(FYI, "clone range\n");
1286
1287 xid = get_xid();
1288
1289 if (!smb_file_src || !smb_file_target) {
1290 rc = -EBADF;
1291 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1292 goto out;
1293 }
1294
1295 src_tcon = tlink_tcon(smb_file_src->tlink);
1296 target_tcon = tlink_tcon(smb_file_target->tlink);
1297
1298 /*
1299 * Note: cifs case is easier than btrfs since server responsible for
1300 * checks for proper open modes and file type and if it wants
1301 * server could even support copy of range where source = target
1302 */
1303 lock_two_nondirectories(target_inode, src_inode);
1304
1305 if (len == 0)
1306 len = src_inode->i_size - off;
1307
1308 cifs_dbg(FYI, "clone range\n");
1309
1310 /* Flush the source buffer */
1311 rc = filemap_write_and_wait_range(src_inode->i_mapping, off,
1312 off + len - 1);
1313 if (rc)
1314 goto unlock;
1315
1316 /* The server-side copy will fail if the source crosses the EOF marker.
1317 * Advance the EOF marker after the flush above to the end of the range
1318 * if it's short of that.
1319 */
1320 if (src_cifsi->netfs.remote_i_size < off + len) {
1321 rc = cifs_precopy_set_eof(src_inode, src_cifsi, src_tcon, xid, off + len);
1322 if (rc < 0)
1323 goto unlock;
1324 }
1325
1326 new_size = destoff + len;
1327 destend = destoff + len - 1;
1328
1329 /* Flush the folios at either end of the destination range to prevent
1330 * accidental loss of dirty data outside of the range.
1331 */
1332 fstart = destoff;
1333 fend = destend;
1334
1335 rc = cifs_flush_folio(target_inode, destoff, &fstart, &fend, true);
1336 if (rc)
1337 goto unlock;
1338 rc = cifs_flush_folio(target_inode, destend, &fstart, &fend, false);
1339 if (rc)
1340 goto unlock;
1341
1342 /* Discard all the folios that overlap the destination region. */
1343 cifs_dbg(FYI, "about to discard pages %llx-%llx\n", fstart, fend);
1344 truncate_inode_pages_range(&target_inode->i_data, fstart, fend);
1345
1346 fscache_invalidate(cifs_inode_cookie(target_inode), NULL,
1347 i_size_read(target_inode), 0);
1348
1349 rc = -EOPNOTSUPP;
1350 if (target_tcon->ses->server->ops->duplicate_extents) {
1351 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1352 smb_file_src, smb_file_target, off, len, destoff);
1353 if (rc == 0 && new_size > i_size_read(target_inode)) {
1354 truncate_setsize(target_inode, new_size);
1355 netfs_resize_file(&target_cifsi->netfs, new_size);
1356 fscache_resize_cookie(cifs_inode_cookie(target_inode),
1357 new_size);
1358 }
1359 }
1360
1361 /* force revalidate of size and timestamps of target file now
1362 that target is updated on the server */
1363 CIFS_I(target_inode)->time = 0;
1364 unlock:
1365 /* although unlocking in the reverse order from locking is not
1366 strictly necessary here it is a little cleaner to be consistent */
1367 unlock_two_nondirectories(src_inode, target_inode);
1368 out:
1369 free_xid(xid);
1370 return rc < 0 ? rc : len;
1371 }
1372
cifs_file_copychunk_range(unsigned int xid,struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,size_t len,unsigned int flags)1373 ssize_t cifs_file_copychunk_range(unsigned int xid,
1374 struct file *src_file, loff_t off,
1375 struct file *dst_file, loff_t destoff,
1376 size_t len, unsigned int flags)
1377 {
1378 struct inode *src_inode = file_inode(src_file);
1379 struct inode *target_inode = file_inode(dst_file);
1380 struct cifsInodeInfo *src_cifsi = CIFS_I(src_inode);
1381 struct cifsFileInfo *smb_file_src;
1382 struct cifsFileInfo *smb_file_target;
1383 struct cifs_tcon *src_tcon;
1384 struct cifs_tcon *target_tcon;
1385 unsigned long long destend, fstart, fend;
1386 ssize_t rc;
1387
1388 cifs_dbg(FYI, "copychunk range\n");
1389
1390 if (!src_file->private_data || !dst_file->private_data) {
1391 rc = -EBADF;
1392 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1393 goto out;
1394 }
1395
1396 rc = -EXDEV;
1397 smb_file_target = dst_file->private_data;
1398 smb_file_src = src_file->private_data;
1399 src_tcon = tlink_tcon(smb_file_src->tlink);
1400 target_tcon = tlink_tcon(smb_file_target->tlink);
1401
1402 if (src_tcon->ses != target_tcon->ses) {
1403 cifs_dbg(VFS, "source and target of copy not on same server\n");
1404 goto out;
1405 }
1406
1407 rc = -EOPNOTSUPP;
1408 if (!target_tcon->ses->server->ops->copychunk_range)
1409 goto out;
1410
1411 /*
1412 * Note: cifs case is easier than btrfs since server responsible for
1413 * checks for proper open modes and file type and if it wants
1414 * server could even support copy of range where source = target
1415 */
1416 lock_two_nondirectories(target_inode, src_inode);
1417
1418 cifs_dbg(FYI, "about to flush pages\n");
1419
1420 rc = filemap_write_and_wait_range(src_inode->i_mapping, off,
1421 off + len - 1);
1422 if (rc)
1423 goto unlock;
1424
1425 /* The server-side copy will fail if the source crosses the EOF marker.
1426 * Advance the EOF marker after the flush above to the end of the range
1427 * if it's short of that.
1428 */
1429 if (src_cifsi->server_eof < off + len) {
1430 rc = cifs_precopy_set_eof(src_inode, src_cifsi, src_tcon, xid, off + len);
1431 if (rc < 0)
1432 goto unlock;
1433 }
1434
1435 destend = destoff + len - 1;
1436
1437 /* Flush the folios at either end of the destination range to prevent
1438 * accidental loss of dirty data outside of the range.
1439 */
1440 fstart = destoff;
1441 fend = destend;
1442
1443 rc = cifs_flush_folio(target_inode, destoff, &fstart, &fend, true);
1444 if (rc)
1445 goto unlock;
1446 rc = cifs_flush_folio(target_inode, destend, &fstart, &fend, false);
1447 if (rc)
1448 goto unlock;
1449
1450 /* Discard all the folios that overlap the destination region. */
1451 truncate_inode_pages_range(&target_inode->i_data, fstart, fend);
1452
1453 rc = file_modified(dst_file);
1454 if (!rc) {
1455 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1456 smb_file_src, smb_file_target, off, len, destoff);
1457 if (rc > 0 && destoff + rc > i_size_read(target_inode))
1458 truncate_setsize(target_inode, destoff + rc);
1459 }
1460
1461 file_accessed(src_file);
1462
1463 /* force revalidate of size and timestamps of target file now
1464 * that target is updated on the server
1465 */
1466 CIFS_I(target_inode)->time = 0;
1467
1468 unlock:
1469 /* although unlocking in the reverse order from locking is not
1470 * strictly necessary here it is a little cleaner to be consistent
1471 */
1472 unlock_two_nondirectories(src_inode, target_inode);
1473
1474 out:
1475 return rc;
1476 }
1477
1478 /*
1479 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1480 * is a dummy operation.
1481 */
cifs_dir_fsync(struct file * file,loff_t start,loff_t end,int datasync)1482 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1483 {
1484 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1485 file, datasync);
1486
1487 return 0;
1488 }
1489
cifs_copy_file_range(struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,size_t len,unsigned int flags)1490 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1491 struct file *dst_file, loff_t destoff,
1492 size_t len, unsigned int flags)
1493 {
1494 unsigned int xid = get_xid();
1495 ssize_t rc;
1496 struct cifsFileInfo *cfile = dst_file->private_data;
1497
1498 if (cfile->swapfile) {
1499 rc = -EOPNOTSUPP;
1500 free_xid(xid);
1501 return rc;
1502 }
1503
1504 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1505 len, flags);
1506 free_xid(xid);
1507
1508 if (rc == -EOPNOTSUPP || rc == -EXDEV)
1509 rc = generic_copy_file_range(src_file, off, dst_file,
1510 destoff, len, flags);
1511 return rc;
1512 }
1513
1514 const struct file_operations cifs_file_ops = {
1515 .read_iter = cifs_loose_read_iter,
1516 .write_iter = cifs_file_write_iter,
1517 .open = cifs_open,
1518 .release = cifs_close,
1519 .lock = cifs_lock,
1520 .flock = cifs_flock,
1521 .fsync = cifs_fsync,
1522 .flush = cifs_flush,
1523 .mmap = cifs_file_mmap,
1524 .splice_read = filemap_splice_read,
1525 .splice_write = iter_file_splice_write,
1526 .llseek = cifs_llseek,
1527 .unlocked_ioctl = cifs_ioctl,
1528 .copy_file_range = cifs_copy_file_range,
1529 .remap_file_range = cifs_remap_file_range,
1530 .setlease = cifs_setlease,
1531 .fallocate = cifs_fallocate,
1532 };
1533
1534 const struct file_operations cifs_file_strict_ops = {
1535 .read_iter = cifs_strict_readv,
1536 .write_iter = cifs_strict_writev,
1537 .open = cifs_open,
1538 .release = cifs_close,
1539 .lock = cifs_lock,
1540 .flock = cifs_flock,
1541 .fsync = cifs_strict_fsync,
1542 .flush = cifs_flush,
1543 .mmap = cifs_file_strict_mmap,
1544 .splice_read = filemap_splice_read,
1545 .splice_write = iter_file_splice_write,
1546 .llseek = cifs_llseek,
1547 .unlocked_ioctl = cifs_ioctl,
1548 .copy_file_range = cifs_copy_file_range,
1549 .remap_file_range = cifs_remap_file_range,
1550 .setlease = cifs_setlease,
1551 .fallocate = cifs_fallocate,
1552 };
1553
1554 const struct file_operations cifs_file_direct_ops = {
1555 .read_iter = cifs_direct_readv,
1556 .write_iter = cifs_direct_writev,
1557 .open = cifs_open,
1558 .release = cifs_close,
1559 .lock = cifs_lock,
1560 .flock = cifs_flock,
1561 .fsync = cifs_fsync,
1562 .flush = cifs_flush,
1563 .mmap = cifs_file_mmap,
1564 .splice_read = copy_splice_read,
1565 .splice_write = iter_file_splice_write,
1566 .unlocked_ioctl = cifs_ioctl,
1567 .copy_file_range = cifs_copy_file_range,
1568 .remap_file_range = cifs_remap_file_range,
1569 .llseek = cifs_llseek,
1570 .setlease = cifs_setlease,
1571 .fallocate = cifs_fallocate,
1572 };
1573
1574 const struct file_operations cifs_file_nobrl_ops = {
1575 .read_iter = cifs_loose_read_iter,
1576 .write_iter = cifs_file_write_iter,
1577 .open = cifs_open,
1578 .release = cifs_close,
1579 .fsync = cifs_fsync,
1580 .flush = cifs_flush,
1581 .mmap = cifs_file_mmap,
1582 .splice_read = filemap_splice_read,
1583 .splice_write = iter_file_splice_write,
1584 .llseek = cifs_llseek,
1585 .unlocked_ioctl = cifs_ioctl,
1586 .copy_file_range = cifs_copy_file_range,
1587 .remap_file_range = cifs_remap_file_range,
1588 .setlease = cifs_setlease,
1589 .fallocate = cifs_fallocate,
1590 };
1591
1592 const struct file_operations cifs_file_strict_nobrl_ops = {
1593 .read_iter = cifs_strict_readv,
1594 .write_iter = cifs_strict_writev,
1595 .open = cifs_open,
1596 .release = cifs_close,
1597 .fsync = cifs_strict_fsync,
1598 .flush = cifs_flush,
1599 .mmap = cifs_file_strict_mmap,
1600 .splice_read = filemap_splice_read,
1601 .splice_write = iter_file_splice_write,
1602 .llseek = cifs_llseek,
1603 .unlocked_ioctl = cifs_ioctl,
1604 .copy_file_range = cifs_copy_file_range,
1605 .remap_file_range = cifs_remap_file_range,
1606 .setlease = cifs_setlease,
1607 .fallocate = cifs_fallocate,
1608 };
1609
1610 const struct file_operations cifs_file_direct_nobrl_ops = {
1611 .read_iter = cifs_direct_readv,
1612 .write_iter = cifs_direct_writev,
1613 .open = cifs_open,
1614 .release = cifs_close,
1615 .fsync = cifs_fsync,
1616 .flush = cifs_flush,
1617 .mmap = cifs_file_mmap,
1618 .splice_read = copy_splice_read,
1619 .splice_write = iter_file_splice_write,
1620 .unlocked_ioctl = cifs_ioctl,
1621 .copy_file_range = cifs_copy_file_range,
1622 .remap_file_range = cifs_remap_file_range,
1623 .llseek = cifs_llseek,
1624 .setlease = cifs_setlease,
1625 .fallocate = cifs_fallocate,
1626 };
1627
1628 const struct file_operations cifs_dir_ops = {
1629 .iterate_shared = cifs_readdir,
1630 .release = cifs_closedir,
1631 .read = generic_read_dir,
1632 .unlocked_ioctl = cifs_ioctl,
1633 .copy_file_range = cifs_copy_file_range,
1634 .remap_file_range = cifs_remap_file_range,
1635 .llseek = generic_file_llseek,
1636 .fsync = cifs_dir_fsync,
1637 };
1638
1639 static void
cifs_init_once(void * inode)1640 cifs_init_once(void *inode)
1641 {
1642 struct cifsInodeInfo *cifsi = inode;
1643
1644 inode_init_once(&cifsi->netfs.inode);
1645 init_rwsem(&cifsi->lock_sem);
1646 }
1647
1648 static int __init
cifs_init_inodecache(void)1649 cifs_init_inodecache(void)
1650 {
1651 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1652 sizeof(struct cifsInodeInfo),
1653 0, (SLAB_RECLAIM_ACCOUNT|
1654 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1655 cifs_init_once);
1656 if (cifs_inode_cachep == NULL)
1657 return -ENOMEM;
1658
1659 return 0;
1660 }
1661
1662 static void
cifs_destroy_inodecache(void)1663 cifs_destroy_inodecache(void)
1664 {
1665 /*
1666 * Make sure all delayed rcu free inodes are flushed before we
1667 * destroy cache.
1668 */
1669 rcu_barrier();
1670 kmem_cache_destroy(cifs_inode_cachep);
1671 }
1672
1673 static int
cifs_init_request_bufs(void)1674 cifs_init_request_bufs(void)
1675 {
1676 /*
1677 * SMB2 maximum header size is bigger than CIFS one - no problems to
1678 * allocate some more bytes for CIFS.
1679 */
1680 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1681
1682 if (CIFSMaxBufSize < 8192) {
1683 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1684 Unicode path name has to fit in any SMB/CIFS path based frames */
1685 CIFSMaxBufSize = 8192;
1686 } else if (CIFSMaxBufSize > 1024*127) {
1687 CIFSMaxBufSize = 1024 * 127;
1688 } else {
1689 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1690 }
1691 /*
1692 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1693 CIFSMaxBufSize, CIFSMaxBufSize);
1694 */
1695 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1696 CIFSMaxBufSize + max_hdr_size, 0,
1697 SLAB_HWCACHE_ALIGN, 0,
1698 CIFSMaxBufSize + max_hdr_size,
1699 NULL);
1700 if (cifs_req_cachep == NULL)
1701 return -ENOMEM;
1702
1703 if (cifs_min_rcv < 1)
1704 cifs_min_rcv = 1;
1705 else if (cifs_min_rcv > 64) {
1706 cifs_min_rcv = 64;
1707 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1708 }
1709
1710 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1711 cifs_req_cachep);
1712
1713 if (cifs_req_poolp == NULL) {
1714 kmem_cache_destroy(cifs_req_cachep);
1715 return -ENOMEM;
1716 }
1717 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1718 almost all handle based requests (but not write response, nor is it
1719 sufficient for path based requests). A smaller size would have
1720 been more efficient (compacting multiple slab items on one 4k page)
1721 for the case in which debug was on, but this larger size allows
1722 more SMBs to use small buffer alloc and is still much more
1723 efficient to alloc 1 per page off the slab compared to 17K (5page)
1724 alloc of large cifs buffers even when page debugging is on */
1725 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1726 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1727 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1728 if (cifs_sm_req_cachep == NULL) {
1729 mempool_destroy(cifs_req_poolp);
1730 kmem_cache_destroy(cifs_req_cachep);
1731 return -ENOMEM;
1732 }
1733
1734 if (cifs_min_small < 2)
1735 cifs_min_small = 2;
1736 else if (cifs_min_small > 256) {
1737 cifs_min_small = 256;
1738 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1739 }
1740
1741 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1742 cifs_sm_req_cachep);
1743
1744 if (cifs_sm_req_poolp == NULL) {
1745 mempool_destroy(cifs_req_poolp);
1746 kmem_cache_destroy(cifs_req_cachep);
1747 kmem_cache_destroy(cifs_sm_req_cachep);
1748 return -ENOMEM;
1749 }
1750
1751 return 0;
1752 }
1753
1754 static void
cifs_destroy_request_bufs(void)1755 cifs_destroy_request_bufs(void)
1756 {
1757 mempool_destroy(cifs_req_poolp);
1758 kmem_cache_destroy(cifs_req_cachep);
1759 mempool_destroy(cifs_sm_req_poolp);
1760 kmem_cache_destroy(cifs_sm_req_cachep);
1761 }
1762
init_mids(void)1763 static int init_mids(void)
1764 {
1765 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1766 sizeof(struct mid_q_entry), 0,
1767 SLAB_HWCACHE_ALIGN, NULL);
1768 if (cifs_mid_cachep == NULL)
1769 return -ENOMEM;
1770
1771 /* 3 is a reasonable minimum number of simultaneous operations */
1772 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1773 if (cifs_mid_poolp == NULL) {
1774 kmem_cache_destroy(cifs_mid_cachep);
1775 return -ENOMEM;
1776 }
1777
1778 return 0;
1779 }
1780
destroy_mids(void)1781 static void destroy_mids(void)
1782 {
1783 mempool_destroy(cifs_mid_poolp);
1784 kmem_cache_destroy(cifs_mid_cachep);
1785 }
1786
1787 static int __init
init_cifs(void)1788 init_cifs(void)
1789 {
1790 int rc = 0;
1791 cifs_proc_init();
1792 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1793 /*
1794 * Initialize Global counters
1795 */
1796 atomic_set(&sesInfoAllocCount, 0);
1797 atomic_set(&tconInfoAllocCount, 0);
1798 atomic_set(&tcpSesNextId, 0);
1799 atomic_set(&tcpSesAllocCount, 0);
1800 atomic_set(&tcpSesReconnectCount, 0);
1801 atomic_set(&tconInfoReconnectCount, 0);
1802
1803 atomic_set(&buf_alloc_count, 0);
1804 atomic_set(&small_buf_alloc_count, 0);
1805 #ifdef CONFIG_CIFS_STATS2
1806 atomic_set(&total_buf_alloc_count, 0);
1807 atomic_set(&total_small_buf_alloc_count, 0);
1808 if (slow_rsp_threshold < 1)
1809 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1810 else if (slow_rsp_threshold > 32767)
1811 cifs_dbg(VFS,
1812 "slow response threshold set higher than recommended (0 to 32767)\n");
1813 #endif /* CONFIG_CIFS_STATS2 */
1814
1815 atomic_set(&mid_count, 0);
1816 GlobalCurrentXid = 0;
1817 GlobalTotalActiveXid = 0;
1818 GlobalMaxActiveXid = 0;
1819 spin_lock_init(&cifs_tcp_ses_lock);
1820 spin_lock_init(&GlobalMid_Lock);
1821
1822 cifs_lock_secret = get_random_u32();
1823
1824 if (cifs_max_pending < 2) {
1825 cifs_max_pending = 2;
1826 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1827 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1828 cifs_max_pending = CIFS_MAX_REQ;
1829 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1830 CIFS_MAX_REQ);
1831 }
1832
1833 /* Limit max to about 18 hours, and setting to zero disables directory entry caching */
1834 if (dir_cache_timeout > 65000) {
1835 dir_cache_timeout = 65000;
1836 cifs_dbg(VFS, "dir_cache_timeout set to max of 65000 seconds\n");
1837 }
1838
1839 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1840 if (!cifsiod_wq) {
1841 rc = -ENOMEM;
1842 goto out_clean_proc;
1843 }
1844
1845 /*
1846 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1847 * so that we don't launch too many worker threads but
1848 * Documentation/core-api/workqueue.rst recommends setting it to 0
1849 */
1850
1851 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1852 decrypt_wq = alloc_workqueue("smb3decryptd",
1853 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1854 if (!decrypt_wq) {
1855 rc = -ENOMEM;
1856 goto out_destroy_cifsiod_wq;
1857 }
1858
1859 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1860 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1861 if (!fileinfo_put_wq) {
1862 rc = -ENOMEM;
1863 goto out_destroy_decrypt_wq;
1864 }
1865
1866 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1867 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1868 if (!cifsoplockd_wq) {
1869 rc = -ENOMEM;
1870 goto out_destroy_fileinfo_put_wq;
1871 }
1872
1873 deferredclose_wq = alloc_workqueue("deferredclose",
1874 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1875 if (!deferredclose_wq) {
1876 rc = -ENOMEM;
1877 goto out_destroy_cifsoplockd_wq;
1878 }
1879
1880 rc = cifs_init_inodecache();
1881 if (rc)
1882 goto out_destroy_deferredclose_wq;
1883
1884 rc = init_mids();
1885 if (rc)
1886 goto out_destroy_inodecache;
1887
1888 rc = cifs_init_request_bufs();
1889 if (rc)
1890 goto out_destroy_mids;
1891
1892 #ifdef CONFIG_CIFS_DFS_UPCALL
1893 rc = dfs_cache_init();
1894 if (rc)
1895 goto out_destroy_request_bufs;
1896 #endif /* CONFIG_CIFS_DFS_UPCALL */
1897 #ifdef CONFIG_CIFS_UPCALL
1898 rc = init_cifs_spnego();
1899 if (rc)
1900 goto out_destroy_dfs_cache;
1901 #endif /* CONFIG_CIFS_UPCALL */
1902 #ifdef CONFIG_CIFS_SWN_UPCALL
1903 rc = cifs_genl_init();
1904 if (rc)
1905 goto out_register_key_type;
1906 #endif /* CONFIG_CIFS_SWN_UPCALL */
1907
1908 rc = init_cifs_idmap();
1909 if (rc)
1910 goto out_cifs_swn_init;
1911
1912 rc = register_filesystem(&cifs_fs_type);
1913 if (rc)
1914 goto out_init_cifs_idmap;
1915
1916 rc = register_filesystem(&smb3_fs_type);
1917 if (rc) {
1918 unregister_filesystem(&cifs_fs_type);
1919 goto out_init_cifs_idmap;
1920 }
1921
1922 return 0;
1923
1924 out_init_cifs_idmap:
1925 exit_cifs_idmap();
1926 out_cifs_swn_init:
1927 #ifdef CONFIG_CIFS_SWN_UPCALL
1928 cifs_genl_exit();
1929 out_register_key_type:
1930 #endif
1931 #ifdef CONFIG_CIFS_UPCALL
1932 exit_cifs_spnego();
1933 out_destroy_dfs_cache:
1934 #endif
1935 #ifdef CONFIG_CIFS_DFS_UPCALL
1936 dfs_cache_destroy();
1937 out_destroy_request_bufs:
1938 #endif
1939 cifs_destroy_request_bufs();
1940 out_destroy_mids:
1941 destroy_mids();
1942 out_destroy_inodecache:
1943 cifs_destroy_inodecache();
1944 out_destroy_deferredclose_wq:
1945 destroy_workqueue(deferredclose_wq);
1946 out_destroy_cifsoplockd_wq:
1947 destroy_workqueue(cifsoplockd_wq);
1948 out_destroy_fileinfo_put_wq:
1949 destroy_workqueue(fileinfo_put_wq);
1950 out_destroy_decrypt_wq:
1951 destroy_workqueue(decrypt_wq);
1952 out_destroy_cifsiod_wq:
1953 destroy_workqueue(cifsiod_wq);
1954 out_clean_proc:
1955 cifs_proc_clean();
1956 return rc;
1957 }
1958
1959 static void __exit
exit_cifs(void)1960 exit_cifs(void)
1961 {
1962 cifs_dbg(NOISY, "exit_smb3\n");
1963 unregister_filesystem(&cifs_fs_type);
1964 unregister_filesystem(&smb3_fs_type);
1965 cifs_release_automount_timer();
1966 exit_cifs_idmap();
1967 #ifdef CONFIG_CIFS_SWN_UPCALL
1968 cifs_genl_exit();
1969 #endif
1970 #ifdef CONFIG_CIFS_UPCALL
1971 exit_cifs_spnego();
1972 #endif
1973 #ifdef CONFIG_CIFS_DFS_UPCALL
1974 dfs_cache_destroy();
1975 #endif
1976 cifs_destroy_request_bufs();
1977 destroy_mids();
1978 cifs_destroy_inodecache();
1979 destroy_workqueue(deferredclose_wq);
1980 destroy_workqueue(cifsoplockd_wq);
1981 destroy_workqueue(decrypt_wq);
1982 destroy_workqueue(fileinfo_put_wq);
1983 destroy_workqueue(cifsiod_wq);
1984 cifs_proc_clean();
1985 }
1986
1987 MODULE_AUTHOR("Steve French");
1988 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1989 MODULE_DESCRIPTION
1990 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1991 "also older servers complying with the SNIA CIFS Specification)");
1992 MODULE_VERSION(CIFS_VERSION);
1993 MODULE_SOFTDEP("ecb");
1994 MODULE_SOFTDEP("hmac");
1995 MODULE_SOFTDEP("md5");
1996 MODULE_SOFTDEP("nls");
1997 MODULE_SOFTDEP("aes");
1998 MODULE_SOFTDEP("cmac");
1999 MODULE_SOFTDEP("sha256");
2000 MODULE_SOFTDEP("sha512");
2001 MODULE_SOFTDEP("aead2");
2002 MODULE_SOFTDEP("ccm");
2003 MODULE_SOFTDEP("gcm");
2004 module_init(init_cifs)
2005 module_exit(exit_cifs)
2006