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