1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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/xattr.h>
41#include <net/ipv6.h>
42#include "cifsfs.h"
43#include "cifspdu.h"
44#define DECLARE_GLOBALS_HERE
45#include "cifsglob.h"
46#include "cifsproto.h"
47#include "cifs_debug.h"
48#include "cifs_fs_sb.h"
49#include <linux/mm.h>
50#include <linux/key-type.h>
51#include "cifs_spnego.h"
52#include "fscache.h"
53#ifdef CONFIG_CIFS_SMB2
54#include "smb2pdu.h"
55#endif
56
57int cifsFYI = 0;
58bool traceSMB;
59bool enable_oplocks = true;
60bool linuxExtEnabled = true;
61bool lookupCacheEnabled = true;
62unsigned int global_secflags = CIFSSEC_DEF;
63
64unsigned int sign_CIFS_PDUs = 1;
65static const struct super_operations cifs_super_ops;
66unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
67module_param(CIFSMaxBufSize, uint, 0444);
68MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
69 "Default: 16384 Range: 8192 to 130048");
70unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
71module_param(cifs_min_rcv, uint, 0444);
72MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
73 "1 to 64");
74unsigned int cifs_min_small = 30;
75module_param(cifs_min_small, uint, 0444);
76MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
77 "Range: 2 to 256");
78unsigned int cifs_max_pending = CIFS_MAX_REQ;
79module_param(cifs_max_pending, uint, 0444);
80MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
81 "Default: 32767 Range: 2 to 32767.");
82module_param(enable_oplocks, bool, 0644);
83MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
84
85extern mempool_t *cifs_sm_req_poolp;
86extern mempool_t *cifs_req_poolp;
87extern mempool_t *cifs_mid_poolp;
88
89struct workqueue_struct *cifsiod_wq;
90__u32 cifs_lock_secret;
91
92
93
94
95
96
97
98void
99cifs_sb_active(struct super_block *sb)
100{
101 struct cifs_sb_info *server = CIFS_SB(sb);
102
103 if (atomic_inc_return(&server->active) == 1)
104 atomic_inc(&sb->s_active);
105}
106
107void
108cifs_sb_deactive(struct super_block *sb)
109{
110 struct cifs_sb_info *server = CIFS_SB(sb);
111
112 if (atomic_dec_and_test(&server->active))
113 deactivate_super(sb);
114}
115
116static int
117cifs_read_super(struct super_block *sb)
118{
119 struct inode *inode;
120 struct cifs_sb_info *cifs_sb;
121 struct cifs_tcon *tcon;
122 int rc = 0;
123
124 cifs_sb = CIFS_SB(sb);
125 tcon = cifs_sb_master_tcon(cifs_sb);
126
127 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128 sb->s_flags |= MS_POSIXACL;
129
130 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
131 sb->s_maxbytes = MAX_LFS_FILESIZE;
132 else
133 sb->s_maxbytes = MAX_NON_LFS;
134
135
136 sb->s_time_gran = 100;
137
138 sb->s_magic = CIFS_MAGIC_NUMBER;
139 sb->s_op = &cifs_super_ops;
140 sb->s_xattr = cifs_xattr_handlers;
141 sb->s_bdi = &cifs_sb->bdi;
142 sb->s_blocksize = CIFS_MAX_MSGSIZE;
143 sb->s_blocksize_bits = 14;
144 inode = cifs_root_iget(sb);
145
146 if (IS_ERR(inode)) {
147 rc = PTR_ERR(inode);
148 goto out_no_root;
149 }
150
151 if (tcon->nocase)
152 sb->s_d_op = &cifs_ci_dentry_ops;
153 else
154 sb->s_d_op = &cifs_dentry_ops;
155
156 sb->s_root = d_make_root(inode);
157 if (!sb->s_root) {
158 rc = -ENOMEM;
159 goto out_no_root;
160 }
161
162#ifdef CONFIG_CIFS_NFSD_EXPORT
163 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
164 cifs_dbg(FYI, "export ops supported\n");
165 sb->s_export_op = &cifs_export_ops;
166 }
167#endif
168
169 return 0;
170
171out_no_root:
172 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
173 return rc;
174}
175
176static void cifs_kill_sb(struct super_block *sb)
177{
178 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
179 kill_anon_super(sb);
180 cifs_umount(cifs_sb);
181}
182
183static int
184cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
185{
186 struct super_block *sb = dentry->d_sb;
187 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
188 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
189 struct TCP_Server_Info *server = tcon->ses->server;
190 unsigned int xid;
191 int rc = 0;
192
193 xid = get_xid();
194
195
196
197
198
199
200
201
202 buf->f_namelen = PATH_MAX;
203 buf->f_files = 0;
204 buf->f_ffree = 0;
205
206 if (server->ops->queryfs)
207 rc = server->ops->queryfs(xid, tcon, buf);
208
209 free_xid(xid);
210 return 0;
211}
212
213static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
214{
215 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
216 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
217 struct TCP_Server_Info *server = tcon->ses->server;
218
219 if (server->ops->fallocate)
220 return server->ops->fallocate(file, tcon, mode, off, len);
221
222 return -EOPNOTSUPP;
223}
224
225static int cifs_permission(struct inode *inode, int mask)
226{
227 struct cifs_sb_info *cifs_sb;
228
229 cifs_sb = CIFS_SB(inode->i_sb);
230
231 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
232 if ((mask & MAY_EXEC) && !execute_ok(inode))
233 return -EACCES;
234 else
235 return 0;
236 } else
237
238
239
240 return generic_permission(inode, mask);
241}
242
243static struct kmem_cache *cifs_inode_cachep;
244static struct kmem_cache *cifs_req_cachep;
245static struct kmem_cache *cifs_mid_cachep;
246static struct kmem_cache *cifs_sm_req_cachep;
247mempool_t *cifs_sm_req_poolp;
248mempool_t *cifs_req_poolp;
249mempool_t *cifs_mid_poolp;
250
251static struct inode *
252cifs_alloc_inode(struct super_block *sb)
253{
254 struct cifsInodeInfo *cifs_inode;
255 cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
256 if (!cifs_inode)
257 return NULL;
258 cifs_inode->cifsAttrs = 0x20;
259 cifs_inode->time = 0;
260
261
262
263
264 cifs_set_oplock_level(cifs_inode, 0);
265 cifs_inode->flags = 0;
266 spin_lock_init(&cifs_inode->writers_lock);
267 cifs_inode->writers = 0;
268 cifs_inode->vfs_inode.i_blkbits = 14;
269 cifs_inode->server_eof = 0;
270 cifs_inode->uniqueid = 0;
271 cifs_inode->createtime = 0;
272 cifs_inode->epoch = 0;
273#ifdef CONFIG_CIFS_SMB2
274 generate_random_uuid(cifs_inode->lease_key);
275#endif
276
277
278
279
280
281 INIT_LIST_HEAD(&cifs_inode->openFileList);
282 INIT_LIST_HEAD(&cifs_inode->llist);
283 return &cifs_inode->vfs_inode;
284}
285
286static void cifs_i_callback(struct rcu_head *head)
287{
288 struct inode *inode = container_of(head, struct inode, i_rcu);
289 kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
290}
291
292static void
293cifs_destroy_inode(struct inode *inode)
294{
295 call_rcu(&inode->i_rcu, cifs_i_callback);
296}
297
298static void
299cifs_evict_inode(struct inode *inode)
300{
301 truncate_inode_pages_final(&inode->i_data);
302 clear_inode(inode);
303 cifs_fscache_release_inode_cookie(inode);
304}
305
306static void
307cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
308{
309 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
310 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
311
312 seq_puts(s, ",addr=");
313
314 switch (server->dstaddr.ss_family) {
315 case AF_INET:
316 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
317 break;
318 case AF_INET6:
319 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
320 if (sa6->sin6_scope_id)
321 seq_printf(s, "%%%u", sa6->sin6_scope_id);
322 break;
323 default:
324 seq_puts(s, "(unknown)");
325 }
326}
327
328static void
329cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
330{
331 if (ses->sectype == Unspecified) {
332 if (ses->user_name == NULL)
333 seq_puts(s, ",sec=none");
334 return;
335 }
336
337 seq_puts(s, ",sec=");
338
339 switch (ses->sectype) {
340 case LANMAN:
341 seq_puts(s, "lanman");
342 break;
343 case NTLMv2:
344 seq_puts(s, "ntlmv2");
345 break;
346 case NTLM:
347 seq_puts(s, "ntlm");
348 break;
349 case Kerberos:
350 seq_puts(s, "krb5");
351 break;
352 case RawNTLMSSP:
353 seq_puts(s, "ntlmssp");
354 break;
355 default:
356
357 seq_puts(s, "unknown");
358 break;
359 }
360
361 if (ses->sign)
362 seq_puts(s, "i");
363}
364
365static void
366cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
367{
368 seq_puts(s, ",cache=");
369
370 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
371 seq_puts(s, "strict");
372 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
373 seq_puts(s, "none");
374 else
375 seq_puts(s, "loose");
376}
377
378static void
379cifs_show_nls(struct seq_file *s, struct nls_table *cur)
380{
381 struct nls_table *def;
382
383
384 def = load_nls_default();
385 if (def != cur)
386 seq_printf(s, ",iocharset=%s", cur->charset);
387 unload_nls(def);
388}
389
390
391
392
393
394
395static int
396cifs_show_options(struct seq_file *s, struct dentry *root)
397{
398 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
399 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
400 struct sockaddr *srcaddr;
401 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
402
403 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
404 cifs_show_security(s, tcon->ses);
405 cifs_show_cache_flavor(s, cifs_sb);
406
407 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
408 seq_puts(s, ",multiuser");
409 else if (tcon->ses->user_name)
410 seq_show_option(s, "username", tcon->ses->user_name);
411
412 if (tcon->ses->domainName)
413 seq_show_option(s, "domain", tcon->ses->domainName);
414
415 if (srcaddr->sa_family != AF_UNSPEC) {
416 struct sockaddr_in *saddr4;
417 struct sockaddr_in6 *saddr6;
418 saddr4 = (struct sockaddr_in *)srcaddr;
419 saddr6 = (struct sockaddr_in6 *)srcaddr;
420 if (srcaddr->sa_family == AF_INET6)
421 seq_printf(s, ",srcaddr=%pI6c",
422 &saddr6->sin6_addr);
423 else if (srcaddr->sa_family == AF_INET)
424 seq_printf(s, ",srcaddr=%pI4",
425 &saddr4->sin_addr.s_addr);
426 else
427 seq_printf(s, ",srcaddr=BAD-AF:%i",
428 (int)(srcaddr->sa_family));
429 }
430
431 seq_printf(s, ",uid=%u",
432 from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
434 seq_puts(s, ",forceuid");
435 else
436 seq_puts(s, ",noforceuid");
437
438 seq_printf(s, ",gid=%u",
439 from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
441 seq_puts(s, ",forcegid");
442 else
443 seq_puts(s, ",noforcegid");
444
445 cifs_show_address(s, tcon->ses->server);
446
447 if (!tcon->unix_ext)
448 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
449 cifs_sb->mnt_file_mode,
450 cifs_sb->mnt_dir_mode);
451
452 cifs_show_nls(s, cifs_sb->local_nls);
453
454 if (tcon->seal)
455 seq_puts(s, ",seal");
456 if (tcon->nocase)
457 seq_puts(s, ",nocase");
458 if (tcon->retry)
459 seq_puts(s, ",hard");
460 if (tcon->use_persistent)
461 seq_puts(s, ",persistenthandles");
462 else if (tcon->use_resilient)
463 seq_puts(s, ",resilienthandles");
464 if (tcon->unix_ext)
465 seq_puts(s, ",unix");
466 else
467 seq_puts(s, ",nounix");
468 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
469 seq_puts(s, ",posixpaths");
470 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
471 seq_puts(s, ",setuids");
472 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
473 seq_puts(s, ",idsfromsid");
474 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
475 seq_puts(s, ",serverino");
476 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
477 seq_puts(s, ",rwpidforward");
478 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
479 seq_puts(s, ",forcemand");
480 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
481 seq_puts(s, ",nouser_xattr");
482 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
483 seq_puts(s, ",mapchars");
484 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
485 seq_puts(s, ",mapposix");
486 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
487 seq_puts(s, ",sfu");
488 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
489 seq_puts(s, ",nobrl");
490 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
491 seq_puts(s, ",cifsacl");
492 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
493 seq_puts(s, ",dynperm");
494 if (root->d_sb->s_flags & MS_POSIXACL)
495 seq_puts(s, ",acl");
496 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
497 seq_puts(s, ",mfsymlinks");
498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
499 seq_puts(s, ",fsc");
500 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
501 seq_puts(s, ",nostrictsync");
502 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
503 seq_puts(s, ",noperm");
504 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
505 seq_printf(s, ",backupuid=%u",
506 from_kuid_munged(&init_user_ns,
507 cifs_sb->mnt_backupuid));
508 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
509 seq_printf(s, ",backupgid=%u",
510 from_kgid_munged(&init_user_ns,
511 cifs_sb->mnt_backupgid));
512
513 seq_printf(s, ",rsize=%u", cifs_sb->rsize);
514 seq_printf(s, ",wsize=%u", cifs_sb->wsize);
515 seq_printf(s, ",echo_interval=%lu",
516 tcon->ses->server->echo_interval / HZ);
517
518 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
519
520 return 0;
521}
522
523static void cifs_umount_begin(struct super_block *sb)
524{
525 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
526 struct cifs_tcon *tcon;
527
528 if (cifs_sb == NULL)
529 return;
530
531 tcon = cifs_sb_master_tcon(cifs_sb);
532
533 spin_lock(&cifs_tcp_ses_lock);
534 if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
535
536
537
538 spin_unlock(&cifs_tcp_ses_lock);
539 return;
540 } else if (tcon->tc_count == 1)
541 tcon->tidStatus = CifsExiting;
542 spin_unlock(&cifs_tcp_ses_lock);
543
544
545
546 if (tcon->ses && tcon->ses->server) {
547 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
548 wake_up_all(&tcon->ses->server->request_q);
549 wake_up_all(&tcon->ses->server->response_q);
550 msleep(1);
551
552 wake_up_all(&tcon->ses->server->response_q);
553 msleep(1);
554 }
555
556 return;
557}
558
559#ifdef CONFIG_CIFS_STATS2
560static int cifs_show_stats(struct seq_file *s, struct dentry *root)
561{
562
563 return 0;
564}
565#endif
566
567static int cifs_remount(struct super_block *sb, int *flags, char *data)
568{
569 sync_filesystem(sb);
570 *flags |= MS_NODIRATIME;
571 return 0;
572}
573
574static int cifs_drop_inode(struct inode *inode)
575{
576 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
577
578
579 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
580 generic_drop_inode(inode);
581}
582
583static const struct super_operations cifs_super_ops = {
584 .statfs = cifs_statfs,
585 .alloc_inode = cifs_alloc_inode,
586 .destroy_inode = cifs_destroy_inode,
587 .drop_inode = cifs_drop_inode,
588 .evict_inode = cifs_evict_inode,
589
590
591
592
593 .show_options = cifs_show_options,
594 .umount_begin = cifs_umount_begin,
595 .remount_fs = cifs_remount,
596#ifdef CONFIG_CIFS_STATS2
597 .show_stats = cifs_show_stats,
598#endif
599};
600
601
602
603
604
605static struct dentry *
606cifs_get_root(struct smb_vol *vol, struct super_block *sb)
607{
608 struct dentry *dentry;
609 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
610 char *full_path = NULL;
611 char *s, *p;
612 char sep;
613
614 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
615 return dget(sb->s_root);
616
617 full_path = cifs_build_path_to_root(vol, cifs_sb,
618 cifs_sb_master_tcon(cifs_sb), 0);
619 if (full_path == NULL)
620 return ERR_PTR(-ENOMEM);
621
622 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
623
624 sep = CIFS_DIR_SEP(cifs_sb);
625 dentry = dget(sb->s_root);
626 p = s = full_path;
627
628 do {
629 struct inode *dir = d_inode(dentry);
630 struct dentry *child;
631
632 if (!dir) {
633 dput(dentry);
634 dentry = ERR_PTR(-ENOENT);
635 break;
636 }
637 if (!S_ISDIR(dir->i_mode)) {
638 dput(dentry);
639 dentry = ERR_PTR(-ENOTDIR);
640 break;
641 }
642
643
644 while (*s == sep)
645 s++;
646 if (!*s)
647 break;
648 p = s++;
649
650 while (*s && *s != sep)
651 s++;
652
653 child = lookup_one_len_unlocked(p, dentry, s - p);
654 dput(dentry);
655 dentry = child;
656 } while (!IS_ERR(dentry));
657 kfree(full_path);
658 return dentry;
659}
660
661static int cifs_set_super(struct super_block *sb, void *data)
662{
663 struct cifs_mnt_data *mnt_data = data;
664 sb->s_fs_info = mnt_data->cifs_sb;
665 return set_anon_super(sb, NULL);
666}
667
668static struct dentry *
669cifs_do_mount(struct file_system_type *fs_type,
670 int flags, const char *dev_name, void *data)
671{
672 int rc;
673 struct super_block *sb;
674 struct cifs_sb_info *cifs_sb;
675 struct smb_vol *volume_info;
676 struct cifs_mnt_data mnt_data;
677 struct dentry *root;
678
679 cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
680
681 volume_info = cifs_get_volume_info((char *)data, dev_name);
682 if (IS_ERR(volume_info))
683 return ERR_CAST(volume_info);
684
685 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
686 if (cifs_sb == NULL) {
687 root = ERR_PTR(-ENOMEM);
688 goto out_nls;
689 }
690
691 cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
692 if (cifs_sb->mountdata == NULL) {
693 root = ERR_PTR(-ENOMEM);
694 goto out_free;
695 }
696
697 rc = cifs_setup_cifs_sb(volume_info, cifs_sb);
698 if (rc) {
699 root = ERR_PTR(rc);
700 goto out_free;
701 }
702
703 rc = cifs_mount(cifs_sb, volume_info);
704 if (rc) {
705 if (!(flags & MS_SILENT))
706 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
707 rc);
708 root = ERR_PTR(rc);
709 goto out_free;
710 }
711
712 mnt_data.vol = volume_info;
713 mnt_data.cifs_sb = cifs_sb;
714 mnt_data.flags = flags;
715
716
717 flags |= MS_NODIRATIME | MS_NOATIME;
718
719 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
720 if (IS_ERR(sb)) {
721 root = ERR_CAST(sb);
722 cifs_umount(cifs_sb);
723 goto out;
724 }
725
726 if (sb->s_root) {
727 cifs_dbg(FYI, "Use existing superblock\n");
728 cifs_umount(cifs_sb);
729 } else {
730 rc = cifs_read_super(sb);
731 if (rc) {
732 root = ERR_PTR(rc);
733 goto out_super;
734 }
735
736 sb->s_flags |= MS_ACTIVE;
737 }
738
739 root = cifs_get_root(volume_info, sb);
740 if (IS_ERR(root))
741 goto out_super;
742
743 cifs_dbg(FYI, "dentry root is: %p\n", root);
744 goto out;
745
746out_super:
747 deactivate_locked_super(sb);
748out:
749 cifs_cleanup_volume_info(volume_info);
750 return root;
751
752out_free:
753 kfree(cifs_sb->prepath);
754 kfree(cifs_sb->mountdata);
755 kfree(cifs_sb);
756out_nls:
757 unload_nls(volume_info->local_nls);
758 goto out;
759}
760
761static ssize_t
762cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
763{
764 ssize_t rc;
765 struct inode *inode = file_inode(iocb->ki_filp);
766
767 if (iocb->ki_filp->f_flags & O_DIRECT)
768 return cifs_user_readv(iocb, iter);
769
770 rc = cifs_revalidate_mapping(inode);
771 if (rc)
772 return rc;
773
774 return generic_file_read_iter(iocb, iter);
775}
776
777static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
778{
779 struct inode *inode = file_inode(iocb->ki_filp);
780 struct cifsInodeInfo *cinode = CIFS_I(inode);
781 ssize_t written;
782 int rc;
783
784 if (iocb->ki_filp->f_flags & O_DIRECT) {
785 written = cifs_user_writev(iocb, from);
786 if (written > 0 && CIFS_CACHE_READ(cinode)) {
787 cifs_zap_mapping(inode);
788 cifs_dbg(FYI,
789 "Set no oplock for inode=%p after a write operation\n",
790 inode);
791 cinode->oplock = 0;
792 }
793 return written;
794 }
795
796 written = cifs_get_writer(cinode);
797 if (written)
798 return written;
799
800 written = generic_file_write_iter(iocb, from);
801
802 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
803 goto out;
804
805 rc = filemap_fdatawrite(inode->i_mapping);
806 if (rc)
807 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
808 rc, inode);
809
810out:
811 cifs_put_writer(cinode);
812 return written;
813}
814
815static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
816{
817
818
819
820
821 if (whence != SEEK_SET && whence != SEEK_CUR) {
822 int rc;
823 struct inode *inode = file_inode(file);
824
825
826
827
828
829 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
830 inode->i_mapping->nrpages != 0) {
831 rc = filemap_fdatawait(inode->i_mapping);
832 if (rc) {
833 mapping_set_error(inode->i_mapping, rc);
834 return rc;
835 }
836 }
837
838
839
840
841
842 CIFS_I(inode)->time = 0;
843
844 rc = cifs_revalidate_file_attr(file);
845 if (rc < 0)
846 return (loff_t)rc;
847 }
848 return generic_file_llseek(file, offset, whence);
849}
850
851static int
852cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
853{
854
855
856
857
858 struct inode *inode = file_inode(file);
859 struct cifsFileInfo *cfile = file->private_data;
860
861 if (!(S_ISREG(inode->i_mode)))
862 return -EINVAL;
863
864
865 if (arg == F_UNLCK ||
866 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
867 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
868 return generic_setlease(file, arg, lease, priv);
869 else if (tlink_tcon(cfile->tlink)->local_lease &&
870 !CIFS_CACHE_READ(CIFS_I(inode)))
871
872
873
874
875
876
877
878
879 return generic_setlease(file, arg, lease, priv);
880 else
881 return -EAGAIN;
882}
883
884struct file_system_type cifs_fs_type = {
885 .owner = THIS_MODULE,
886 .name = "cifs",
887 .mount = cifs_do_mount,
888 .kill_sb = cifs_kill_sb,
889
890};
891MODULE_ALIAS_FS("cifs");
892const struct inode_operations cifs_dir_inode_ops = {
893 .create = cifs_create,
894 .atomic_open = cifs_atomic_open,
895 .lookup = cifs_lookup,
896 .getattr = cifs_getattr,
897 .unlink = cifs_unlink,
898 .link = cifs_hardlink,
899 .mkdir = cifs_mkdir,
900 .rmdir = cifs_rmdir,
901 .rename = cifs_rename2,
902 .permission = cifs_permission,
903 .setattr = cifs_setattr,
904 .symlink = cifs_symlink,
905 .mknod = cifs_mknod,
906 .listxattr = cifs_listxattr,
907};
908
909const struct inode_operations cifs_file_inode_ops = {
910 .setattr = cifs_setattr,
911 .getattr = cifs_getattr,
912 .permission = cifs_permission,
913 .listxattr = cifs_listxattr,
914};
915
916const struct inode_operations cifs_symlink_inode_ops = {
917 .get_link = cifs_get_link,
918 .permission = cifs_permission,
919 .listxattr = cifs_listxattr,
920};
921
922static int cifs_clone_file_range(struct file *src_file, loff_t off,
923 struct file *dst_file, loff_t destoff, u64 len)
924{
925 struct inode *src_inode = file_inode(src_file);
926 struct inode *target_inode = file_inode(dst_file);
927 struct cifsFileInfo *smb_file_src = src_file->private_data;
928 struct cifsFileInfo *smb_file_target = dst_file->private_data;
929 struct cifs_tcon *target_tcon = tlink_tcon(smb_file_target->tlink);
930 unsigned int xid;
931 int rc;
932
933 cifs_dbg(FYI, "clone range\n");
934
935 xid = get_xid();
936
937 if (!src_file->private_data || !dst_file->private_data) {
938 rc = -EBADF;
939 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
940 goto out;
941 }
942
943
944
945
946
947
948 lock_two_nondirectories(target_inode, src_inode);
949
950 if (len == 0)
951 len = src_inode->i_size - off;
952
953 cifs_dbg(FYI, "about to flush pages\n");
954
955 truncate_inode_pages_range(&target_inode->i_data, destoff,
956 PAGE_ALIGN(destoff + len)-1);
957
958 if (target_tcon->ses->server->ops->duplicate_extents)
959 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
960 smb_file_src, smb_file_target, off, len, destoff);
961 else
962 rc = -EOPNOTSUPP;
963
964
965
966 CIFS_I(target_inode)->time = 0;
967
968
969 unlock_two_nondirectories(src_inode, target_inode);
970out:
971 free_xid(xid);
972 return rc;
973}
974
975ssize_t cifs_file_copychunk_range(unsigned int xid,
976 struct file *src_file, loff_t off,
977 struct file *dst_file, loff_t destoff,
978 size_t len, unsigned int flags)
979{
980 struct inode *src_inode = file_inode(src_file);
981 struct inode *target_inode = file_inode(dst_file);
982 struct cifsFileInfo *smb_file_src;
983 struct cifsFileInfo *smb_file_target;
984 struct cifs_tcon *src_tcon;
985 struct cifs_tcon *target_tcon;
986 ssize_t rc;
987
988 cifs_dbg(FYI, "copychunk range\n");
989
990 if (src_inode == target_inode) {
991 rc = -EINVAL;
992 goto out;
993 }
994
995 if (!src_file->private_data || !dst_file->private_data) {
996 rc = -EBADF;
997 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
998 goto out;
999 }
1000
1001 rc = -EXDEV;
1002 smb_file_target = dst_file->private_data;
1003 smb_file_src = src_file->private_data;
1004 src_tcon = tlink_tcon(smb_file_src->tlink);
1005 target_tcon = tlink_tcon(smb_file_target->tlink);
1006
1007 if (src_tcon->ses != target_tcon->ses) {
1008 cifs_dbg(VFS, "source and target of copy not on same server\n");
1009 goto out;
1010 }
1011
1012
1013
1014
1015
1016
1017 lock_two_nondirectories(target_inode, src_inode);
1018
1019 cifs_dbg(FYI, "about to flush pages\n");
1020
1021 truncate_inode_pages(&target_inode->i_data, 0);
1022
1023 if (target_tcon->ses->server->ops->copychunk_range)
1024 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1025 smb_file_src, smb_file_target, off, len, destoff);
1026 else
1027 rc = -EOPNOTSUPP;
1028
1029
1030
1031
1032 CIFS_I(target_inode)->time = 0;
1033
1034
1035
1036 unlock_two_nondirectories(src_inode, target_inode);
1037
1038out:
1039 return rc;
1040}
1041
1042static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1043 struct file *dst_file, loff_t destoff,
1044 size_t len, unsigned int flags)
1045{
1046 unsigned int xid = get_xid();
1047 ssize_t rc;
1048
1049 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1050 len, flags);
1051 free_xid(xid);
1052 return rc;
1053}
1054
1055const struct file_operations cifs_file_ops = {
1056 .read_iter = cifs_loose_read_iter,
1057 .write_iter = cifs_file_write_iter,
1058 .open = cifs_open,
1059 .release = cifs_close,
1060 .lock = cifs_lock,
1061 .fsync = cifs_fsync,
1062 .flush = cifs_flush,
1063 .mmap = cifs_file_mmap,
1064 .splice_read = generic_file_splice_read,
1065 .llseek = cifs_llseek,
1066 .unlocked_ioctl = cifs_ioctl,
1067 .copy_file_range = cifs_copy_file_range,
1068 .clone_file_range = cifs_clone_file_range,
1069 .setlease = cifs_setlease,
1070 .fallocate = cifs_fallocate,
1071};
1072
1073const struct file_operations cifs_file_strict_ops = {
1074 .read_iter = cifs_strict_readv,
1075 .write_iter = cifs_strict_writev,
1076 .open = cifs_open,
1077 .release = cifs_close,
1078 .lock = cifs_lock,
1079 .fsync = cifs_strict_fsync,
1080 .flush = cifs_flush,
1081 .mmap = cifs_file_strict_mmap,
1082 .splice_read = generic_file_splice_read,
1083 .llseek = cifs_llseek,
1084 .unlocked_ioctl = cifs_ioctl,
1085 .copy_file_range = cifs_copy_file_range,
1086 .clone_file_range = cifs_clone_file_range,
1087 .setlease = cifs_setlease,
1088 .fallocate = cifs_fallocate,
1089};
1090
1091const struct file_operations cifs_file_direct_ops = {
1092
1093 .read_iter = cifs_user_readv,
1094 .write_iter = cifs_user_writev,
1095 .open = cifs_open,
1096 .release = cifs_close,
1097 .lock = cifs_lock,
1098 .fsync = cifs_fsync,
1099 .flush = cifs_flush,
1100 .mmap = cifs_file_mmap,
1101 .splice_read = generic_file_splice_read,
1102 .unlocked_ioctl = cifs_ioctl,
1103 .copy_file_range = cifs_copy_file_range,
1104 .clone_file_range = cifs_clone_file_range,
1105 .llseek = cifs_llseek,
1106 .setlease = cifs_setlease,
1107 .fallocate = cifs_fallocate,
1108};
1109
1110const struct file_operations cifs_file_nobrl_ops = {
1111 .read_iter = cifs_loose_read_iter,
1112 .write_iter = cifs_file_write_iter,
1113 .open = cifs_open,
1114 .release = cifs_close,
1115 .fsync = cifs_fsync,
1116 .flush = cifs_flush,
1117 .mmap = cifs_file_mmap,
1118 .splice_read = generic_file_splice_read,
1119 .llseek = cifs_llseek,
1120 .unlocked_ioctl = cifs_ioctl,
1121 .copy_file_range = cifs_copy_file_range,
1122 .clone_file_range = cifs_clone_file_range,
1123 .setlease = cifs_setlease,
1124 .fallocate = cifs_fallocate,
1125};
1126
1127const struct file_operations cifs_file_strict_nobrl_ops = {
1128 .read_iter = cifs_strict_readv,
1129 .write_iter = cifs_strict_writev,
1130 .open = cifs_open,
1131 .release = cifs_close,
1132 .fsync = cifs_strict_fsync,
1133 .flush = cifs_flush,
1134 .mmap = cifs_file_strict_mmap,
1135 .splice_read = generic_file_splice_read,
1136 .llseek = cifs_llseek,
1137 .unlocked_ioctl = cifs_ioctl,
1138 .copy_file_range = cifs_copy_file_range,
1139 .clone_file_range = cifs_clone_file_range,
1140 .setlease = cifs_setlease,
1141 .fallocate = cifs_fallocate,
1142};
1143
1144const struct file_operations cifs_file_direct_nobrl_ops = {
1145
1146 .read_iter = cifs_user_readv,
1147 .write_iter = cifs_user_writev,
1148 .open = cifs_open,
1149 .release = cifs_close,
1150 .fsync = cifs_fsync,
1151 .flush = cifs_flush,
1152 .mmap = cifs_file_mmap,
1153 .splice_read = generic_file_splice_read,
1154 .unlocked_ioctl = cifs_ioctl,
1155 .copy_file_range = cifs_copy_file_range,
1156 .clone_file_range = cifs_clone_file_range,
1157 .llseek = cifs_llseek,
1158 .setlease = cifs_setlease,
1159 .fallocate = cifs_fallocate,
1160};
1161
1162const struct file_operations cifs_dir_ops = {
1163 .iterate_shared = cifs_readdir,
1164 .release = cifs_closedir,
1165 .read = generic_read_dir,
1166 .unlocked_ioctl = cifs_ioctl,
1167 .copy_file_range = cifs_copy_file_range,
1168 .clone_file_range = cifs_clone_file_range,
1169 .llseek = generic_file_llseek,
1170};
1171
1172static void
1173cifs_init_once(void *inode)
1174{
1175 struct cifsInodeInfo *cifsi = inode;
1176
1177 inode_init_once(&cifsi->vfs_inode);
1178 init_rwsem(&cifsi->lock_sem);
1179}
1180
1181static int __init
1182cifs_init_inodecache(void)
1183{
1184 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1185 sizeof(struct cifsInodeInfo),
1186 0, (SLAB_RECLAIM_ACCOUNT|
1187 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1188 cifs_init_once);
1189 if (cifs_inode_cachep == NULL)
1190 return -ENOMEM;
1191
1192 return 0;
1193}
1194
1195static void
1196cifs_destroy_inodecache(void)
1197{
1198
1199
1200
1201
1202 rcu_barrier();
1203 kmem_cache_destroy(cifs_inode_cachep);
1204}
1205
1206static int
1207cifs_init_request_bufs(void)
1208{
1209 size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1210#ifdef CONFIG_CIFS_SMB2
1211
1212
1213
1214
1215 max_hdr_size = MAX_SMB2_HDR_SIZE;
1216#endif
1217 if (CIFSMaxBufSize < 8192) {
1218
1219
1220 CIFSMaxBufSize = 8192;
1221 } else if (CIFSMaxBufSize > 1024*127) {
1222 CIFSMaxBufSize = 1024 * 127;
1223 } else {
1224 CIFSMaxBufSize &= 0x1FE00;
1225 }
1226
1227
1228
1229
1230 cifs_req_cachep = kmem_cache_create("cifs_request",
1231 CIFSMaxBufSize + max_hdr_size, 0,
1232 SLAB_HWCACHE_ALIGN, NULL);
1233 if (cifs_req_cachep == NULL)
1234 return -ENOMEM;
1235
1236 if (cifs_min_rcv < 1)
1237 cifs_min_rcv = 1;
1238 else if (cifs_min_rcv > 64) {
1239 cifs_min_rcv = 64;
1240 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1241 }
1242
1243 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1244 cifs_req_cachep);
1245
1246 if (cifs_req_poolp == NULL) {
1247 kmem_cache_destroy(cifs_req_cachep);
1248 return -ENOMEM;
1249 }
1250
1251
1252
1253
1254
1255
1256
1257
1258 cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1259 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1260 NULL);
1261 if (cifs_sm_req_cachep == NULL) {
1262 mempool_destroy(cifs_req_poolp);
1263 kmem_cache_destroy(cifs_req_cachep);
1264 return -ENOMEM;
1265 }
1266
1267 if (cifs_min_small < 2)
1268 cifs_min_small = 2;
1269 else if (cifs_min_small > 256) {
1270 cifs_min_small = 256;
1271 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1272 }
1273
1274 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1275 cifs_sm_req_cachep);
1276
1277 if (cifs_sm_req_poolp == NULL) {
1278 mempool_destroy(cifs_req_poolp);
1279 kmem_cache_destroy(cifs_req_cachep);
1280 kmem_cache_destroy(cifs_sm_req_cachep);
1281 return -ENOMEM;
1282 }
1283
1284 return 0;
1285}
1286
1287static void
1288cifs_destroy_request_bufs(void)
1289{
1290 mempool_destroy(cifs_req_poolp);
1291 kmem_cache_destroy(cifs_req_cachep);
1292 mempool_destroy(cifs_sm_req_poolp);
1293 kmem_cache_destroy(cifs_sm_req_cachep);
1294}
1295
1296static int
1297cifs_init_mids(void)
1298{
1299 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1300 sizeof(struct mid_q_entry), 0,
1301 SLAB_HWCACHE_ALIGN, NULL);
1302 if (cifs_mid_cachep == NULL)
1303 return -ENOMEM;
1304
1305
1306 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1307 if (cifs_mid_poolp == NULL) {
1308 kmem_cache_destroy(cifs_mid_cachep);
1309 return -ENOMEM;
1310 }
1311
1312 return 0;
1313}
1314
1315static void
1316cifs_destroy_mids(void)
1317{
1318 mempool_destroy(cifs_mid_poolp);
1319 kmem_cache_destroy(cifs_mid_cachep);
1320}
1321
1322static int __init
1323init_cifs(void)
1324{
1325 int rc = 0;
1326 cifs_proc_init();
1327 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1328#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL
1329 INIT_LIST_HEAD(&GlobalDnotifyReqList);
1330 INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1331#endif
1332
1333
1334
1335 atomic_set(&sesInfoAllocCount, 0);
1336 atomic_set(&tconInfoAllocCount, 0);
1337 atomic_set(&tcpSesAllocCount, 0);
1338 atomic_set(&tcpSesReconnectCount, 0);
1339 atomic_set(&tconInfoReconnectCount, 0);
1340
1341 atomic_set(&bufAllocCount, 0);
1342 atomic_set(&smBufAllocCount, 0);
1343#ifdef CONFIG_CIFS_STATS2
1344 atomic_set(&totBufAllocCount, 0);
1345 atomic_set(&totSmBufAllocCount, 0);
1346#endif
1347
1348 atomic_set(&midCount, 0);
1349 GlobalCurrentXid = 0;
1350 GlobalTotalActiveXid = 0;
1351 GlobalMaxActiveXid = 0;
1352 spin_lock_init(&cifs_tcp_ses_lock);
1353 spin_lock_init(&GlobalMid_Lock);
1354
1355 get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
1356
1357 if (cifs_max_pending < 2) {
1358 cifs_max_pending = 2;
1359 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1360 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1361 cifs_max_pending = CIFS_MAX_REQ;
1362 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1363 CIFS_MAX_REQ);
1364 }
1365
1366 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1367 if (!cifsiod_wq) {
1368 rc = -ENOMEM;
1369 goto out_clean_proc;
1370 }
1371
1372 rc = cifs_fscache_register();
1373 if (rc)
1374 goto out_destroy_wq;
1375
1376 rc = cifs_init_inodecache();
1377 if (rc)
1378 goto out_unreg_fscache;
1379
1380 rc = cifs_init_mids();
1381 if (rc)
1382 goto out_destroy_inodecache;
1383
1384 rc = cifs_init_request_bufs();
1385 if (rc)
1386 goto out_destroy_mids;
1387
1388#ifdef CONFIG_CIFS_UPCALL
1389 rc = init_cifs_spnego();
1390 if (rc)
1391 goto out_destroy_request_bufs;
1392#endif
1393
1394#ifdef CONFIG_CIFS_ACL
1395 rc = init_cifs_idmap();
1396 if (rc)
1397 goto out_register_key_type;
1398#endif
1399
1400 rc = register_filesystem(&cifs_fs_type);
1401 if (rc)
1402 goto out_init_cifs_idmap;
1403
1404 return 0;
1405
1406out_init_cifs_idmap:
1407#ifdef CONFIG_CIFS_ACL
1408 exit_cifs_idmap();
1409out_register_key_type:
1410#endif
1411#ifdef CONFIG_CIFS_UPCALL
1412 exit_cifs_spnego();
1413out_destroy_request_bufs:
1414#endif
1415 cifs_destroy_request_bufs();
1416out_destroy_mids:
1417 cifs_destroy_mids();
1418out_destroy_inodecache:
1419 cifs_destroy_inodecache();
1420out_unreg_fscache:
1421 cifs_fscache_unregister();
1422out_destroy_wq:
1423 destroy_workqueue(cifsiod_wq);
1424out_clean_proc:
1425 cifs_proc_clean();
1426 return rc;
1427}
1428
1429static void __exit
1430exit_cifs(void)
1431{
1432 cifs_dbg(NOISY, "exit_cifs\n");
1433 unregister_filesystem(&cifs_fs_type);
1434 cifs_dfs_release_automount_timer();
1435#ifdef CONFIG_CIFS_ACL
1436 exit_cifs_idmap();
1437#endif
1438#ifdef CONFIG_CIFS_UPCALL
1439 unregister_key_type(&cifs_spnego_key_type);
1440#endif
1441 cifs_destroy_request_bufs();
1442 cifs_destroy_mids();
1443 cifs_destroy_inodecache();
1444 cifs_fscache_unregister();
1445 destroy_workqueue(cifsiod_wq);
1446 cifs_proc_clean();
1447}
1448
1449MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1450MODULE_LICENSE("GPL");
1451MODULE_DESCRIPTION
1452 ("VFS to access servers complying with the SNIA CIFS Specification "
1453 "e.g. Samba and Windows");
1454MODULE_VERSION(CIFS_VERSION);
1455MODULE_SOFTDEP("pre: arc4");
1456MODULE_SOFTDEP("pre: des");
1457MODULE_SOFTDEP("pre: ecb");
1458MODULE_SOFTDEP("pre: hmac");
1459MODULE_SOFTDEP("pre: md4");
1460MODULE_SOFTDEP("pre: md5");
1461MODULE_SOFTDEP("pre: nls");
1462#ifdef CONFIG_CIFS_SMB2
1463MODULE_SOFTDEP("pre: aes");
1464MODULE_SOFTDEP("pre: cmac");
1465MODULE_SOFTDEP("pre: sha256");
1466MODULE_SOFTDEP("pre: aead2");
1467MODULE_SOFTDEP("pre: ccm");
1468#endif
1469module_init(init_cifs)
1470module_exit(exit_cifs)
1471