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