1 // SPDX-License-Identifier: LGPL-2.1
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Common Internet FileSystem (CIFS) client
11 /* Note that BB means BUGBUG (ie something to fix eventually) */
13 #include <linux/module.h>
15 #include <linux/filelock.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 <uapi/linux/magic.h>
34 #define DECLARE_GLOBALS_HERE
36 #include "cifsproto.h"
37 #include "cifs_debug.h"
38 #include "cifs_fs_sb.h"
40 #include <linux/key-type.h>
41 #include "cifs_spnego.h"
43 #ifdef CONFIG_CIFS_DFS_UPCALL
44 #include "dfs_cache.h"
46 #ifdef CONFIG_CIFS_SWN_UPCALL
49 #include "fs_context.h"
50 #include "cached_dir.h"
53 * DOS dates from 1980/1/1 through 2107/12/31
54 * Protocol specifications indicate the range should be to 119, which
55 * limits maximum year to 2099. But this range has not been checked.
57 #define SMB_DATE_MAX (127<<9 | 12<<5 | 31)
58 #define SMB_DATE_MIN (0<<9 | 1<<5 | 1)
59 #define SMB_TIME_MAX (23<<11 | 59<<5 | 29)
63 bool enable_oplocks = true;
64 bool linuxExtEnabled = true;
65 bool lookupCacheEnabled = true;
66 bool disable_legacy_dialects; /* false by default */
67 bool enable_gcm_256 = true;
68 bool require_gcm_256; /* false by default */
69 bool enable_negotiate_signing; /* false by default */
70 unsigned int global_secflags = CIFSSEC_DEF;
71 /* unsigned int ntlmv2_support = 0; */
72 unsigned int sign_CIFS_PDUs = 1;
75 * Global transaction id (XID) information
77 unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
78 unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
79 unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
80 spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */
83 * Global counters, updated atomically
85 atomic_t sesInfoAllocCount;
86 atomic_t tconInfoAllocCount;
87 atomic_t tcpSesNextId;
88 atomic_t tcpSesAllocCount;
89 atomic_t tcpSesReconnectCount;
90 atomic_t tconInfoReconnectCount;
93 atomic_t buf_alloc_count;
94 atomic_t small_buf_alloc_count;
95 #ifdef CONFIG_CIFS_STATS2
96 atomic_t total_buf_alloc_count;
97 atomic_t total_small_buf_alloc_count;
99 struct list_head cifs_tcp_ses_list;
100 spinlock_t cifs_tcp_ses_lock;
101 static const struct super_operations cifs_super_ops;
102 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
103 module_param(CIFSMaxBufSize, uint, 0444);
104 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "
105 "for CIFS requests. "
106 "Default: 16384 Range: 8192 to 130048");
107 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
108 module_param(cifs_min_rcv, uint, 0444);
109 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
111 unsigned int cifs_min_small = 30;
112 module_param(cifs_min_small, uint, 0444);
113 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
115 unsigned int cifs_max_pending = CIFS_MAX_REQ;
116 module_param(cifs_max_pending, uint, 0444);
117 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "
118 "CIFS/SMB1 dialect (N/A for SMB3) "
119 "Default: 32767 Range: 2 to 32767.");
120 #ifdef CONFIG_CIFS_STATS2
121 unsigned int slow_rsp_threshold = 1;
122 module_param(slow_rsp_threshold, uint, 0644);
123 MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "
124 "before logging that a response is delayed. "
125 "Default: 1 (if set to 0 disables msg).");
128 module_param(enable_oplocks, bool, 0644);
129 MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
131 module_param(enable_gcm_256, bool, 0644);
132 MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: n/N/0");
134 module_param(require_gcm_256, bool, 0644);
135 MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");
137 module_param(enable_negotiate_signing, bool, 0644);
138 MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");
140 module_param(disable_legacy_dialects, bool, 0644);
141 MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "
142 "helpful to restrict the ability to "
143 "override the default dialects (SMB2.1, "
144 "SMB3 and SMB3.02) on mount with old "
145 "dialects (CIFS/SMB1 and SMB2) since "
146 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"
147 " and less secure. Default: n/N/0");
149 extern mempool_t *cifs_sm_req_poolp;
150 extern mempool_t *cifs_req_poolp;
151 extern mempool_t *cifs_mid_poolp;
153 struct workqueue_struct *cifsiod_wq;
154 struct workqueue_struct *decrypt_wq;
155 struct workqueue_struct *fileinfo_put_wq;
156 struct workqueue_struct *cifsoplockd_wq;
157 struct workqueue_struct *deferredclose_wq;
158 __u32 cifs_lock_secret;
161 * Bumps refcount for cifs super block.
162 * Note that it should be only called if a referece to VFS super block is
163 * already held, e.g. in open-type syscalls context. Otherwise it can race with
164 * atomic_dec_and_test in deactivate_locked_super.
167 cifs_sb_active(struct super_block *sb)
169 struct cifs_sb_info *server = CIFS_SB(sb);
171 if (atomic_inc_return(&server->active) == 1)
172 atomic_inc(&sb->s_active);
176 cifs_sb_deactive(struct super_block *sb)
178 struct cifs_sb_info *server = CIFS_SB(sb);
180 if (atomic_dec_and_test(&server->active))
181 deactivate_super(sb);
185 cifs_read_super(struct super_block *sb)
188 struct cifs_sb_info *cifs_sb;
189 struct cifs_tcon *tcon;
190 struct timespec64 ts;
193 cifs_sb = CIFS_SB(sb);
194 tcon = cifs_sb_master_tcon(cifs_sb);
196 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
197 sb->s_flags |= SB_POSIXACL;
199 if (tcon->snapshot_time)
200 sb->s_flags |= SB_RDONLY;
202 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
203 sb->s_maxbytes = MAX_LFS_FILESIZE;
205 sb->s_maxbytes = MAX_NON_LFS;
208 * Some very old servers like DOS and OS/2 used 2 second granularity
209 * (while all current servers use 100ns granularity - see MS-DTYP)
210 * but 1 second is the maximum allowed granularity for the VFS
211 * so for old servers set time granularity to 1 second while for
212 * everything else (current servers) set it to 100ns.
214 if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&
215 ((tcon->ses->capabilities &
216 tcon->ses->server->vals->cap_nt_find) == 0) &&
218 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */
219 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);
220 sb->s_time_min = ts.tv_sec;
221 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),
222 cpu_to_le16(SMB_TIME_MAX), 0);
223 sb->s_time_max = ts.tv_sec;
226 * Almost every server, including all SMB2+, uses DCE TIME
227 * ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC
229 sb->s_time_gran = 100;
230 ts = cifs_NTtimeToUnix(0);
231 sb->s_time_min = ts.tv_sec;
232 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));
233 sb->s_time_max = ts.tv_sec;
236 sb->s_magic = CIFS_SUPER_MAGIC;
237 sb->s_op = &cifs_super_ops;
238 sb->s_xattr = cifs_xattr_handlers;
239 rc = super_setup_bdi(sb);
242 /* tune readahead according to rsize if readahead size not set on mount */
243 if (cifs_sb->ctx->rsize == 0)
244 cifs_sb->ctx->rsize =
245 tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);
246 if (cifs_sb->ctx->rasize)
247 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;
249 sb->s_bdi->ra_pages = cifs_sb->ctx->rsize / PAGE_SIZE;
251 sb->s_blocksize = CIFS_MAX_MSGSIZE;
252 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */
253 inode = cifs_root_iget(sb);
261 sb->s_d_op = &cifs_ci_dentry_ops;
263 sb->s_d_op = &cifs_dentry_ops;
265 sb->s_root = d_make_root(inode);
271 #ifdef CONFIG_CIFS_NFSD_EXPORT
272 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
273 cifs_dbg(FYI, "export ops supported\n");
274 sb->s_export_op = &cifs_export_ops;
276 #endif /* CONFIG_CIFS_NFSD_EXPORT */
281 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
285 static void cifs_kill_sb(struct super_block *sb)
287 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
290 * We ned to release all dentries for the cached directories
291 * before we kill the sb.
294 close_all_cached_dirs(cifs_sb);
296 /* finally release root dentry */
298 cifs_sb->root = NULL;
302 cifs_umount(cifs_sb);
306 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
308 struct super_block *sb = dentry->d_sb;
309 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
310 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
311 struct TCP_Server_Info *server = tcon->ses->server;
317 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)
319 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
321 buf->f_namelen = PATH_MAX;
323 buf->f_fsid.val[0] = tcon->vol_serial_number;
324 /* are using part of create time for more randomness, see man statfs */
325 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);
327 buf->f_files = 0; /* undefined */
328 buf->f_ffree = 0; /* unlimited */
330 if (server->ops->queryfs)
331 rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
337 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
339 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
340 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
341 struct TCP_Server_Info *server = tcon->ses->server;
343 if (server->ops->fallocate)
344 return server->ops->fallocate(file, tcon, mode, off, len);
349 static int cifs_permission(struct mnt_idmap *idmap,
350 struct inode *inode, int mask)
352 struct cifs_sb_info *cifs_sb;
354 cifs_sb = CIFS_SB(inode->i_sb);
356 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
357 if ((mask & MAY_EXEC) && !execute_ok(inode))
361 } else /* file mode might have been restricted at mount time
362 on the client (above and beyond ACL on servers) for
363 servers which do not support setting and viewing mode bits,
364 so allowing client to check permissions is useful */
365 return generic_permission(&nop_mnt_idmap, inode, mask);
368 static struct kmem_cache *cifs_inode_cachep;
369 static struct kmem_cache *cifs_req_cachep;
370 static struct kmem_cache *cifs_mid_cachep;
371 static struct kmem_cache *cifs_sm_req_cachep;
372 mempool_t *cifs_sm_req_poolp;
373 mempool_t *cifs_req_poolp;
374 mempool_t *cifs_mid_poolp;
376 static struct inode *
377 cifs_alloc_inode(struct super_block *sb)
379 struct cifsInodeInfo *cifs_inode;
380 cifs_inode = alloc_inode_sb(sb, cifs_inode_cachep, GFP_KERNEL);
383 cifs_inode->cifsAttrs = 0x20; /* default */
384 cifs_inode->time = 0;
386 * Until the file is open and we have gotten oplock info back from the
387 * server, can not assume caching of file data or metadata.
389 cifs_set_oplock_level(cifs_inode, 0);
390 cifs_inode->flags = 0;
391 spin_lock_init(&cifs_inode->writers_lock);
392 cifs_inode->writers = 0;
393 cifs_inode->netfs.inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */
394 cifs_inode->server_eof = 0;
395 cifs_inode->uniqueid = 0;
396 cifs_inode->createtime = 0;
397 cifs_inode->epoch = 0;
398 spin_lock_init(&cifs_inode->open_file_lock);
399 generate_random_uuid(cifs_inode->lease_key);
400 cifs_inode->symlink_target = NULL;
403 * Can not set i_flags here - they get immediately overwritten to zero
406 /* cifs_inode->netfs.inode.i_flags = S_NOATIME | S_NOCMTIME; */
407 INIT_LIST_HEAD(&cifs_inode->openFileList);
408 INIT_LIST_HEAD(&cifs_inode->llist);
409 INIT_LIST_HEAD(&cifs_inode->deferred_closes);
410 spin_lock_init(&cifs_inode->deferred_lock);
411 return &cifs_inode->netfs.inode;
415 cifs_free_inode(struct inode *inode)
417 struct cifsInodeInfo *cinode = CIFS_I(inode);
419 if (S_ISLNK(inode->i_mode))
420 kfree(cinode->symlink_target);
421 kmem_cache_free(cifs_inode_cachep, cinode);
425 cifs_evict_inode(struct inode *inode)
427 truncate_inode_pages_final(&inode->i_data);
428 if (inode->i_state & I_PINNING_FSCACHE_WB)
429 cifs_fscache_unuse_inode_cookie(inode, true);
430 cifs_fscache_release_inode_cookie(inode);
435 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
437 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
438 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
440 seq_puts(s, ",addr=");
442 switch (server->dstaddr.ss_family) {
444 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
447 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
448 if (sa6->sin6_scope_id)
449 seq_printf(s, "%%%u", sa6->sin6_scope_id);
452 seq_puts(s, "(unknown)");
455 seq_puts(s, ",rdma");
459 cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
461 if (ses->sectype == Unspecified) {
462 if (ses->user_name == NULL)
463 seq_puts(s, ",sec=none");
467 seq_puts(s, ",sec=");
469 switch (ses->sectype) {
471 seq_puts(s, "ntlmv2");
477 seq_puts(s, "ntlmssp");
480 /* shouldn't ever happen */
481 seq_puts(s, "unknown");
488 if (ses->sectype == Kerberos)
489 seq_printf(s, ",cruid=%u",
490 from_kuid_munged(&init_user_ns, ses->cred_uid));
494 cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
496 seq_puts(s, ",cache=");
498 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
499 seq_puts(s, "strict");
500 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
502 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
503 seq_puts(s, "singleclient"); /* assume only one client access */
504 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)
505 seq_puts(s, "ro"); /* read only caching assumed */
507 seq_puts(s, "loose");
511 * cifs_show_devname() is used so we show the mount device name with correct
512 * format (e.g. forward slashes vs. back slashes) in /proc/mounts
514 static int cifs_show_devname(struct seq_file *m, struct dentry *root)
516 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
517 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);
522 convert_delimiter(devname, '/');
523 /* escape all spaces in share names */
524 seq_escape(m, devname, " \t");
531 * cifs_show_options() is for displaying mount options in /proc/mounts.
532 * Not all settable options are displayed but most of the important
536 cifs_show_options(struct seq_file *s, struct dentry *root)
538 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
539 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
540 struct sockaddr *srcaddr;
541 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
543 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);
544 cifs_show_security(s, tcon->ses);
545 cifs_show_cache_flavor(s, cifs_sb);
548 seq_puts(s, ",nolease");
549 if (cifs_sb->ctx->multiuser)
550 seq_puts(s, ",multiuser");
551 else if (tcon->ses->user_name)
552 seq_show_option(s, "username", tcon->ses->user_name);
554 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)
555 seq_show_option(s, "domain", tcon->ses->domainName);
557 if (srcaddr->sa_family != AF_UNSPEC) {
558 struct sockaddr_in *saddr4;
559 struct sockaddr_in6 *saddr6;
560 saddr4 = (struct sockaddr_in *)srcaddr;
561 saddr6 = (struct sockaddr_in6 *)srcaddr;
562 if (srcaddr->sa_family == AF_INET6)
563 seq_printf(s, ",srcaddr=%pI6c",
565 else if (srcaddr->sa_family == AF_INET)
566 seq_printf(s, ",srcaddr=%pI4",
567 &saddr4->sin_addr.s_addr);
569 seq_printf(s, ",srcaddr=BAD-AF:%i",
570 (int)(srcaddr->sa_family));
573 seq_printf(s, ",uid=%u",
574 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));
575 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
576 seq_puts(s, ",forceuid");
578 seq_puts(s, ",noforceuid");
580 seq_printf(s, ",gid=%u",
581 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));
582 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
583 seq_puts(s, ",forcegid");
585 seq_puts(s, ",noforcegid");
587 cifs_show_address(s, tcon->ses->server);
590 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
591 cifs_sb->ctx->file_mode,
592 cifs_sb->ctx->dir_mode);
593 if (cifs_sb->ctx->iocharset)
594 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);
596 seq_puts(s, ",seal");
597 else if (tcon->ses->server->ignore_signature)
598 seq_puts(s, ",signloosely");
600 seq_puts(s, ",nocase");
602 seq_puts(s, ",nodelete");
603 if (cifs_sb->ctx->no_sparse)
604 seq_puts(s, ",nosparse");
605 if (tcon->local_lease)
606 seq_puts(s, ",locallease");
608 seq_puts(s, ",hard");
610 seq_puts(s, ",soft");
611 if (tcon->use_persistent)
612 seq_puts(s, ",persistenthandles");
613 else if (tcon->use_resilient)
614 seq_puts(s, ",resilienthandles");
615 if (tcon->posix_extensions)
616 seq_puts(s, ",posix");
617 else if (tcon->unix_ext)
618 seq_puts(s, ",unix");
620 seq_puts(s, ",nounix");
621 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
622 seq_puts(s, ",nodfs");
623 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
624 seq_puts(s, ",posixpaths");
625 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
626 seq_puts(s, ",setuids");
627 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)
628 seq_puts(s, ",idsfromsid");
629 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
630 seq_puts(s, ",serverino");
631 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
632 seq_puts(s, ",rwpidforward");
633 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
634 seq_puts(s, ",forcemand");
635 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
636 seq_puts(s, ",nouser_xattr");
637 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
638 seq_puts(s, ",mapchars");
639 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
640 seq_puts(s, ",mapposix");
641 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
643 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
644 seq_puts(s, ",nobrl");
645 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)
646 seq_puts(s, ",nohandlecache");
647 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)
648 seq_puts(s, ",modefromsid");
649 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
650 seq_puts(s, ",cifsacl");
651 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
652 seq_puts(s, ",dynperm");
653 if (root->d_sb->s_flags & SB_POSIXACL)
655 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
656 seq_puts(s, ",mfsymlinks");
657 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
659 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
660 seq_puts(s, ",nostrictsync");
661 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
662 seq_puts(s, ",noperm");
663 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
664 seq_printf(s, ",backupuid=%u",
665 from_kuid_munged(&init_user_ns,
666 cifs_sb->ctx->backupuid));
667 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
668 seq_printf(s, ",backupgid=%u",
669 from_kgid_munged(&init_user_ns,
670 cifs_sb->ctx->backupgid));
672 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);
673 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);
674 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);
675 if (cifs_sb->ctx->rasize)
676 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);
677 if (tcon->ses->server->min_offload)
678 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);
679 seq_printf(s, ",echo_interval=%lu",
680 tcon->ses->server->echo_interval / HZ);
682 /* Only display the following if overridden on mount */
683 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)
684 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);
685 if (tcon->ses->server->tcp_nodelay)
686 seq_puts(s, ",tcpnodelay");
687 if (tcon->ses->server->noautotune)
688 seq_puts(s, ",noautotune");
689 if (tcon->ses->server->noblocksnd)
690 seq_puts(s, ",noblocksend");
692 if (tcon->snapshot_time)
693 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);
694 if (tcon->handle_timeout)
695 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);
698 * Display file and directory attribute timeout in seconds.
699 * If file and directory attribute timeout the same then actimeo
700 * was likely specified on mount
702 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)
703 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);
705 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);
706 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);
708 seq_printf(s, ",closetimeo=%lu", cifs_sb->ctx->closetimeo / HZ);
710 if (tcon->ses->chan_max > 1)
711 seq_printf(s, ",multichannel,max_channels=%zu",
712 tcon->ses->chan_max);
714 if (tcon->use_witness)
715 seq_puts(s, ",witness");
720 static void cifs_umount_begin(struct super_block *sb)
722 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
723 struct cifs_tcon *tcon;
728 tcon = cifs_sb_master_tcon(cifs_sb);
730 spin_lock(&cifs_tcp_ses_lock);
731 spin_lock(&tcon->tc_lock);
732 if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {
733 /* we have other mounts to same share or we have
734 already tried to umount this and woken up
735 all waiting network requests, nothing to do */
736 spin_unlock(&tcon->tc_lock);
737 spin_unlock(&cifs_tcp_ses_lock);
741 * can not set tcon->status to TID_EXITING yet since we don't know if umount -f will
742 * fail later (e.g. due to open files). TID_EXITING will be set just before tdis req sent
744 spin_unlock(&tcon->tc_lock);
745 spin_unlock(&cifs_tcp_ses_lock);
747 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
748 /* cancel_notify_requests(tcon); */
749 if (tcon->ses && tcon->ses->server) {
750 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
751 wake_up_all(&tcon->ses->server->request_q);
752 wake_up_all(&tcon->ses->server->response_q);
753 msleep(1); /* yield */
754 /* we have to kick the requests once more */
755 wake_up_all(&tcon->ses->server->response_q);
762 #ifdef CONFIG_CIFS_STATS2
763 static int cifs_show_stats(struct seq_file *s, struct dentry *root)
770 static int cifs_write_inode(struct inode *inode, struct writeback_control *wbc)
772 fscache_unpin_writeback(wbc, cifs_inode_cookie(inode));
776 static int cifs_drop_inode(struct inode *inode)
778 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
780 /* no serverino => unconditional eviction */
781 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
782 generic_drop_inode(inode);
785 static const struct super_operations cifs_super_ops = {
786 .statfs = cifs_statfs,
787 .alloc_inode = cifs_alloc_inode,
788 .write_inode = cifs_write_inode,
789 .free_inode = cifs_free_inode,
790 .drop_inode = cifs_drop_inode,
791 .evict_inode = cifs_evict_inode,
792 /* .show_path = cifs_show_path, */ /* Would we ever need show path? */
793 .show_devname = cifs_show_devname,
794 /* .delete_inode = cifs_delete_inode, */ /* Do not need above
795 function unless later we add lazy close of inodes or unless the
796 kernel forgets to call us with the same number of releases (closes)
798 .show_options = cifs_show_options,
799 .umount_begin = cifs_umount_begin,
800 #ifdef CONFIG_CIFS_STATS2
801 .show_stats = cifs_show_stats,
806 * Get root dentry from superblock according to prefix path mount option.
807 * Return dentry with refcount + 1 on success and NULL otherwise.
809 static struct dentry *
810 cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)
812 struct dentry *dentry;
813 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
814 char *full_path = NULL;
818 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
819 return dget(sb->s_root);
821 full_path = cifs_build_path_to_root(ctx, cifs_sb,
822 cifs_sb_master_tcon(cifs_sb), 0);
823 if (full_path == NULL)
824 return ERR_PTR(-ENOMEM);
826 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
828 sep = CIFS_DIR_SEP(cifs_sb);
829 dentry = dget(sb->s_root);
833 struct inode *dir = d_inode(dentry);
834 struct dentry *child;
836 if (!S_ISDIR(dir->i_mode)) {
838 dentry = ERR_PTR(-ENOTDIR);
842 /* skip separators */
849 while (*s && *s != sep)
852 child = lookup_positive_unlocked(p, dentry, s - p);
855 } while (!IS_ERR(dentry));
860 static int cifs_set_super(struct super_block *sb, void *data)
862 struct cifs_mnt_data *mnt_data = data;
863 sb->s_fs_info = mnt_data->cifs_sb;
864 return set_anon_super(sb, NULL);
868 cifs_smb3_do_mount(struct file_system_type *fs_type,
869 int flags, struct smb3_fs_context *old_ctx)
872 struct super_block *sb = NULL;
873 struct cifs_sb_info *cifs_sb = NULL;
874 struct cifs_mnt_data mnt_data;
878 * Prints in Kernel / CIFS log the attempted mount operation
879 * If CIFS_DEBUG && cifs_FYI
882 cifs_dbg(FYI, "Devname: %s flags: %d\n", old_ctx->UNC, flags);
884 cifs_info("Attempting to mount %s\n", old_ctx->UNC);
886 cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
887 if (cifs_sb == NULL) {
888 root = ERR_PTR(-ENOMEM);
892 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
894 root = ERR_PTR(-ENOMEM);
897 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);
903 rc = cifs_setup_cifs_sb(cifs_sb);
909 rc = cifs_mount(cifs_sb, cifs_sb->ctx);
911 if (!(flags & SB_SILENT))
912 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
918 mnt_data.ctx = cifs_sb->ctx;
919 mnt_data.cifs_sb = cifs_sb;
920 mnt_data.flags = flags;
922 /* BB should we make this contingent on mount parm? */
923 flags |= SB_NODIRATIME | SB_NOATIME;
925 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
928 cifs_umount(cifs_sb);
934 cifs_dbg(FYI, "Use existing superblock\n");
935 cifs_umount(cifs_sb);
938 rc = cifs_read_super(sb);
944 sb->s_flags |= SB_ACTIVE;
947 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);
952 cifs_sb->root = dget(root);
954 cifs_dbg(FYI, "dentry root is: %p\n", root);
958 deactivate_locked_super(sb);
962 if (!sb || IS_ERR(sb)) { /* otherwise kill_sb will handle */
963 kfree(cifs_sb->prepath);
964 smb3_cleanup_fs_context(cifs_sb->ctx);
973 cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
976 struct inode *inode = file_inode(iocb->ki_filp);
978 if (iocb->ki_flags & IOCB_DIRECT)
979 return cifs_user_readv(iocb, iter);
981 rc = cifs_revalidate_mapping(inode);
985 return generic_file_read_iter(iocb, iter);
988 static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
990 struct inode *inode = file_inode(iocb->ki_filp);
991 struct cifsInodeInfo *cinode = CIFS_I(inode);
995 if (iocb->ki_filp->f_flags & O_DIRECT) {
996 written = cifs_user_writev(iocb, from);
997 if (written > 0 && CIFS_CACHE_READ(cinode)) {
998 cifs_zap_mapping(inode);
1000 "Set no oplock for inode=%p after a write operation\n",
1007 written = cifs_get_writer(cinode);
1011 written = generic_file_write_iter(iocb, from);
1013 if (CIFS_CACHE_WRITE(CIFS_I(inode)))
1016 rc = filemap_fdatawrite(inode->i_mapping);
1018 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
1022 cifs_put_writer(cinode);
1026 static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
1028 struct cifsFileInfo *cfile = file->private_data;
1029 struct cifs_tcon *tcon;
1032 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
1033 * the cached file length
1035 if (whence != SEEK_SET && whence != SEEK_CUR) {
1037 struct inode *inode = file_inode(file);
1040 * We need to be sure that all dirty pages are written and the
1041 * server has the newest file length.
1043 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1044 inode->i_mapping->nrpages != 0) {
1045 rc = filemap_fdatawait(inode->i_mapping);
1047 mapping_set_error(inode->i_mapping, rc);
1052 * Some applications poll for the file length in this strange
1053 * way so we must seek to end on non-oplocked files by
1054 * setting the revalidate time to zero.
1056 CIFS_I(inode)->time = 0;
1058 rc = cifs_revalidate_file_attr(file);
1062 if (cfile && cfile->tlink) {
1063 tcon = tlink_tcon(cfile->tlink);
1064 if (tcon->ses->server->ops->llseek)
1065 return tcon->ses->server->ops->llseek(file, tcon,
1068 return generic_file_llseek(file, offset, whence);
1072 cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
1075 * Note that this is called by vfs setlease with i_lock held to
1076 * protect *lease from going away.
1078 struct inode *inode = file_inode(file);
1079 struct cifsFileInfo *cfile = file->private_data;
1081 if (!(S_ISREG(inode->i_mode)))
1084 /* Check if file is oplocked if this is request for new lease */
1085 if (arg == F_UNLCK ||
1086 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
1087 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
1088 return generic_setlease(file, arg, lease, priv);
1089 else if (tlink_tcon(cfile->tlink)->local_lease &&
1090 !CIFS_CACHE_READ(CIFS_I(inode)))
1092 * If the server claims to support oplock on this file, then we
1093 * still need to check oplock even if the local_lease mount
1094 * option is set, but there are servers which do not support
1095 * oplock for which this mount option may be useful if the user
1096 * knows that the file won't be changed on the server by anyone
1099 return generic_setlease(file, arg, lease, priv);
1104 struct file_system_type cifs_fs_type = {
1105 .owner = THIS_MODULE,
1107 .init_fs_context = smb3_init_fs_context,
1108 .parameters = smb3_fs_parameters,
1109 .kill_sb = cifs_kill_sb,
1110 .fs_flags = FS_RENAME_DOES_D_MOVE,
1112 MODULE_ALIAS_FS("cifs");
1114 struct file_system_type smb3_fs_type = {
1115 .owner = THIS_MODULE,
1117 .init_fs_context = smb3_init_fs_context,
1118 .parameters = smb3_fs_parameters,
1119 .kill_sb = cifs_kill_sb,
1120 .fs_flags = FS_RENAME_DOES_D_MOVE,
1122 MODULE_ALIAS_FS("smb3");
1123 MODULE_ALIAS("smb3");
1125 const struct inode_operations cifs_dir_inode_ops = {
1126 .create = cifs_create,
1127 .atomic_open = cifs_atomic_open,
1128 .lookup = cifs_lookup,
1129 .getattr = cifs_getattr,
1130 .unlink = cifs_unlink,
1131 .link = cifs_hardlink,
1132 .mkdir = cifs_mkdir,
1133 .rmdir = cifs_rmdir,
1134 .rename = cifs_rename2,
1135 .permission = cifs_permission,
1136 .setattr = cifs_setattr,
1137 .symlink = cifs_symlink,
1138 .mknod = cifs_mknod,
1139 .listxattr = cifs_listxattr,
1140 .get_acl = cifs_get_acl,
1141 .set_acl = cifs_set_acl,
1144 const struct inode_operations cifs_file_inode_ops = {
1145 .setattr = cifs_setattr,
1146 .getattr = cifs_getattr,
1147 .permission = cifs_permission,
1148 .listxattr = cifs_listxattr,
1149 .fiemap = cifs_fiemap,
1150 .get_acl = cifs_get_acl,
1151 .set_acl = cifs_set_acl,
1154 const char *cifs_get_link(struct dentry *dentry, struct inode *inode,
1155 struct delayed_call *done)
1159 target_path = kmalloc(PATH_MAX, GFP_KERNEL);
1161 return ERR_PTR(-ENOMEM);
1163 spin_lock(&inode->i_lock);
1164 if (likely(CIFS_I(inode)->symlink_target)) {
1165 strscpy(target_path, CIFS_I(inode)->symlink_target, PATH_MAX);
1168 target_path = ERR_PTR(-EOPNOTSUPP);
1170 spin_unlock(&inode->i_lock);
1172 if (!IS_ERR(target_path))
1173 set_delayed_call(done, kfree_link, target_path);
1178 const struct inode_operations cifs_symlink_inode_ops = {
1179 .get_link = cifs_get_link,
1180 .permission = cifs_permission,
1181 .listxattr = cifs_listxattr,
1184 static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
1185 struct file *dst_file, loff_t destoff, loff_t len,
1186 unsigned int remap_flags)
1188 struct inode *src_inode = file_inode(src_file);
1189 struct inode *target_inode = file_inode(dst_file);
1190 struct cifsFileInfo *smb_file_src = src_file->private_data;
1191 struct cifsFileInfo *smb_file_target;
1192 struct cifs_tcon *target_tcon;
1196 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1199 cifs_dbg(FYI, "clone range\n");
1203 if (!src_file->private_data || !dst_file->private_data) {
1205 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1209 smb_file_target = dst_file->private_data;
1210 target_tcon = tlink_tcon(smb_file_target->tlink);
1213 * Note: cifs case is easier than btrfs since server responsible for
1214 * checks for proper open modes and file type and if it wants
1215 * server could even support copy of range where source = target
1217 lock_two_nondirectories(target_inode, src_inode);
1220 len = src_inode->i_size - off;
1222 cifs_dbg(FYI, "about to flush pages\n");
1223 /* should we flush first and last page first */
1224 truncate_inode_pages_range(&target_inode->i_data, destoff,
1225 PAGE_ALIGN(destoff + len)-1);
1227 if (target_tcon->ses->server->ops->duplicate_extents)
1228 rc = target_tcon->ses->server->ops->duplicate_extents(xid,
1229 smb_file_src, smb_file_target, off, len, destoff);
1233 /* force revalidate of size and timestamps of target file now
1234 that target is updated on the server */
1235 CIFS_I(target_inode)->time = 0;
1236 /* although unlocking in the reverse order from locking is not
1237 strictly necessary here it is a little cleaner to be consistent */
1238 unlock_two_nondirectories(src_inode, target_inode);
1241 return rc < 0 ? rc : len;
1244 ssize_t cifs_file_copychunk_range(unsigned int xid,
1245 struct file *src_file, loff_t off,
1246 struct file *dst_file, loff_t destoff,
1247 size_t len, unsigned int flags)
1249 struct inode *src_inode = file_inode(src_file);
1250 struct inode *target_inode = file_inode(dst_file);
1251 struct cifsFileInfo *smb_file_src;
1252 struct cifsFileInfo *smb_file_target;
1253 struct cifs_tcon *src_tcon;
1254 struct cifs_tcon *target_tcon;
1257 cifs_dbg(FYI, "copychunk range\n");
1259 if (!src_file->private_data || !dst_file->private_data) {
1261 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
1266 smb_file_target = dst_file->private_data;
1267 smb_file_src = src_file->private_data;
1268 src_tcon = tlink_tcon(smb_file_src->tlink);
1269 target_tcon = tlink_tcon(smb_file_target->tlink);
1271 if (src_tcon->ses != target_tcon->ses) {
1272 cifs_dbg(VFS, "source and target of copy not on same server\n");
1277 if (!target_tcon->ses->server->ops->copychunk_range)
1281 * Note: cifs case is easier than btrfs since server responsible for
1282 * checks for proper open modes and file type and if it wants
1283 * server could even support copy of range where source = target
1285 lock_two_nondirectories(target_inode, src_inode);
1287 cifs_dbg(FYI, "about to flush pages\n");
1289 rc = filemap_write_and_wait_range(src_inode->i_mapping, off,
1294 /* should we flush first and last page first */
1295 truncate_inode_pages(&target_inode->i_data, 0);
1297 rc = file_modified(dst_file);
1299 rc = target_tcon->ses->server->ops->copychunk_range(xid,
1300 smb_file_src, smb_file_target, off, len, destoff);
1302 file_accessed(src_file);
1304 /* force revalidate of size and timestamps of target file now
1305 * that target is updated on the server
1307 CIFS_I(target_inode)->time = 0;
1310 /* although unlocking in the reverse order from locking is not
1311 * strictly necessary here it is a little cleaner to be consistent
1313 unlock_two_nondirectories(src_inode, target_inode);
1320 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()
1321 * is a dummy operation.
1323 static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1325 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",
1331 static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,
1332 struct file *dst_file, loff_t destoff,
1333 size_t len, unsigned int flags)
1335 unsigned int xid = get_xid();
1337 struct cifsFileInfo *cfile = dst_file->private_data;
1339 if (cfile->swapfile) {
1345 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,
1349 if (rc == -EOPNOTSUPP || rc == -EXDEV)
1350 rc = generic_copy_file_range(src_file, off, dst_file,
1351 destoff, len, flags);
1355 const struct file_operations cifs_file_ops = {
1356 .read_iter = cifs_loose_read_iter,
1357 .write_iter = cifs_file_write_iter,
1359 .release = cifs_close,
1361 .flock = cifs_flock,
1362 .fsync = cifs_fsync,
1363 .flush = cifs_flush,
1364 .mmap = cifs_file_mmap,
1365 .splice_read = cifs_splice_read,
1366 .splice_write = iter_file_splice_write,
1367 .llseek = cifs_llseek,
1368 .unlocked_ioctl = cifs_ioctl,
1369 .copy_file_range = cifs_copy_file_range,
1370 .remap_file_range = cifs_remap_file_range,
1371 .setlease = cifs_setlease,
1372 .fallocate = cifs_fallocate,
1375 const struct file_operations cifs_file_strict_ops = {
1376 .read_iter = cifs_strict_readv,
1377 .write_iter = cifs_strict_writev,
1379 .release = cifs_close,
1381 .flock = cifs_flock,
1382 .fsync = cifs_strict_fsync,
1383 .flush = cifs_flush,
1384 .mmap = cifs_file_strict_mmap,
1385 .splice_read = cifs_splice_read,
1386 .splice_write = iter_file_splice_write,
1387 .llseek = cifs_llseek,
1388 .unlocked_ioctl = cifs_ioctl,
1389 .copy_file_range = cifs_copy_file_range,
1390 .remap_file_range = cifs_remap_file_range,
1391 .setlease = cifs_setlease,
1392 .fallocate = cifs_fallocate,
1395 const struct file_operations cifs_file_direct_ops = {
1396 .read_iter = cifs_direct_readv,
1397 .write_iter = cifs_direct_writev,
1399 .release = cifs_close,
1401 .flock = cifs_flock,
1402 .fsync = cifs_fsync,
1403 .flush = cifs_flush,
1404 .mmap = cifs_file_mmap,
1405 .splice_read = direct_splice_read,
1406 .splice_write = iter_file_splice_write,
1407 .unlocked_ioctl = cifs_ioctl,
1408 .copy_file_range = cifs_copy_file_range,
1409 .remap_file_range = cifs_remap_file_range,
1410 .llseek = cifs_llseek,
1411 .setlease = cifs_setlease,
1412 .fallocate = cifs_fallocate,
1415 const struct file_operations cifs_file_nobrl_ops = {
1416 .read_iter = cifs_loose_read_iter,
1417 .write_iter = cifs_file_write_iter,
1419 .release = cifs_close,
1420 .fsync = cifs_fsync,
1421 .flush = cifs_flush,
1422 .mmap = cifs_file_mmap,
1423 .splice_read = cifs_splice_read,
1424 .splice_write = iter_file_splice_write,
1425 .llseek = cifs_llseek,
1426 .unlocked_ioctl = cifs_ioctl,
1427 .copy_file_range = cifs_copy_file_range,
1428 .remap_file_range = cifs_remap_file_range,
1429 .setlease = cifs_setlease,
1430 .fallocate = cifs_fallocate,
1433 const struct file_operations cifs_file_strict_nobrl_ops = {
1434 .read_iter = cifs_strict_readv,
1435 .write_iter = cifs_strict_writev,
1437 .release = cifs_close,
1438 .fsync = cifs_strict_fsync,
1439 .flush = cifs_flush,
1440 .mmap = cifs_file_strict_mmap,
1441 .splice_read = cifs_splice_read,
1442 .splice_write = iter_file_splice_write,
1443 .llseek = cifs_llseek,
1444 .unlocked_ioctl = cifs_ioctl,
1445 .copy_file_range = cifs_copy_file_range,
1446 .remap_file_range = cifs_remap_file_range,
1447 .setlease = cifs_setlease,
1448 .fallocate = cifs_fallocate,
1451 const struct file_operations cifs_file_direct_nobrl_ops = {
1452 .read_iter = cifs_direct_readv,
1453 .write_iter = cifs_direct_writev,
1455 .release = cifs_close,
1456 .fsync = cifs_fsync,
1457 .flush = cifs_flush,
1458 .mmap = cifs_file_mmap,
1459 .splice_read = direct_splice_read,
1460 .splice_write = iter_file_splice_write,
1461 .unlocked_ioctl = cifs_ioctl,
1462 .copy_file_range = cifs_copy_file_range,
1463 .remap_file_range = cifs_remap_file_range,
1464 .llseek = cifs_llseek,
1465 .setlease = cifs_setlease,
1466 .fallocate = cifs_fallocate,
1469 const struct file_operations cifs_dir_ops = {
1470 .iterate_shared = cifs_readdir,
1471 .release = cifs_closedir,
1472 .read = generic_read_dir,
1473 .unlocked_ioctl = cifs_ioctl,
1474 .copy_file_range = cifs_copy_file_range,
1475 .remap_file_range = cifs_remap_file_range,
1476 .llseek = generic_file_llseek,
1477 .fsync = cifs_dir_fsync,
1481 cifs_init_once(void *inode)
1483 struct cifsInodeInfo *cifsi = inode;
1485 inode_init_once(&cifsi->netfs.inode);
1486 init_rwsem(&cifsi->lock_sem);
1490 cifs_init_inodecache(void)
1492 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1493 sizeof(struct cifsInodeInfo),
1494 0, (SLAB_RECLAIM_ACCOUNT|
1495 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1497 if (cifs_inode_cachep == NULL)
1504 cifs_destroy_inodecache(void)
1507 * Make sure all delayed rcu free inodes are flushed before we
1511 kmem_cache_destroy(cifs_inode_cachep);
1515 cifs_init_request_bufs(void)
1518 * SMB2 maximum header size is bigger than CIFS one - no problems to
1519 * allocate some more bytes for CIFS.
1521 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;
1523 if (CIFSMaxBufSize < 8192) {
1524 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1525 Unicode path name has to fit in any SMB/CIFS path based frames */
1526 CIFSMaxBufSize = 8192;
1527 } else if (CIFSMaxBufSize > 1024*127) {
1528 CIFSMaxBufSize = 1024 * 127;
1530 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1533 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1534 CIFSMaxBufSize, CIFSMaxBufSize);
1536 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",
1537 CIFSMaxBufSize + max_hdr_size, 0,
1538 SLAB_HWCACHE_ALIGN, 0,
1539 CIFSMaxBufSize + max_hdr_size,
1541 if (cifs_req_cachep == NULL)
1544 if (cifs_min_rcv < 1)
1546 else if (cifs_min_rcv > 64) {
1548 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1551 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1554 if (cifs_req_poolp == NULL) {
1555 kmem_cache_destroy(cifs_req_cachep);
1558 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1559 almost all handle based requests (but not write response, nor is it
1560 sufficient for path based requests). A smaller size would have
1561 been more efficient (compacting multiple slab items on one 4k page)
1562 for the case in which debug was on, but this larger size allows
1563 more SMBs to use small buffer alloc and is still much more
1564 efficient to alloc 1 per page off the slab compared to 17K (5page)
1565 alloc of large cifs buffers even when page debugging is on */
1566 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",
1567 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1568 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);
1569 if (cifs_sm_req_cachep == NULL) {
1570 mempool_destroy(cifs_req_poolp);
1571 kmem_cache_destroy(cifs_req_cachep);
1575 if (cifs_min_small < 2)
1577 else if (cifs_min_small > 256) {
1578 cifs_min_small = 256;
1579 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1582 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1583 cifs_sm_req_cachep);
1585 if (cifs_sm_req_poolp == NULL) {
1586 mempool_destroy(cifs_req_poolp);
1587 kmem_cache_destroy(cifs_req_cachep);
1588 kmem_cache_destroy(cifs_sm_req_cachep);
1596 cifs_destroy_request_bufs(void)
1598 mempool_destroy(cifs_req_poolp);
1599 kmem_cache_destroy(cifs_req_cachep);
1600 mempool_destroy(cifs_sm_req_poolp);
1601 kmem_cache_destroy(cifs_sm_req_cachep);
1604 static int init_mids(void)
1606 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1607 sizeof(struct mid_q_entry), 0,
1608 SLAB_HWCACHE_ALIGN, NULL);
1609 if (cifs_mid_cachep == NULL)
1612 /* 3 is a reasonable minimum number of simultaneous operations */
1613 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1614 if (cifs_mid_poolp == NULL) {
1615 kmem_cache_destroy(cifs_mid_cachep);
1622 static void destroy_mids(void)
1624 mempool_destroy(cifs_mid_poolp);
1625 kmem_cache_destroy(cifs_mid_cachep);
1633 INIT_LIST_HEAD(&cifs_tcp_ses_list);
1635 * Initialize Global counters
1637 atomic_set(&sesInfoAllocCount, 0);
1638 atomic_set(&tconInfoAllocCount, 0);
1639 atomic_set(&tcpSesNextId, 0);
1640 atomic_set(&tcpSesAllocCount, 0);
1641 atomic_set(&tcpSesReconnectCount, 0);
1642 atomic_set(&tconInfoReconnectCount, 0);
1644 atomic_set(&buf_alloc_count, 0);
1645 atomic_set(&small_buf_alloc_count, 0);
1646 #ifdef CONFIG_CIFS_STATS2
1647 atomic_set(&total_buf_alloc_count, 0);
1648 atomic_set(&total_small_buf_alloc_count, 0);
1649 if (slow_rsp_threshold < 1)
1650 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");
1651 else if (slow_rsp_threshold > 32767)
1653 "slow response threshold set higher than recommended (0 to 32767)\n");
1654 #endif /* CONFIG_CIFS_STATS2 */
1656 atomic_set(&mid_count, 0);
1657 GlobalCurrentXid = 0;
1658 GlobalTotalActiveXid = 0;
1659 GlobalMaxActiveXid = 0;
1660 spin_lock_init(&cifs_tcp_ses_lock);
1661 spin_lock_init(&GlobalMid_Lock);
1663 cifs_lock_secret = get_random_u32();
1665 if (cifs_max_pending < 2) {
1666 cifs_max_pending = 2;
1667 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1668 } else if (cifs_max_pending > CIFS_MAX_REQ) {
1669 cifs_max_pending = CIFS_MAX_REQ;
1670 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1674 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1677 goto out_clean_proc;
1681 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)
1682 * so that we don't launch too many worker threads but
1683 * Documentation/core-api/workqueue.rst recommends setting it to 0
1686 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */
1687 decrypt_wq = alloc_workqueue("smb3decryptd",
1688 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1691 goto out_destroy_cifsiod_wq;
1694 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",
1695 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1696 if (!fileinfo_put_wq) {
1698 goto out_destroy_decrypt_wq;
1701 cifsoplockd_wq = alloc_workqueue("cifsoplockd",
1702 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1703 if (!cifsoplockd_wq) {
1705 goto out_destroy_fileinfo_put_wq;
1708 deferredclose_wq = alloc_workqueue("deferredclose",
1709 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1710 if (!deferredclose_wq) {
1712 goto out_destroy_cifsoplockd_wq;
1715 rc = cifs_init_inodecache();
1717 goto out_destroy_deferredclose_wq;
1721 goto out_destroy_inodecache;
1723 rc = cifs_init_request_bufs();
1725 goto out_destroy_mids;
1727 #ifdef CONFIG_CIFS_DFS_UPCALL
1728 rc = dfs_cache_init();
1730 goto out_destroy_request_bufs;
1731 #endif /* CONFIG_CIFS_DFS_UPCALL */
1732 #ifdef CONFIG_CIFS_UPCALL
1733 rc = init_cifs_spnego();
1735 goto out_destroy_dfs_cache;
1736 #endif /* CONFIG_CIFS_UPCALL */
1737 #ifdef CONFIG_CIFS_SWN_UPCALL
1738 rc = cifs_genl_init();
1740 goto out_register_key_type;
1741 #endif /* CONFIG_CIFS_SWN_UPCALL */
1743 rc = init_cifs_idmap();
1745 goto out_cifs_swn_init;
1747 rc = register_filesystem(&cifs_fs_type);
1749 goto out_init_cifs_idmap;
1751 rc = register_filesystem(&smb3_fs_type);
1753 unregister_filesystem(&cifs_fs_type);
1754 goto out_init_cifs_idmap;
1759 out_init_cifs_idmap:
1762 #ifdef CONFIG_CIFS_SWN_UPCALL
1764 out_register_key_type:
1766 #ifdef CONFIG_CIFS_UPCALL
1768 out_destroy_dfs_cache:
1770 #ifdef CONFIG_CIFS_DFS_UPCALL
1771 dfs_cache_destroy();
1772 out_destroy_request_bufs:
1774 cifs_destroy_request_bufs();
1777 out_destroy_inodecache:
1778 cifs_destroy_inodecache();
1779 out_destroy_deferredclose_wq:
1780 destroy_workqueue(deferredclose_wq);
1781 out_destroy_cifsoplockd_wq:
1782 destroy_workqueue(cifsoplockd_wq);
1783 out_destroy_fileinfo_put_wq:
1784 destroy_workqueue(fileinfo_put_wq);
1785 out_destroy_decrypt_wq:
1786 destroy_workqueue(decrypt_wq);
1787 out_destroy_cifsiod_wq:
1788 destroy_workqueue(cifsiod_wq);
1797 cifs_dbg(NOISY, "exit_smb3\n");
1798 unregister_filesystem(&cifs_fs_type);
1799 unregister_filesystem(&smb3_fs_type);
1800 cifs_dfs_release_automount_timer();
1802 #ifdef CONFIG_CIFS_SWN_UPCALL
1805 #ifdef CONFIG_CIFS_UPCALL
1808 #ifdef CONFIG_CIFS_DFS_UPCALL
1809 dfs_cache_destroy();
1811 cifs_destroy_request_bufs();
1813 cifs_destroy_inodecache();
1814 destroy_workqueue(deferredclose_wq);
1815 destroy_workqueue(cifsoplockd_wq);
1816 destroy_workqueue(decrypt_wq);
1817 destroy_workqueue(fileinfo_put_wq);
1818 destroy_workqueue(cifsiod_wq);
1822 MODULE_AUTHOR("Steve French");
1823 MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */
1825 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "
1826 "also older servers complying with the SNIA CIFS Specification)");
1827 MODULE_VERSION(CIFS_VERSION);
1828 MODULE_SOFTDEP("ecb");
1829 MODULE_SOFTDEP("hmac");
1830 MODULE_SOFTDEP("md5");
1831 MODULE_SOFTDEP("nls");
1832 MODULE_SOFTDEP("aes");
1833 MODULE_SOFTDEP("cmac");
1834 MODULE_SOFTDEP("sha256");
1835 MODULE_SOFTDEP("sha512");
1836 MODULE_SOFTDEP("aead2");
1837 MODULE_SOFTDEP("ccm");
1838 MODULE_SOFTDEP("gcm");
1839 module_init(init_cifs)
1840 module_exit(exit_cifs)