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