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 <net/ipv6.h>
30 #include "cifsfs.h"
31 #include "cifspdu.h"
32 #define DECLARE_GLOBALS_HERE
33 #include "cifsglob.h"
34 #include "cifsproto.h"
35 #include "cifs_debug.h"
36 #include "cifs_fs_sb.h"
37 #include <linux/mm.h>
38 #include <linux/key-type.h>
39 #include "cifs_spnego.h"
40 #include "fscache.h"
41 #include "smb2pdu.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_MAGIC_NUMBER;
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 = kmem_cache_alloc(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->vfs_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->vfs_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->vfs_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 clear_inode(inode);
411 }
412
413 static void
cifs_show_address(struct seq_file * s,struct TCP_Server_Info * server)414 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
415 {
416 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
417 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
418
419 seq_puts(s, ",addr=");
420
421 switch (server->dstaddr.ss_family) {
422 case AF_INET:
423 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
424 break;
425 case AF_INET6:
426 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
427 if (sa6->sin6_scope_id)
428 seq_printf(s, "%%%u", sa6->sin6_scope_id);
429 break;
430 default:
431 seq_puts(s, "(unknown)");
432 }
433 if (server->rdma)
434 seq_puts(s, ",rdma");
435 }
436
437 static void
cifs_show_security(struct seq_file * s,struct cifs_ses * ses)438 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
439 {
440 if (ses->sectype == Unspecified) {
441 if (ses->user_name == NULL)
442 seq_puts(s, ",sec=none");
443 return;
444 }
445
446 seq_puts(s, ",sec=");
447
448 switch (ses->sectype) {
449 case NTLMv2:
450 seq_puts(s, "ntlmv2");
451 break;
452 case Kerberos:
453 seq_puts(s, "krb5");
454 break;
455 case RawNTLMSSP:
456 seq_puts(s, "ntlmssp");
457 break;
458 default:
459 /* shouldn't ever happen */
460 seq_puts(s, "unknown");
461 break;
462 }
463
464 if (ses->sign)
465 seq_puts(s, "i");
466
467 if (ses->sectype == Kerberos)
468 seq_printf(s, ",cruid=%u",
469 from_kuid_munged(&init_user_ns, ses->cred_uid));
470 }
471
472 static void
cifs_show_cache_flavor(struct seq_file * s,struct cifs_sb_info * cifs_sb)473 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
474 {
475 seq_puts(s, ",cache=");
476
477 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
478 seq_puts(s, "strict");
479 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
480 seq_puts(s, "none");
481 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
482 seq_puts(s, "singleclient"); /* assume only one client access */
483 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
484 seq_puts(s, "ro"); /* read only caching assumed */
485 else
486 seq_puts(s, "loose");
487 }
488
489 /*
490 * cifs_show_devname() is used so we show the mount device name with correct
491 * format (e.g. forward slashes vs. back slashes) in /proc/mounts
492 */
cifs_show_devname(struct seq_file * m,struct dentry * root)493 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
494 {
495 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
496 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
497
498 if (devname == NULL)
499 seq_puts(m, "none");
500 else {
501 convert_delimiter(devname, '/');
502 /* escape all spaces in share names */
503 seq_escape(m, devname, " \t");
504 kfree(devname);
505 }
506 return 0;
507 }
508
509 /*
510 * cifs_show_options() is for displaying mount options in /proc/mounts.
511 * Not all settable options are displayed but most of the important
512 * ones are.
513 */
514 static int
cifs_show_options(struct seq_file * s,struct dentry * root)515 cifs_show_options(struct seq_file *s, struct dentry *root)
516 {
517 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
518 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
519 struct sockaddr *srcaddr;
520 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
521
522 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
523 cifs_show_security(s, tcon->ses);
524 cifs_show_cache_flavor(s, cifs_sb);
525
526 if (tcon->no_lease)
527 seq_puts(s, ",nolease");
528 if (cifs_sb->ctx->multiuser)
529 seq_puts(s, ",multiuser");
530 else if (tcon->ses->user_name)
531 seq_show_option(s, "username", tcon->ses->user_name);
532
533 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
534 seq_show_option(s, "domain", tcon->ses->domainName);
535
536 if (srcaddr->sa_family != AF_UNSPEC) {
537 struct sockaddr_in *saddr4;
538 struct sockaddr_in6 *saddr6;
539 saddr4 = (struct sockaddr_in *)srcaddr;
540 saddr6 = (struct sockaddr_in6 *)srcaddr;
541 if (srcaddr->sa_family == AF_INET6)
542 seq_printf(s, ",srcaddr=%pI6c",
543 &saddr6->sin6_addr);
544 else if (srcaddr->sa_family == AF_INET)
545 seq_printf(s, ",srcaddr=%pI4",
546 &saddr4->sin_addr.s_addr);
547 else
548 seq_printf(s, ",srcaddr=BAD-AF:%i",
549 (int)(srcaddr->sa_family));
550 }
551
552 seq_printf(s, ",uid=%u",
553 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
554 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
555 seq_puts(s, ",forceuid");
556 else
557 seq_puts(s, ",noforceuid");
558
559 seq_printf(s, ",gid=%u",
560 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
561 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
562 seq_puts(s, ",forcegid");
563 else
564 seq_puts(s, ",noforcegid");
565
566 cifs_show_address(s, tcon->ses->server);
567
568 if (!tcon->unix_ext)
569 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
570 cifs_sb->ctx->file_mode,
571 cifs_sb->ctx->dir_mode);
572 if (cifs_sb->ctx->iocharset)
573 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
574 if (tcon->seal)
575 seq_puts(s, ",seal");
576 else if (tcon->ses->server->ignore_signature)
577 seq_puts(s, ",signloosely");
578 if (tcon->nocase)
579 seq_puts(s, ",nocase");
580 if (tcon->nodelete)
581 seq_puts(s, ",nodelete");
582 if (tcon->local_lease)
583 seq_puts(s, ",locallease");
584 if (tcon->retry)
585 seq_puts(s, ",hard");
586 else
587 seq_puts(s, ",soft");
588 if (tcon->use_persistent)
589 seq_puts(s, ",persistenthandles");
590 else if (tcon->use_resilient)
591 seq_puts(s, ",resilienthandles");
592 if (tcon->posix_extensions)
593 seq_puts(s, ",posix");
594 else if (tcon->unix_ext)
595 seq_puts(s, ",unix");
596 else
597 seq_puts(s, ",nounix");
598 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
599 seq_puts(s, ",nodfs");
600 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
601 seq_puts(s, ",posixpaths");
602 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
603 seq_puts(s, ",setuids");
604 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
605 seq_puts(s, ",idsfromsid");
606 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
607 seq_puts(s, ",serverino");
608 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
609 seq_puts(s, ",rwpidforward");
610 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
611 seq_puts(s, ",forcemand");
612 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
613 seq_puts(s, ",nouser_xattr");
614 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
615 seq_puts(s, ",mapchars");
616 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
617 seq_puts(s, ",mapposix");
618 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
619 seq_puts(s, ",sfu");
620 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
621 seq_puts(s, ",nobrl");
622 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
623 seq_puts(s, ",nohandlecache");
624 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
625 seq_puts(s, ",modefromsid");
626 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
627 seq_puts(s, ",cifsacl");
628 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
629 seq_puts(s, ",dynperm");
630 if (root->d_sb->s_flags & SB_POSIXACL)
631 seq_puts(s, ",acl");
632 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
633 seq_puts(s, ",mfsymlinks");
634 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
635 seq_puts(s, ",fsc");
636 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
637 seq_puts(s, ",nostrictsync");
638 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
639 seq_puts(s, ",noperm");
640 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
641 seq_printf(s, ",backupuid=%u",
642 from_kuid_munged(&init_user_ns,
643 cifs_sb->ctx->backupuid));
644 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
645 seq_printf(s, ",backupgid=%u",
646 from_kgid_munged(&init_user_ns,
647 cifs_sb->ctx->backupgid));
648
649 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
650 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
651 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
652 if (cifs_sb->ctx->rasize)
653 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
654 if (tcon->ses->server->min_offload)
655 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
656 seq_printf(s, ",echo_interval=%lu",
657 tcon->ses->server->echo_interval / HZ);
658
659 /* Only display the following if overridden on mount */
660 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
661 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
662 if (tcon->ses->server->tcp_nodelay)
663 seq_puts(s, ",tcpnodelay");
664 if (tcon->ses->server->noautotune)
665 seq_puts(s, ",noautotune");
666 if (tcon->ses->server->noblocksnd)
667 seq_puts(s, ",noblocksend");
668
669 if (tcon->snapshot_time)
670 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
671 if (tcon->handle_timeout)
672 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
673
674 /*
675 * Display file and directory attribute timeout in seconds.
676 * If file and directory attribute timeout the same then actimeo
677 * was likely specified on mount
678 */
679 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
680 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
681 else {
682 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
683 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
684 }
685 seq_printf(s, ",closetimeo=%lu", cifs_sb->ctx->closetimeo / HZ);
686
687 if (tcon->ses->chan_max > 1)
688 seq_printf(s, ",multichannel,max_channels=%zu",
689 tcon->ses->chan_max);
690
691 if (tcon->use_witness)
692 seq_puts(s, ",witness");
693
694 return 0;
695 }
696
cifs_umount_begin(struct super_block * sb)697 static void cifs_umount_begin(struct super_block *sb)
698 {
699 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
700 struct cifs_tcon *tcon;
701
702 if (cifs_sb == NULL)
703 return;
704
705 tcon = cifs_sb_master_tcon(cifs_sb);
706
707 spin_lock(&cifs_tcp_ses_lock);
708 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
709 /* we have other mounts to same share or we have
710 already tried to force umount this and woken up
711 all waiting network requests, nothing to do */
712 spin_unlock(&cifs_tcp_ses_lock);
713 return;
714 } else if (tcon->tc_count == 1)
715 tcon->tidStatus = CifsExiting;
716 spin_unlock(&cifs_tcp_ses_lock);
717
718 cifs_close_all_deferred_files(tcon);
719 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
720 /* cancel_notify_requests(tcon); */
721 if (tcon->ses && tcon->ses->server) {
722 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
723 wake_up_all(&tcon->ses->server->request_q);
724 wake_up_all(&tcon->ses->server->response_q);
725 msleep(1); /* yield */
726 /* we have to kick the requests once more */
727 wake_up_all(&tcon->ses->server->response_q);
728 msleep(1);
729 }
730
731 return;
732 }
733
cifs_freeze(struct super_block * sb)734 static int cifs_freeze(struct super_block *sb)
735 {
736 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
737 struct cifs_tcon *tcon;
738
739 if (cifs_sb == NULL)
740 return 0;
741
742 tcon = cifs_sb_master_tcon(cifs_sb);
743
744 cifs_close_all_deferred_files(tcon);
745 return 0;
746 }
747
748 #ifdef CONFIG_CIFS_STATS2
cifs_show_stats(struct seq_file * s,struct dentry * root)749 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
750 {
751 /* BB FIXME */
752 return 0;
753 }
754 #endif
755
cifs_drop_inode(struct inode * inode)756 static int cifs_drop_inode(struct inode *inode)
757 {
758 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
759
760 /* no serverino => unconditional eviction */
761 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
762 generic_drop_inode(inode);
763 }
764
765 static const struct super_operations cifs_super_ops = {
766 .statfs = cifs_statfs,
767 .alloc_inode = cifs_alloc_inode,
768 .free_inode = cifs_free_inode,
769 .drop_inode = cifs_drop_inode,
770 .evict_inode = cifs_evict_inode,
771 /* .show_path = cifs_show_path, */ /* Would we ever need show path? */
772 .show_devname = cifs_show_devname,
773 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
774 function unless later we add lazy close of inodes or unless the
775 kernel forgets to call us with the same number of releases (closes)
776 as opens */
777 .show_options = cifs_show_options,
778 .umount_begin = cifs_umount_begin,
779 .freeze_fs = cifs_freeze,
780 #ifdef CONFIG_CIFS_STATS2
781 .show_stats = cifs_show_stats,
782 #endif
783 };
784
785 /*
786 * Get root dentry from superblock according to prefix path mount option.
787 * Return dentry with refcount + 1 on success and NULL otherwise.
788 */
789 static struct dentry *
cifs_get_root(struct smb3_fs_context * ctx,struct super_block * sb)790 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
791 {
792 struct dentry *dentry;
793 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
794 char *full_path = NULL;
795 char *s, *p;
796 char sep;
797
798 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
799 return dget(sb->s_root);
800
801 full_path = cifs_build_path_to_root(ctx, cifs_sb,
802 cifs_sb_master_tcon(cifs_sb), 0);
803 if (full_path == NULL)
804 return ERR_PTR(-ENOMEM);
805
806 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
807
808 sep = CIFS_DIR_SEP(cifs_sb);
809 dentry = dget(sb->s_root);
810 p = s = full_path;
811
812 do {
813 struct inode *dir = d_inode(dentry);
814 struct dentry *child;
815
816 if (!S_ISDIR(dir->i_mode)) {
817 dput(dentry);
818 dentry = ERR_PTR(-ENOTDIR);
819 break;
820 }
821
822 /* skip separators */
823 while (*s == sep)
824 s++;
825 if (!*s)
826 break;
827 p = s++;
828 /* next separator */
829 while (*s && *s != sep)
830 s++;
831
832 child = lookup_positive_unlocked(p, dentry, s - p);
833 dput(dentry);
834 dentry = child;
835 } while (!IS_ERR(dentry));
836 kfree(full_path);
837 return dentry;
838 }
839
cifs_set_super(struct super_block * sb,void * data)840 static int cifs_set_super(struct super_block *sb, void *data)
841 {
842 struct cifs_mnt_data *mnt_data = data;
843 sb->s_fs_info = mnt_data->cifs_sb;
844 return set_anon_super(sb, NULL);
845 }
846
847 struct dentry *
cifs_smb3_do_mount(struct file_system_type * fs_type,int flags,struct smb3_fs_context * old_ctx)848 cifs_smb3_do_mount(struct file_system_type *fs_type,
849 int flags, struct smb3_fs_context *old_ctx)
850 {
851 struct cifs_mnt_data mnt_data;
852 struct cifs_sb_info *cifs_sb;
853 struct super_block *sb;
854 struct dentry *root;
855 int rc;
856
857 /*
858 * Prints in Kernel / CIFS log the attempted mount operation
859 * If CIFS_DEBUG && cifs_FYI
860 */
861 if (cifsFYI)
862 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
863 else
864 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
865
866 cifs_sb = kzalloc(sizeof(*cifs_sb), GFP_KERNEL);
867 if (!cifs_sb)
868 return ERR_PTR(-ENOMEM);
869
870 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
871 if (!cifs_sb->ctx) {
872 root = ERR_PTR(-ENOMEM);
873 goto out;
874 }
875 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
876 if (rc) {
877 root = ERR_PTR(rc);
878 goto out;
879 }
880
881 rc = cifs_setup_volume_info(cifs_sb->ctx, NULL, NULL);
882 if (rc) {
883 root = ERR_PTR(rc);
884 goto out;
885 }
886
887 rc = cifs_setup_cifs_sb(cifs_sb);
888 if (rc) {
889 root = ERR_PTR(rc);
890 goto out;
891 }
892
893 rc = cifs_mount(cifs_sb, cifs_sb->ctx);
894 if (rc) {
895 if (!(flags & SB_SILENT))
896 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
897 rc);
898 root = ERR_PTR(rc);
899 goto out;
900 }
901
902 mnt_data.ctx = cifs_sb->ctx;
903 mnt_data.cifs_sb = cifs_sb;
904 mnt_data.flags = flags;
905
906 /* BB should we make this contingent on mount parm? */
907 flags |= SB_NODIRATIME | SB_NOATIME;
908
909 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
910 if (IS_ERR(sb)) {
911 cifs_umount(cifs_sb);
912 return ERR_CAST(sb);
913 }
914
915 if (sb->s_root) {
916 cifs_dbg(FYI, "Use existing superblock\n");
917 cifs_umount(cifs_sb);
918 cifs_sb = NULL;
919 } else {
920 rc = cifs_read_super(sb);
921 if (rc) {
922 root = ERR_PTR(rc);
923 goto out_super;
924 }
925
926 sb->s_flags |= SB_ACTIVE;
927 }
928
929 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
930 if (IS_ERR(root))
931 goto out_super;
932
933 if (cifs_sb)
934 cifs_sb->root = dget(root);
935
936 cifs_dbg(FYI, "dentry root is: %p\n", root);
937 return root;
938
939 out_super:
940 deactivate_locked_super(sb);
941 return root;
942 out:
943 kfree(cifs_sb->prepath);
944 smb3_cleanup_fs_context(cifs_sb->ctx);
945 kfree(cifs_sb);
946 return root;
947 }
948
949
950 static ssize_t
cifs_loose_read_iter(struct kiocb * iocb,struct iov_iter * iter)951 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
952 {
953 ssize_t rc;
954 struct inode *inode = file_inode(iocb->ki_filp);
955
956 if (iocb->ki_flags & IOCB_DIRECT)
957 return cifs_user_readv(iocb, iter);
958
959 rc = cifs_revalidate_mapping(inode);
960 if (rc)
961 return rc;
962
963 return generic_file_read_iter(iocb, iter);
964 }
965
cifs_file_write_iter(struct kiocb * iocb,struct iov_iter * from)966 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
967 {
968 struct inode *inode = file_inode(iocb->ki_filp);
969 struct cifsInodeInfo *cinode = CIFS_I(inode);
970 ssize_t written;
971 int rc;
972
973 if (iocb->ki_filp->f_flags & O_DIRECT) {
974 written = cifs_user_writev(iocb, from);
975 if (written > 0 && CIFS_CACHE_READ(cinode)) {
976 cifs_zap_mapping(inode);
977 cifs_dbg(FYI,
978 "Set no oplock for inode=%p after a write operation\n",
979 inode);
980 cinode->oplock = 0;
981 }
982 return written;
983 }
984
985 written = cifs_get_writer(cinode);
986 if (written)
987 return written;
988
989 written = generic_file_write_iter(iocb, from);
990
991 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
992 goto out;
993
994 rc = filemap_fdatawrite(inode->i_mapping);
995 if (rc)
996 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
997 rc, inode);
998
999 out:
1000 cifs_put_writer(cinode);
1001 return written;
1002 }
1003
cifs_llseek(struct file * file,loff_t offset,int whence)1004 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1005 {
1006 struct cifsFileInfo *cfile = file->private_data;
1007 struct cifs_tcon *tcon;
1008
1009 /*
1010 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1011 * the cached file length
1012 */
1013 if (whence != SEEK_SET && whence != SEEK_CUR) {
1014 int rc;
1015 struct inode *inode = file_inode(file);
1016
1017 /*
1018 * We need to be sure that all dirty pages are written and the
1019 * server has the newest file length.
1020 */
1021 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1022 inode->i_mapping->nrpages != 0) {
1023 rc = filemap_fdatawait(inode->i_mapping);
1024 if (rc) {
1025 mapping_set_error(inode->i_mapping, rc);
1026 return rc;
1027 }
1028 }
1029 /*
1030 * Some applications poll for the file length in this strange
1031 * way so we must seek to end on non-oplocked files by
1032 * setting the revalidate time to zero.
1033 */
1034 CIFS_I(inode)->time = 0;
1035
1036 rc = cifs_revalidate_file_attr(file);
1037 if (rc < 0)
1038 return (loff_t)rc;
1039 }
1040 if (cfile && cfile->tlink) {
1041 tcon = tlink_tcon(cfile->tlink);
1042 if (tcon->ses->server->ops->llseek)
1043 return tcon->ses->server->ops->llseek(file, tcon,
1044 offset, whence);
1045 }
1046 return generic_file_llseek(file, offset, whence);
1047 }
1048
1049 static int
cifs_setlease(struct file * file,long arg,struct file_lock ** lease,void ** priv)1050 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1051 {
1052 /*
1053 * Note that this is called by vfs setlease with i_lock held to
1054 * protect *lease from going away.
1055 */
1056 struct inode *inode = file_inode(file);
1057 struct cifsFileInfo *cfile = file->private_data;
1058
1059 if (!(S_ISREG(inode->i_mode)))
1060 return -EINVAL;
1061
1062 /* Check if file is oplocked if this is request for new lease */
1063 if (arg == F_UNLCK ||
1064 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1065 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1066 return generic_setlease(file, arg, lease, priv);
1067 else if (tlink_tcon(cfile->tlink)->local_lease &&
1068 !CIFS_CACHE_READ(CIFS_I(inode)))
1069 /*
1070 * If the server claims to support oplock on this file, then we
1071 * still need to check oplock even if the local_lease mount
1072 * option is set, but there are servers which do not support
1073 * oplock for which this mount option may be useful if the user
1074 * knows that the file won't be changed on the server by anyone
1075 * else.
1076 */
1077 return generic_setlease(file, arg, lease, priv);
1078 else
1079 return -EAGAIN;
1080 }
1081
1082 struct file_system_type cifs_fs_type = {
1083 .owner = THIS_MODULE,
1084 .name = "cifs",
1085 .init_fs_context = smb3_init_fs_context,
1086 .parameters = smb3_fs_parameters,
1087 .kill_sb = cifs_kill_sb,
1088 .fs_flags = FS_RENAME_DOES_D_MOVE,
1089 };
1090 MODULE_ALIAS_FS("cifs");
1091
1092 struct file_system_type smb3_fs_type = {
1093 .owner = THIS_MODULE,
1094 .name = "smb3",
1095 .init_fs_context = smb3_init_fs_context,
1096 .parameters = smb3_fs_parameters,
1097 .kill_sb = cifs_kill_sb,
1098 .fs_flags = FS_RENAME_DOES_D_MOVE,
1099 };
1100 MODULE_ALIAS_FS("smb3");
1101 MODULE_ALIAS("smb3");
1102
1103 const struct inode_operations cifs_dir_inode_ops = {
1104 .create = cifs_create,
1105 .atomic_open = cifs_atomic_open,
1106 .lookup = cifs_lookup,
1107 .getattr = cifs_getattr,
1108 .unlink = cifs_unlink,
1109 .link = cifs_hardlink,
1110 .mkdir = cifs_mkdir,
1111 .rmdir = cifs_rmdir,
1112 .rename = cifs_rename2,
1113 .permission = cifs_permission,
1114 .setattr = cifs_setattr,
1115 .symlink = cifs_symlink,
1116 .mknod = cifs_mknod,
1117 .listxattr = cifs_listxattr,
1118 };
1119
1120 const struct inode_operations cifs_file_inode_ops = {
1121 .setattr = cifs_setattr,
1122 .getattr = cifs_getattr,
1123 .permission = cifs_permission,
1124 .listxattr = cifs_listxattr,
1125 .fiemap = cifs_fiemap,
1126 };
1127
1128 const struct inode_operations cifs_symlink_inode_ops = {
1129 .get_link = cifs_get_link,
1130 .setattr = cifs_setattr,
1131 .permission = cifs_permission,
1132 .listxattr = cifs_listxattr,
1133 };
1134
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)1135 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1136 struct file *dst_file, loff_t destoff, loff_t len,
1137 unsigned int remap_flags)
1138 {
1139 struct inode *src_inode = file_inode(src_file);
1140 struct inode *target_inode = file_inode(dst_file);
1141 struct cifsFileInfo *smb_file_src = src_file->private_data;
1142 struct cifsFileInfo *smb_file_target;
1143 struct cifs_tcon *target_tcon;
1144 unsigned int xid;
1145 int rc;
1146
1147 if (remap_flags & REMAP_FILE_DEDUP)
1148 return -EOPNOTSUPP;
1149 if (remap_flags & ~REMAP_FILE_ADVISORY)
1150 return -EINVAL;
1151
1152 cifs_dbg(FYI, "clone range\n");
1153
1154 xid = get_xid();
1155
1156 if (!src_file->private_data || !dst_file->private_data) {
1157 rc = -EBADF;
1158 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1159 goto out;
1160 }
1161
1162 smb_file_target = dst_file->private_data;
1163 target_tcon = tlink_tcon(smb_file_target->tlink);
1164
1165 /*
1166 * Note: cifs case is easier than btrfs since server responsible for
1167 * checks for proper open modes and file type and if it wants
1168 * server could even support copy of range where source = target
1169 */
1170 lock_two_nondirectories(target_inode, src_inode);
1171
1172 if (len == 0)
1173 len = src_inode->i_size - off;
1174
1175 cifs_dbg(FYI, "about to flush pages\n");
1176 /* should we flush first and last page first */
1177 truncate_inode_pages_range(&target_inode->i_data, destoff,
1178 PAGE_ALIGN(destoff + len)-1);
1179
1180 if (target_tcon->ses->server->ops->duplicate_extents)
1181 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1182 smb_file_src, smb_file_target, off, len, destoff);
1183 else
1184 rc = -EOPNOTSUPP;
1185
1186 /* force revalidate of size and timestamps of target file now
1187 that target is updated on the server */
1188 CIFS_I(target_inode)->time = 0;
1189 /* although unlocking in the reverse order from locking is not
1190 strictly necessary here it is a little cleaner to be consistent */
1191 unlock_two_nondirectories(src_inode, target_inode);
1192 out:
1193 free_xid(xid);
1194 return rc < 0 ? rc : len;
1195 }
1196
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)1197 ssize_t cifs_file_copychunk_range(unsigned int xid,
1198 struct file *src_file, loff_t off,
1199 struct file *dst_file, loff_t destoff,
1200 size_t len, unsigned int flags)
1201 {
1202 struct inode *src_inode = file_inode(src_file);
1203 struct inode *target_inode = file_inode(dst_file);
1204 struct cifsFileInfo *smb_file_src;
1205 struct cifsFileInfo *smb_file_target;
1206 struct cifs_tcon *src_tcon;
1207 struct cifs_tcon *target_tcon;
1208 ssize_t rc;
1209
1210 cifs_dbg(FYI, "copychunk range\n");
1211
1212 if (!src_file->private_data || !dst_file->private_data) {
1213 rc = -EBADF;
1214 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1215 goto out;
1216 }
1217
1218 rc = -EXDEV;
1219 smb_file_target = dst_file->private_data;
1220 smb_file_src = src_file->private_data;
1221 src_tcon = tlink_tcon(smb_file_src->tlink);
1222 target_tcon = tlink_tcon(smb_file_target->tlink);
1223
1224 if (src_tcon->ses != target_tcon->ses) {
1225 cifs_dbg(VFS, "source and target of copy not on same server\n");
1226 goto out;
1227 }
1228
1229 rc = -EOPNOTSUPP;
1230 if (!target_tcon->ses->server->ops->copychunk_range)
1231 goto out;
1232
1233 /*
1234 * Note: cifs case is easier than btrfs since server responsible for
1235 * checks for proper open modes and file type and if it wants
1236 * server could even support copy of range where source = target
1237 */
1238 lock_two_nondirectories(target_inode, src_inode);
1239
1240 cifs_dbg(FYI, "about to flush pages\n");
1241 /* should we flush first and last page first */
1242 truncate_inode_pages(&target_inode->i_data, 0);
1243
1244 rc = file_modified(dst_file);
1245 if (!rc)
1246 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1247 smb_file_src, smb_file_target, off, len, destoff);
1248
1249 file_accessed(src_file);
1250
1251 /* force revalidate of size and timestamps of target file now
1252 * that target is updated on the server
1253 */
1254 CIFS_I(target_inode)->time = 0;
1255 /* although unlocking in the reverse order from locking is not
1256 * strictly necessary here it is a little cleaner to be consistent
1257 */
1258 unlock_two_nondirectories(src_inode, target_inode);
1259
1260 out:
1261 return rc;
1262 }
1263
1264 /*
1265 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1266 * is a dummy operation.
1267 */
cifs_dir_fsync(struct file * file,loff_t start,loff_t end,int datasync)1268 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1269 {
1270 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1271 file, datasync);
1272
1273 return 0;
1274 }
1275
cifs_copy_file_range(struct file * src_file,loff_t off,struct file * dst_file,loff_t destoff,size_t len,unsigned int flags)1276 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1277 struct file *dst_file, loff_t destoff,
1278 size_t len, unsigned int flags)
1279 {
1280 unsigned int xid = get_xid();
1281 ssize_t rc;
1282 struct cifsFileInfo *cfile = dst_file->private_data;
1283
1284 if (cfile->swapfile) {
1285 rc = -EOPNOTSUPP;
1286 free_xid(xid);
1287 return rc;
1288 }
1289
1290 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1291 len, flags);
1292 free_xid(xid);
1293
1294 if (rc == -EOPNOTSUPP || rc == -EXDEV)
1295 rc = generic_copy_file_range(src_file, off, dst_file,
1296 destoff, len, flags);
1297 return rc;
1298 }
1299
1300 const struct file_operations cifs_file_ops = {
1301 .read_iter = cifs_loose_read_iter,
1302 .write_iter = cifs_file_write_iter,
1303 .open = cifs_open,
1304 .release = cifs_close,
1305 .lock = cifs_lock,
1306 .flock = cifs_flock,
1307 .fsync = cifs_fsync,
1308 .flush = cifs_flush,
1309 .mmap = cifs_file_mmap,
1310 .splice_read = generic_file_splice_read,
1311 .splice_write = iter_file_splice_write,
1312 .llseek = cifs_llseek,
1313 .unlocked_ioctl = cifs_ioctl,
1314 .copy_file_range = cifs_copy_file_range,
1315 .remap_file_range = cifs_remap_file_range,
1316 .setlease = cifs_setlease,
1317 .fallocate = cifs_fallocate,
1318 };
1319
1320 const struct file_operations cifs_file_strict_ops = {
1321 .read_iter = cifs_strict_readv,
1322 .write_iter = cifs_strict_writev,
1323 .open = cifs_open,
1324 .release = cifs_close,
1325 .lock = cifs_lock,
1326 .flock = cifs_flock,
1327 .fsync = cifs_strict_fsync,
1328 .flush = cifs_flush,
1329 .mmap = cifs_file_strict_mmap,
1330 .splice_read = generic_file_splice_read,
1331 .splice_write = iter_file_splice_write,
1332 .llseek = cifs_llseek,
1333 .unlocked_ioctl = cifs_ioctl,
1334 .copy_file_range = cifs_copy_file_range,
1335 .remap_file_range = cifs_remap_file_range,
1336 .setlease = cifs_setlease,
1337 .fallocate = cifs_fallocate,
1338 };
1339
1340 const struct file_operations cifs_file_direct_ops = {
1341 .read_iter = cifs_direct_readv,
1342 .write_iter = cifs_direct_writev,
1343 .open = cifs_open,
1344 .release = cifs_close,
1345 .lock = cifs_lock,
1346 .flock = cifs_flock,
1347 .fsync = cifs_fsync,
1348 .flush = cifs_flush,
1349 .mmap = cifs_file_mmap,
1350 .splice_read = generic_file_splice_read,
1351 .splice_write = iter_file_splice_write,
1352 .unlocked_ioctl = cifs_ioctl,
1353 .copy_file_range = cifs_copy_file_range,
1354 .remap_file_range = cifs_remap_file_range,
1355 .llseek = cifs_llseek,
1356 .setlease = cifs_setlease,
1357 .fallocate = cifs_fallocate,
1358 };
1359
1360 const struct file_operations cifs_file_nobrl_ops = {
1361 .read_iter = cifs_loose_read_iter,
1362 .write_iter = cifs_file_write_iter,
1363 .open = cifs_open,
1364 .release = cifs_close,
1365 .fsync = cifs_fsync,
1366 .flush = cifs_flush,
1367 .mmap = cifs_file_mmap,
1368 .splice_read = generic_file_splice_read,
1369 .splice_write = iter_file_splice_write,
1370 .llseek = cifs_llseek,
1371 .unlocked_ioctl = cifs_ioctl,
1372 .copy_file_range = cifs_copy_file_range,
1373 .remap_file_range = cifs_remap_file_range,
1374 .setlease = cifs_setlease,
1375 .fallocate = cifs_fallocate,
1376 };
1377
1378 const struct file_operations cifs_file_strict_nobrl_ops = {
1379 .read_iter = cifs_strict_readv,
1380 .write_iter = cifs_strict_writev,
1381 .open = cifs_open,
1382 .release = cifs_close,
1383 .fsync = cifs_strict_fsync,
1384 .flush = cifs_flush,
1385 .mmap = cifs_file_strict_mmap,
1386 .splice_read = generic_file_splice_read,
1387 .splice_write = iter_file_splice_write,
1388 .llseek = cifs_llseek,
1389 .unlocked_ioctl = cifs_ioctl,
1390 .copy_file_range = cifs_copy_file_range,
1391 .remap_file_range = cifs_remap_file_range,
1392 .setlease = cifs_setlease,
1393 .fallocate = cifs_fallocate,
1394 };
1395
1396 const struct file_operations cifs_file_direct_nobrl_ops = {
1397 .read_iter = cifs_direct_readv,
1398 .write_iter = cifs_direct_writev,
1399 .open = cifs_open,
1400 .release = cifs_close,
1401 .fsync = cifs_fsync,
1402 .flush = cifs_flush,
1403 .mmap = cifs_file_mmap,
1404 .splice_read = generic_file_splice_read,
1405 .splice_write = iter_file_splice_write,
1406 .unlocked_ioctl = cifs_ioctl,
1407 .copy_file_range = cifs_copy_file_range,
1408 .remap_file_range = cifs_remap_file_range,
1409 .llseek = cifs_llseek,
1410 .setlease = cifs_setlease,
1411 .fallocate = cifs_fallocate,
1412 };
1413
1414 const struct file_operations cifs_dir_ops = {
1415 .iterate_shared = cifs_readdir,
1416 .release = cifs_closedir,
1417 .read = generic_read_dir,
1418 .unlocked_ioctl = cifs_ioctl,
1419 .copy_file_range = cifs_copy_file_range,
1420 .remap_file_range = cifs_remap_file_range,
1421 .llseek = generic_file_llseek,
1422 .fsync = cifs_dir_fsync,
1423 };
1424
1425 static void
cifs_init_once(void * inode)1426 cifs_init_once(void *inode)
1427 {
1428 struct cifsInodeInfo *cifsi = inode;
1429
1430 inode_init_once(&cifsi->vfs_inode);
1431 init_rwsem(&cifsi->lock_sem);
1432 }
1433
1434 static int __init
cifs_init_inodecache(void)1435 cifs_init_inodecache(void)
1436 {
1437 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1438 sizeof(struct cifsInodeInfo),
1439 0, (SLAB_RECLAIM_ACCOUNT|
1440 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1441 cifs_init_once);
1442 if (cifs_inode_cachep == NULL)
1443 return -ENOMEM;
1444
1445 return 0;
1446 }
1447
1448 static void
cifs_destroy_inodecache(void)1449 cifs_destroy_inodecache(void)
1450 {
1451 /*
1452 * Make sure all delayed rcu free inodes are flushed before we
1453 * destroy cache.
1454 */
1455 rcu_barrier();
1456 kmem_cache_destroy(cifs_inode_cachep);
1457 }
1458
1459 static int
cifs_init_request_bufs(void)1460 cifs_init_request_bufs(void)
1461 {
1462 /*
1463 * SMB2 maximum header size is bigger than CIFS one - no problems to
1464 * allocate some more bytes for CIFS.
1465 */
1466 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1467
1468 if (CIFSMaxBufSize < 8192) {
1469 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1470 Unicode path name has to fit in any SMB/CIFS path based frames */
1471 CIFSMaxBufSize = 8192;
1472 } else if (CIFSMaxBufSize > 1024*127) {
1473 CIFSMaxBufSize = 1024 * 127;
1474 } else {
1475 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1476 }
1477 /*
1478 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1479 CIFSMaxBufSize, CIFSMaxBufSize);
1480 */
1481 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1482 CIFSMaxBufSize + max_hdr_size, 0,
1483 SLAB_HWCACHE_ALIGN, 0,
1484 CIFSMaxBufSize + max_hdr_size,
1485 NULL);
1486 if (cifs_req_cachep == NULL)
1487 return -ENOMEM;
1488
1489 if (cifs_min_rcv < 1)
1490 cifs_min_rcv = 1;
1491 else if (cifs_min_rcv > 64) {
1492 cifs_min_rcv = 64;
1493 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1494 }
1495
1496 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1497 cifs_req_cachep);
1498
1499 if (cifs_req_poolp == NULL) {
1500 kmem_cache_destroy(cifs_req_cachep);
1501 return -ENOMEM;
1502 }
1503 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1504 almost all handle based requests (but not write response, nor is it
1505 sufficient for path based requests). A smaller size would have
1506 been more efficient (compacting multiple slab items on one 4k page)
1507 for the case in which debug was on, but this larger size allows
1508 more SMBs to use small buffer alloc and is still much more
1509 efficient to alloc 1 per page off the slab compared to 17K (5page)
1510 alloc of large cifs buffers even when page debugging is on */
1511 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1512 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1513 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1514 if (cifs_sm_req_cachep == NULL) {
1515 mempool_destroy(cifs_req_poolp);
1516 kmem_cache_destroy(cifs_req_cachep);
1517 return -ENOMEM;
1518 }
1519
1520 if (cifs_min_small < 2)
1521 cifs_min_small = 2;
1522 else if (cifs_min_small > 256) {
1523 cifs_min_small = 256;
1524 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1525 }
1526
1527 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1528 cifs_sm_req_cachep);
1529
1530 if (cifs_sm_req_poolp == NULL) {
1531 mempool_destroy(cifs_req_poolp);
1532 kmem_cache_destroy(cifs_req_cachep);
1533 kmem_cache_destroy(cifs_sm_req_cachep);
1534 return -ENOMEM;
1535 }
1536
1537 return 0;
1538 }
1539
1540 static void
cifs_destroy_request_bufs(void)1541 cifs_destroy_request_bufs(void)
1542 {
1543 mempool_destroy(cifs_req_poolp);
1544 kmem_cache_destroy(cifs_req_cachep);
1545 mempool_destroy(cifs_sm_req_poolp);
1546 kmem_cache_destroy(cifs_sm_req_cachep);
1547 }
1548
1549 static int
cifs_init_mids(void)1550 cifs_init_mids(void)
1551 {
1552 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1553 sizeof(struct mid_q_entry), 0,
1554 SLAB_HWCACHE_ALIGN, NULL);
1555 if (cifs_mid_cachep == NULL)
1556 return -ENOMEM;
1557
1558 /* 3 is a reasonable minimum number of simultaneous operations */
1559 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1560 if (cifs_mid_poolp == NULL) {
1561 kmem_cache_destroy(cifs_mid_cachep);
1562 return -ENOMEM;
1563 }
1564
1565 return 0;
1566 }
1567
1568 static void
cifs_destroy_mids(void)1569 cifs_destroy_mids(void)
1570 {
1571 mempool_destroy(cifs_mid_poolp);
1572 kmem_cache_destroy(cifs_mid_cachep);
1573 }
1574
1575 static int __init
init_cifs(void)1576 init_cifs(void)
1577 {
1578 int rc = 0;
1579 cifs_proc_init();
1580 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1581 /*
1582 * Initialize Global counters
1583 */
1584 atomic_set(&sesInfoAllocCount, 0);
1585 atomic_set(&tconInfoAllocCount, 0);
1586 atomic_set(&tcpSesNextId, 0);
1587 atomic_set(&tcpSesAllocCount, 0);
1588 atomic_set(&tcpSesReconnectCount, 0);
1589 atomic_set(&tconInfoReconnectCount, 0);
1590
1591 atomic_set(&bufAllocCount, 0);
1592 atomic_set(&smBufAllocCount, 0);
1593 #ifdef CONFIG_CIFS_STATS2
1594 atomic_set(&totBufAllocCount, 0);
1595 atomic_set(&totSmBufAllocCount, 0);
1596 if (slow_rsp_threshold < 1)
1597 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1598 else if (slow_rsp_threshold > 32767)
1599 cifs_dbg(VFS,
1600 "slow response threshold set higher than recommended (0 to 32767)\n");
1601 #endif /* CONFIG_CIFS_STATS2 */
1602
1603 atomic_set(&midCount, 0);
1604 GlobalCurrentXid = 0;
1605 GlobalTotalActiveXid = 0;
1606 GlobalMaxActiveXid = 0;
1607 spin_lock_init(&cifs_tcp_ses_lock);
1608 spin_lock_init(&GlobalMid_Lock);
1609
1610 cifs_lock_secret = get_random_u32();
1611
1612 if (cifs_max_pending < 2) {
1613 cifs_max_pending = 2;
1614 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1615 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1616 cifs_max_pending = CIFS_MAX_REQ;
1617 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1618 CIFS_MAX_REQ);
1619 }
1620
1621 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1622 if (!cifsiod_wq) {
1623 rc = -ENOMEM;
1624 goto out_clean_proc;
1625 }
1626
1627 /*
1628 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1629 * so that we don't launch too many worker threads but
1630 * Documentation/core-api/workqueue.rst recommends setting it to 0
1631 */
1632
1633 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1634 decrypt_wq = alloc_workqueue("smb3decryptd",
1635 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1636 if (!decrypt_wq) {
1637 rc = -ENOMEM;
1638 goto out_destroy_cifsiod_wq;
1639 }
1640
1641 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1642 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1643 if (!fileinfo_put_wq) {
1644 rc = -ENOMEM;
1645 goto out_destroy_decrypt_wq;
1646 }
1647
1648 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1649 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1650 if (!cifsoplockd_wq) {
1651 rc = -ENOMEM;
1652 goto out_destroy_fileinfo_put_wq;
1653 }
1654
1655 deferredclose_wq = alloc_workqueue("deferredclose",
1656 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1657 if (!deferredclose_wq) {
1658 rc = -ENOMEM;
1659 goto out_destroy_cifsoplockd_wq;
1660 }
1661
1662 rc = cifs_fscache_register();
1663 if (rc)
1664 goto out_destroy_deferredclose_wq;
1665
1666 rc = cifs_init_inodecache();
1667 if (rc)
1668 goto out_unreg_fscache;
1669
1670 rc = cifs_init_mids();
1671 if (rc)
1672 goto out_destroy_inodecache;
1673
1674 rc = cifs_init_request_bufs();
1675 if (rc)
1676 goto out_destroy_mids;
1677
1678 #ifdef CONFIG_CIFS_DFS_UPCALL
1679 rc = dfs_cache_init();
1680 if (rc)
1681 goto out_destroy_request_bufs;
1682 #endif /* CONFIG_CIFS_DFS_UPCALL */
1683 #ifdef CONFIG_CIFS_UPCALL
1684 rc = init_cifs_spnego();
1685 if (rc)
1686 goto out_destroy_dfs_cache;
1687 #endif /* CONFIG_CIFS_UPCALL */
1688 #ifdef CONFIG_CIFS_SWN_UPCALL
1689 rc = cifs_genl_init();
1690 if (rc)
1691 goto out_register_key_type;
1692 #endif /* CONFIG_CIFS_SWN_UPCALL */
1693
1694 rc = init_cifs_idmap();
1695 if (rc)
1696 goto out_cifs_swn_init;
1697
1698 rc = register_filesystem(&cifs_fs_type);
1699 if (rc)
1700 goto out_init_cifs_idmap;
1701
1702 rc = register_filesystem(&smb3_fs_type);
1703 if (rc) {
1704 unregister_filesystem(&cifs_fs_type);
1705 goto out_init_cifs_idmap;
1706 }
1707
1708 return 0;
1709
1710 out_init_cifs_idmap:
1711 exit_cifs_idmap();
1712 out_cifs_swn_init:
1713 #ifdef CONFIG_CIFS_SWN_UPCALL
1714 cifs_genl_exit();
1715 out_register_key_type:
1716 #endif
1717 #ifdef CONFIG_CIFS_UPCALL
1718 exit_cifs_spnego();
1719 out_destroy_dfs_cache:
1720 #endif
1721 #ifdef CONFIG_CIFS_DFS_UPCALL
1722 dfs_cache_destroy();
1723 out_destroy_request_bufs:
1724 #endif
1725 cifs_destroy_request_bufs();
1726 out_destroy_mids:
1727 cifs_destroy_mids();
1728 out_destroy_inodecache:
1729 cifs_destroy_inodecache();
1730 out_unreg_fscache:
1731 cifs_fscache_unregister();
1732 out_destroy_deferredclose_wq:
1733 destroy_workqueue(deferredclose_wq);
1734 out_destroy_cifsoplockd_wq:
1735 destroy_workqueue(cifsoplockd_wq);
1736 out_destroy_fileinfo_put_wq:
1737 destroy_workqueue(fileinfo_put_wq);
1738 out_destroy_decrypt_wq:
1739 destroy_workqueue(decrypt_wq);
1740 out_destroy_cifsiod_wq:
1741 destroy_workqueue(cifsiod_wq);
1742 out_clean_proc:
1743 cifs_proc_clean();
1744 return rc;
1745 }
1746
1747 static void __exit
exit_cifs(void)1748 exit_cifs(void)
1749 {
1750 cifs_dbg(NOISY, "exit_smb3\n");
1751 unregister_filesystem(&cifs_fs_type);
1752 unregister_filesystem(&smb3_fs_type);
1753 cifs_dfs_release_automount_timer();
1754 exit_cifs_idmap();
1755 #ifdef CONFIG_CIFS_SWN_UPCALL
1756 cifs_genl_exit();
1757 #endif
1758 #ifdef CONFIG_CIFS_UPCALL
1759 exit_cifs_spnego();
1760 #endif
1761 #ifdef CONFIG_CIFS_DFS_UPCALL
1762 dfs_cache_destroy();
1763 #endif
1764 cifs_destroy_request_bufs();
1765 cifs_destroy_mids();
1766 cifs_destroy_inodecache();
1767 cifs_fscache_unregister();
1768 destroy_workqueue(deferredclose_wq);
1769 destroy_workqueue(cifsoplockd_wq);
1770 destroy_workqueue(decrypt_wq);
1771 destroy_workqueue(fileinfo_put_wq);
1772 destroy_workqueue(cifsiod_wq);
1773 cifs_proc_clean();
1774 }
1775
1776 MODULE_AUTHOR("Steve French");
1777 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1778 MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
1779 MODULE_DESCRIPTION
1780 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1781 "also older servers complying with the SNIA CIFS Specification)");
1782 MODULE_VERSION(CIFS_VERSION);
1783 MODULE_SOFTDEP("ecb");
1784 MODULE_SOFTDEP("hmac");
1785 MODULE_SOFTDEP("md5");
1786 MODULE_SOFTDEP("nls");
1787 MODULE_SOFTDEP("aes");
1788 MODULE_SOFTDEP("cmac");
1789 MODULE_SOFTDEP("sha256");
1790 MODULE_SOFTDEP("sha512");
1791 MODULE_SOFTDEP("aead2");
1792 MODULE_SOFTDEP("ccm");
1793 MODULE_SOFTDEP("gcm");
1794 module_init(init_cifs)
1795 module_exit(exit_cifs)
1796