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