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