2034 lines · c
1// SPDX-License-Identifier: LGPL-2.12/*3 *4 * Copyright (C) International Business Machines Corp., 2002,20085 * Author(s): Steve French (sfrench@us.ibm.com)6 *7 * Common Internet FileSystem (CIFS) client8 *9 */10 11/* Note that BB means BUGBUG (ie something to fix eventually) */12 13#include <linux/module.h>14#include <linux/fs.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/splice.h>29#include <linux/uuid.h>30#include <linux/xattr.h>31#include <uapi/linux/magic.h>32#include <net/ipv6.h>33#include "cifsfs.h"34#include "cifspdu.h"35#define DECLARE_GLOBALS_HERE36#include "cifsglob.h"37#include "cifsproto.h"38#include "cifs_debug.h"39#include "cifs_fs_sb.h"40#include <linux/mm.h>41#include <linux/key-type.h>42#include "cifs_spnego.h"43#include "fscache.h"44#ifdef CONFIG_CIFS_DFS_UPCALL45#include "dfs_cache.h"46#endif47#ifdef CONFIG_CIFS_SWN_UPCALL48#include "netlink.h"49#endif50#include "fs_context.h"51#include "cached_dir.h"52 53/*54 * DOS dates from 1980/1/1 through 2107/12/3155 * Protocol specifications indicate the range should be to 119, which56 * limits maximum year to 2099. But this range has not been checked.57 */58#define SMB_DATE_MAX (127<<9 | 12<<5 | 31)59#define SMB_DATE_MIN (0<<9 | 1<<5 | 1)60#define SMB_TIME_MAX (23<<11 | 59<<5 | 29)61 62int cifsFYI = 0;63bool traceSMB;64bool enable_oplocks = true;65bool linuxExtEnabled = true;66bool lookupCacheEnabled = true;67bool disable_legacy_dialects; /* false by default */68bool enable_gcm_256 = true;69bool require_gcm_256; /* false by default */70bool enable_negotiate_signing; /* false by default */71unsigned int global_secflags = CIFSSEC_DEF;72/* unsigned int ntlmv2_support = 0; */73unsigned int sign_CIFS_PDUs = 1;74 75/*76 * Global transaction id (XID) information77 */78unsigned int GlobalCurrentXid; /* protected by GlobalMid_Lock */79unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Lock */80unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Lock */81spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */82 83/*84 * Global counters, updated atomically85 */86atomic_t sesInfoAllocCount;87atomic_t tconInfoAllocCount;88atomic_t tcpSesNextId;89atomic_t tcpSesAllocCount;90atomic_t tcpSesReconnectCount;91atomic_t tconInfoReconnectCount;92 93atomic_t mid_count;94atomic_t buf_alloc_count;95atomic_t small_buf_alloc_count;96#ifdef CONFIG_CIFS_STATS297atomic_t total_buf_alloc_count;98atomic_t total_small_buf_alloc_count;99#endif/* STATS2 */100struct list_head cifs_tcp_ses_list;101spinlock_t cifs_tcp_ses_lock;102static const struct super_operations cifs_super_ops;103unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;104module_param(CIFSMaxBufSize, uint, 0444);105MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header) "106 "for CIFS requests. "107 "Default: 16384 Range: 8192 to 130048");108unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;109module_param(cifs_min_rcv, uint, 0444);110MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "111 "1 to 64");112unsigned int cifs_min_small = 30;113module_param(cifs_min_small, uint, 0444);114MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "115 "Range: 2 to 256");116unsigned int cifs_max_pending = CIFS_MAX_REQ;117module_param(cifs_max_pending, uint, 0444);118MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server for "119 "CIFS/SMB1 dialect (N/A for SMB3) "120 "Default: 32767 Range: 2 to 32767.");121unsigned int dir_cache_timeout = 30;122module_param(dir_cache_timeout, uint, 0644);123MODULE_PARM_DESC(dir_cache_timeout, "Number of seconds to cache directory contents for which we have a lease. Default: 30 "124 "Range: 1 to 65000 seconds, 0 to disable caching dir contents");125#ifdef CONFIG_CIFS_STATS2126unsigned int slow_rsp_threshold = 1;127module_param(slow_rsp_threshold, uint, 0644);128MODULE_PARM_DESC(slow_rsp_threshold, "Amount of time (in seconds) to wait "129 "before logging that a response is delayed. "130 "Default: 1 (if set to 0 disables msg).");131#endif /* STATS2 */132 133module_param(enable_oplocks, bool, 0644);134MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");135 136module_param(enable_gcm_256, bool, 0644);137MODULE_PARM_DESC(enable_gcm_256, "Enable requesting strongest (256 bit) GCM encryption. Default: y/Y/0");138 139module_param(require_gcm_256, bool, 0644);140MODULE_PARM_DESC(require_gcm_256, "Require strongest (256 bit) GCM encryption. Default: n/N/0");141 142module_param(enable_negotiate_signing, bool, 0644);143MODULE_PARM_DESC(enable_negotiate_signing, "Enable negotiating packet signing algorithm with server. Default: n/N/0");144 145module_param(disable_legacy_dialects, bool, 0644);146MODULE_PARM_DESC(disable_legacy_dialects, "To improve security it may be "147 "helpful to restrict the ability to "148 "override the default dialects (SMB2.1, "149 "SMB3 and SMB3.02) on mount with old "150 "dialects (CIFS/SMB1 and SMB2) since "151 "vers=1.0 (CIFS/SMB1) and vers=2.0 are weaker"152 " and less secure. Default: n/N/0");153 154struct workqueue_struct *cifsiod_wq;155struct workqueue_struct *decrypt_wq;156struct workqueue_struct *fileinfo_put_wq;157struct workqueue_struct *cifsoplockd_wq;158struct workqueue_struct *deferredclose_wq;159struct workqueue_struct *serverclose_wq;160__u32 cifs_lock_secret;161 162/*163 * Bumps refcount for cifs super block.164 * Note that it should be only called if a reference to VFS super block is165 * already held, e.g. in open-type syscalls context. Otherwise it can race with166 * atomic_dec_and_test in deactivate_locked_super.167 */168void169cifs_sb_active(struct super_block *sb)170{171 struct cifs_sb_info *server = CIFS_SB(sb);172 173 if (atomic_inc_return(&server->active) == 1)174 atomic_inc(&sb->s_active);175}176 177void178cifs_sb_deactive(struct super_block *sb)179{180 struct cifs_sb_info *server = CIFS_SB(sb);181 182 if (atomic_dec_and_test(&server->active))183 deactivate_super(sb);184}185 186static int187cifs_read_super(struct super_block *sb)188{189 struct inode *inode;190 struct cifs_sb_info *cifs_sb;191 struct cifs_tcon *tcon;192 struct timespec64 ts;193 int rc = 0;194 195 cifs_sb = CIFS_SB(sb);196 tcon = cifs_sb_master_tcon(cifs_sb);197 198 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)199 sb->s_flags |= SB_POSIXACL;200 201 if (tcon->snapshot_time)202 sb->s_flags |= SB_RDONLY;203 204 if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)205 sb->s_maxbytes = MAX_LFS_FILESIZE;206 else207 sb->s_maxbytes = MAX_NON_LFS;208 209 /*210 * Some very old servers like DOS and OS/2 used 2 second granularity211 * (while all current servers use 100ns granularity - see MS-DTYP)212 * but 1 second is the maximum allowed granularity for the VFS213 * so for old servers set time granularity to 1 second while for214 * everything else (current servers) set it to 100ns.215 */216 if ((tcon->ses->server->vals->protocol_id == SMB10_PROT_ID) &&217 ((tcon->ses->capabilities &218 tcon->ses->server->vals->cap_nt_find) == 0) &&219 !tcon->unix_ext) {220 sb->s_time_gran = 1000000000; /* 1 second is max allowed gran */221 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MIN), 0, 0);222 sb->s_time_min = ts.tv_sec;223 ts = cnvrtDosUnixTm(cpu_to_le16(SMB_DATE_MAX),224 cpu_to_le16(SMB_TIME_MAX), 0);225 sb->s_time_max = ts.tv_sec;226 } else {227 /*228 * Almost every server, including all SMB2+, uses DCE TIME229 * ie 100 nanosecond units, since 1601. See MS-DTYP and MS-FSCC230 */231 sb->s_time_gran = 100;232 ts = cifs_NTtimeToUnix(0);233 sb->s_time_min = ts.tv_sec;234 ts = cifs_NTtimeToUnix(cpu_to_le64(S64_MAX));235 sb->s_time_max = ts.tv_sec;236 }237 238 sb->s_magic = CIFS_SUPER_MAGIC;239 sb->s_op = &cifs_super_ops;240 sb->s_xattr = cifs_xattr_handlers;241 rc = super_setup_bdi(sb);242 if (rc)243 goto out_no_root;244 /* tune readahead according to rsize if readahead size not set on mount */245 if (cifs_sb->ctx->rsize == 0)246 cifs_sb->ctx->rsize =247 tcon->ses->server->ops->negotiate_rsize(tcon, cifs_sb->ctx);248 if (cifs_sb->ctx->rasize)249 sb->s_bdi->ra_pages = cifs_sb->ctx->rasize / PAGE_SIZE;250 else251 sb->s_bdi->ra_pages = 2 * (cifs_sb->ctx->rsize / PAGE_SIZE);252 253 sb->s_blocksize = CIFS_MAX_MSGSIZE;254 sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */255 inode = cifs_root_iget(sb);256 257 if (IS_ERR(inode)) {258 rc = PTR_ERR(inode);259 goto out_no_root;260 }261 262 if (tcon->nocase)263 sb->s_d_op = &cifs_ci_dentry_ops;264 else265 sb->s_d_op = &cifs_dentry_ops;266 267 sb->s_root = d_make_root(inode);268 if (!sb->s_root) {269 rc = -ENOMEM;270 goto out_no_root;271 }272 273#ifdef CONFIG_CIFS_NFSD_EXPORT274 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {275 cifs_dbg(FYI, "export ops supported\n");276 sb->s_export_op = &cifs_export_ops;277 }278#endif /* CONFIG_CIFS_NFSD_EXPORT */279 280 return 0;281 282out_no_root:283 cifs_dbg(VFS, "%s: get root inode failed\n", __func__);284 return rc;285}286 287static void cifs_kill_sb(struct super_block *sb)288{289 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);290 291 /*292 * We need to release all dentries for the cached directories293 * before we kill the sb.294 */295 if (cifs_sb->root) {296 close_all_cached_dirs(cifs_sb);297 298 /* finally release root dentry */299 dput(cifs_sb->root);300 cifs_sb->root = NULL;301 }302 303 kill_anon_super(sb);304 cifs_umount(cifs_sb);305}306 307static int308cifs_statfs(struct dentry *dentry, struct kstatfs *buf)309{310 struct super_block *sb = dentry->d_sb;311 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);312 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);313 struct TCP_Server_Info *server = tcon->ses->server;314 unsigned int xid;315 int rc = 0;316 const char *full_path;317 void *page;318 319 xid = get_xid();320 page = alloc_dentry_path();321 322 full_path = build_path_from_dentry(dentry, page);323 if (IS_ERR(full_path)) {324 rc = PTR_ERR(full_path);325 goto statfs_out;326 }327 328 if (le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength) > 0)329 buf->f_namelen =330 le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);331 else332 buf->f_namelen = PATH_MAX;333 334 buf->f_fsid.val[0] = tcon->vol_serial_number;335 /* are using part of create time for more randomness, see man statfs */336 buf->f_fsid.val[1] = (int)le64_to_cpu(tcon->vol_create_time);337 338 buf->f_files = 0; /* undefined */339 buf->f_ffree = 0; /* unlimited */340 341 if (server->ops->queryfs)342 rc = server->ops->queryfs(xid, tcon, full_path, cifs_sb, buf);343 344statfs_out:345 free_dentry_path(page);346 free_xid(xid);347 return rc;348}349 350static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)351{352 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);353 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);354 struct TCP_Server_Info *server = tcon->ses->server;355 356 if (server->ops->fallocate)357 return server->ops->fallocate(file, tcon, mode, off, len);358 359 return -EOPNOTSUPP;360}361 362static int cifs_permission(struct mnt_idmap *idmap,363 struct inode *inode, int mask)364{365 struct cifs_sb_info *cifs_sb;366 367 cifs_sb = CIFS_SB(inode->i_sb);368 369 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {370 if ((mask & MAY_EXEC) && !execute_ok(inode))371 return -EACCES;372 else373 return 0;374 } else /* file mode might have been restricted at mount time375 on the client (above and beyond ACL on servers) for376 servers which do not support setting and viewing mode bits,377 so allowing client to check permissions is useful */378 return generic_permission(&nop_mnt_idmap, inode, mask);379}380 381static struct kmem_cache *cifs_inode_cachep;382static struct kmem_cache *cifs_req_cachep;383static struct kmem_cache *cifs_mid_cachep;384static struct kmem_cache *cifs_sm_req_cachep;385static struct kmem_cache *cifs_io_request_cachep;386static struct kmem_cache *cifs_io_subrequest_cachep;387mempool_t *cifs_sm_req_poolp;388mempool_t *cifs_req_poolp;389mempool_t *cifs_mid_poolp;390mempool_t cifs_io_request_pool;391mempool_t cifs_io_subrequest_pool;392 393static struct inode *394cifs_alloc_inode(struct super_block *sb)395{396 struct cifsInodeInfo *cifs_inode;397 cifs_inode = alloc_inode_sb(sb, cifs_inode_cachep, GFP_KERNEL);398 if (!cifs_inode)399 return NULL;400 cifs_inode->cifsAttrs = 0x20; /* default */401 cifs_inode->time = 0;402 /*403 * Until the file is open and we have gotten oplock info back from the404 * server, can not assume caching of file data or metadata.405 */406 cifs_set_oplock_level(cifs_inode, 0);407 cifs_inode->lease_granted = false;408 cifs_inode->flags = 0;409 spin_lock_init(&cifs_inode->writers_lock);410 cifs_inode->writers = 0;411 cifs_inode->netfs.inode.i_blkbits = 14; /* 2**14 = CIFS_MAX_MSGSIZE */412 cifs_inode->netfs.remote_i_size = 0;413 cifs_inode->uniqueid = 0;414 cifs_inode->createtime = 0;415 cifs_inode->epoch = 0;416 spin_lock_init(&cifs_inode->open_file_lock);417 generate_random_uuid(cifs_inode->lease_key);418 cifs_inode->symlink_target = NULL;419 420 /*421 * Can not set i_flags here - they get immediately overwritten to zero422 * by the VFS.423 */424 /* cifs_inode->netfs.inode.i_flags = S_NOATIME | S_NOCMTIME; */425 INIT_LIST_HEAD(&cifs_inode->openFileList);426 INIT_LIST_HEAD(&cifs_inode->llist);427 INIT_LIST_HEAD(&cifs_inode->deferred_closes);428 spin_lock_init(&cifs_inode->deferred_lock);429 return &cifs_inode->netfs.inode;430}431 432static void433cifs_free_inode(struct inode *inode)434{435 struct cifsInodeInfo *cinode = CIFS_I(inode);436 437 if (S_ISLNK(inode->i_mode))438 kfree(cinode->symlink_target);439 kmem_cache_free(cifs_inode_cachep, cinode);440}441 442static void443cifs_evict_inode(struct inode *inode)444{445 netfs_wait_for_outstanding_io(inode);446 truncate_inode_pages_final(&inode->i_data);447 if (inode->i_state & I_PINNING_NETFS_WB)448 cifs_fscache_unuse_inode_cookie(inode, true);449 cifs_fscache_release_inode_cookie(inode);450 clear_inode(inode);451}452 453static void454cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)455{456 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;457 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;458 459 seq_puts(s, ",addr=");460 461 switch (server->dstaddr.ss_family) {462 case AF_INET:463 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);464 break;465 case AF_INET6:466 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);467 if (sa6->sin6_scope_id)468 seq_printf(s, "%%%u", sa6->sin6_scope_id);469 break;470 default:471 seq_puts(s, "(unknown)");472 }473 if (server->rdma)474 seq_puts(s, ",rdma");475}476 477static void478cifs_show_security(struct seq_file *s, struct cifs_ses *ses)479{480 if (ses->sectype == Unspecified) {481 if (ses->user_name == NULL)482 seq_puts(s, ",sec=none");483 return;484 }485 486 seq_puts(s, ",sec=");487 488 switch (ses->sectype) {489 case NTLMv2:490 seq_puts(s, "ntlmv2");491 break;492 case Kerberos:493 seq_puts(s, "krb5");494 break;495 case RawNTLMSSP:496 seq_puts(s, "ntlmssp");497 break;498 default:499 /* shouldn't ever happen */500 seq_puts(s, "unknown");501 break;502 }503 504 if (ses->sign)505 seq_puts(s, "i");506 507 if (ses->sectype == Kerberos)508 seq_printf(s, ",cruid=%u",509 from_kuid_munged(&init_user_ns, ses->cred_uid));510}511 512static void513cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)514{515 seq_puts(s, ",cache=");516 517 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)518 seq_puts(s, "strict");519 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)520 seq_puts(s, "none");521 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)522 seq_puts(s, "singleclient"); /* assume only one client access */523 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)524 seq_puts(s, "ro"); /* read only caching assumed */525 else526 seq_puts(s, "loose");527}528 529/*530 * cifs_show_devname() is used so we show the mount device name with correct531 * format (e.g. forward slashes vs. back slashes) in /proc/mounts532 */533static int cifs_show_devname(struct seq_file *m, struct dentry *root)534{535 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);536 char *devname = kstrdup(cifs_sb->ctx->source, GFP_KERNEL);537 538 if (devname == NULL)539 seq_puts(m, "none");540 else {541 convert_delimiter(devname, '/');542 /* escape all spaces in share names */543 seq_escape(m, devname, " \t");544 kfree(devname);545 }546 return 0;547}548 549/*550 * cifs_show_options() is for displaying mount options in /proc/mounts.551 * Not all settable options are displayed but most of the important552 * ones are.553 */554static int555cifs_show_options(struct seq_file *s, struct dentry *root)556{557 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);558 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);559 struct sockaddr *srcaddr;560 srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;561 562 seq_show_option(s, "vers", tcon->ses->server->vals->version_string);563 cifs_show_security(s, tcon->ses);564 cifs_show_cache_flavor(s, cifs_sb);565 566 if (tcon->no_lease)567 seq_puts(s, ",nolease");568 if (cifs_sb->ctx->multiuser)569 seq_puts(s, ",multiuser");570 else if (tcon->ses->user_name)571 seq_show_option(s, "username", tcon->ses->user_name);572 573 if (tcon->ses->domainName && tcon->ses->domainName[0] != 0)574 seq_show_option(s, "domain", tcon->ses->domainName);575 576 if (srcaddr->sa_family != AF_UNSPEC) {577 struct sockaddr_in *saddr4;578 struct sockaddr_in6 *saddr6;579 saddr4 = (struct sockaddr_in *)srcaddr;580 saddr6 = (struct sockaddr_in6 *)srcaddr;581 if (srcaddr->sa_family == AF_INET6)582 seq_printf(s, ",srcaddr=%pI6c",583 &saddr6->sin6_addr);584 else if (srcaddr->sa_family == AF_INET)585 seq_printf(s, ",srcaddr=%pI4",586 &saddr4->sin_addr.s_addr);587 else588 seq_printf(s, ",srcaddr=BAD-AF:%i",589 (int)(srcaddr->sa_family));590 }591 592 seq_printf(s, ",uid=%u",593 from_kuid_munged(&init_user_ns, cifs_sb->ctx->linux_uid));594 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)595 seq_puts(s, ",forceuid");596 else597 seq_puts(s, ",noforceuid");598 599 seq_printf(s, ",gid=%u",600 from_kgid_munged(&init_user_ns, cifs_sb->ctx->linux_gid));601 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)602 seq_puts(s, ",forcegid");603 else604 seq_puts(s, ",noforcegid");605 606 cifs_show_address(s, tcon->ses->server);607 608 if (!tcon->unix_ext)609 seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",610 cifs_sb->ctx->file_mode,611 cifs_sb->ctx->dir_mode);612 if (cifs_sb->ctx->iocharset)613 seq_printf(s, ",iocharset=%s", cifs_sb->ctx->iocharset);614 if (tcon->seal)615 seq_puts(s, ",seal");616 else if (tcon->ses->server->ignore_signature)617 seq_puts(s, ",signloosely");618 if (tcon->nocase)619 seq_puts(s, ",nocase");620 if (tcon->nodelete)621 seq_puts(s, ",nodelete");622 if (cifs_sb->ctx->no_sparse)623 seq_puts(s, ",nosparse");624 if (tcon->local_lease)625 seq_puts(s, ",locallease");626 if (tcon->retry)627 seq_puts(s, ",hard");628 else629 seq_puts(s, ",soft");630 if (tcon->use_persistent)631 seq_puts(s, ",persistenthandles");632 else if (tcon->use_resilient)633 seq_puts(s, ",resilienthandles");634 if (tcon->posix_extensions)635 seq_puts(s, ",posix");636 else if (tcon->unix_ext)637 seq_puts(s, ",unix");638 else639 seq_puts(s, ",nounix");640 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)641 seq_puts(s, ",nodfs");642 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)643 seq_puts(s, ",posixpaths");644 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)645 seq_puts(s, ",setuids");646 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL)647 seq_puts(s, ",idsfromsid");648 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)649 seq_puts(s, ",serverino");650 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)651 seq_puts(s, ",rwpidforward");652 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)653 seq_puts(s, ",forcemand");654 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)655 seq_puts(s, ",nouser_xattr");656 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)657 seq_puts(s, ",mapchars");658 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)659 seq_puts(s, ",mapposix");660 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)661 seq_puts(s, ",sfu");662 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)663 seq_puts(s, ",nobrl");664 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_HANDLE_CACHE)665 seq_puts(s, ",nohandlecache");666 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)667 seq_puts(s, ",modefromsid");668 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)669 seq_puts(s, ",cifsacl");670 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)671 seq_puts(s, ",dynperm");672 if (root->d_sb->s_flags & SB_POSIXACL)673 seq_puts(s, ",acl");674 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)675 seq_puts(s, ",mfsymlinks");676 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)677 seq_puts(s, ",fsc");678 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)679 seq_puts(s, ",nostrictsync");680 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)681 seq_puts(s, ",noperm");682 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)683 seq_printf(s, ",backupuid=%u",684 from_kuid_munged(&init_user_ns,685 cifs_sb->ctx->backupuid));686 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)687 seq_printf(s, ",backupgid=%u",688 from_kgid_munged(&init_user_ns,689 cifs_sb->ctx->backupgid));690 seq_show_option(s, "reparse",691 cifs_reparse_type_str(cifs_sb->ctx->reparse_type));692 693 seq_printf(s, ",rsize=%u", cifs_sb->ctx->rsize);694 seq_printf(s, ",wsize=%u", cifs_sb->ctx->wsize);695 seq_printf(s, ",bsize=%u", cifs_sb->ctx->bsize);696 if (cifs_sb->ctx->rasize)697 seq_printf(s, ",rasize=%u", cifs_sb->ctx->rasize);698 if (tcon->ses->server->min_offload)699 seq_printf(s, ",esize=%u", tcon->ses->server->min_offload);700 if (tcon->ses->server->retrans)701 seq_printf(s, ",retrans=%u", tcon->ses->server->retrans);702 seq_printf(s, ",echo_interval=%lu",703 tcon->ses->server->echo_interval / HZ);704 705 /* Only display the following if overridden on mount */706 if (tcon->ses->server->max_credits != SMB2_MAX_CREDITS_AVAILABLE)707 seq_printf(s, ",max_credits=%u", tcon->ses->server->max_credits);708 if (tcon->ses->server->tcp_nodelay)709 seq_puts(s, ",tcpnodelay");710 if (tcon->ses->server->noautotune)711 seq_puts(s, ",noautotune");712 if (tcon->ses->server->noblocksnd)713 seq_puts(s, ",noblocksend");714 if (tcon->ses->server->nosharesock)715 seq_puts(s, ",nosharesock");716 717 if (tcon->snapshot_time)718 seq_printf(s, ",snapshot=%llu", tcon->snapshot_time);719 if (tcon->handle_timeout)720 seq_printf(s, ",handletimeout=%u", tcon->handle_timeout);721 if (tcon->max_cached_dirs != MAX_CACHED_FIDS)722 seq_printf(s, ",max_cached_dirs=%u", tcon->max_cached_dirs);723 724 /*725 * Display file and directory attribute timeout in seconds.726 * If file and directory attribute timeout the same then actimeo727 * was likely specified on mount728 */729 if (cifs_sb->ctx->acdirmax == cifs_sb->ctx->acregmax)730 seq_printf(s, ",actimeo=%lu", cifs_sb->ctx->acregmax / HZ);731 else {732 seq_printf(s, ",acdirmax=%lu", cifs_sb->ctx->acdirmax / HZ);733 seq_printf(s, ",acregmax=%lu", cifs_sb->ctx->acregmax / HZ);734 }735 seq_printf(s, ",closetimeo=%lu", cifs_sb->ctx->closetimeo / HZ);736 737 if (tcon->ses->chan_max > 1)738 seq_printf(s, ",multichannel,max_channels=%zu",739 tcon->ses->chan_max);740 741 if (tcon->use_witness)742 seq_puts(s, ",witness");743 744 return 0;745}746 747static void cifs_umount_begin(struct super_block *sb)748{749 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);750 struct cifs_tcon *tcon;751 752 if (cifs_sb == NULL)753 return;754 755 tcon = cifs_sb_master_tcon(cifs_sb);756 757 spin_lock(&cifs_tcp_ses_lock);758 spin_lock(&tcon->tc_lock);759 trace_smb3_tcon_ref(tcon->debug_id, tcon->tc_count,760 netfs_trace_tcon_ref_see_umount);761 if ((tcon->tc_count > 1) || (tcon->status == TID_EXITING)) {762 /* we have other mounts to same share or we have763 already tried to umount this and woken up764 all waiting network requests, nothing to do */765 spin_unlock(&tcon->tc_lock);766 spin_unlock(&cifs_tcp_ses_lock);767 return;768 }769 /*770 * can not set tcon->status to TID_EXITING yet since we don't know if umount -f will771 * fail later (e.g. due to open files). TID_EXITING will be set just before tdis req sent772 */773 spin_unlock(&tcon->tc_lock);774 spin_unlock(&cifs_tcp_ses_lock);775 776 cifs_close_all_deferred_files(tcon);777 /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */778 /* cancel_notify_requests(tcon); */779 if (tcon->ses && tcon->ses->server) {780 cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");781 wake_up_all(&tcon->ses->server->request_q);782 wake_up_all(&tcon->ses->server->response_q);783 msleep(1); /* yield */784 /* we have to kick the requests once more */785 wake_up_all(&tcon->ses->server->response_q);786 msleep(1);787 }788 789 return;790}791 792static int cifs_freeze(struct super_block *sb)793{794 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);795 struct cifs_tcon *tcon;796 797 if (cifs_sb == NULL)798 return 0;799 800 tcon = cifs_sb_master_tcon(cifs_sb);801 802 cifs_close_all_deferred_files(tcon);803 return 0;804}805 806#ifdef CONFIG_CIFS_STATS2807static int cifs_show_stats(struct seq_file *s, struct dentry *root)808{809 /* BB FIXME */810 return 0;811}812#endif813 814static int cifs_write_inode(struct inode *inode, struct writeback_control *wbc)815{816 return netfs_unpin_writeback(inode, wbc);817}818 819static int cifs_drop_inode(struct inode *inode)820{821 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);822 823 /* no serverino => unconditional eviction */824 return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||825 generic_drop_inode(inode);826}827 828static const struct super_operations cifs_super_ops = {829 .statfs = cifs_statfs,830 .alloc_inode = cifs_alloc_inode,831 .write_inode = cifs_write_inode,832 .free_inode = cifs_free_inode,833 .drop_inode = cifs_drop_inode,834 .evict_inode = cifs_evict_inode,835/* .show_path = cifs_show_path, */ /* Would we ever need show path? */836 .show_devname = cifs_show_devname,837/* .delete_inode = cifs_delete_inode, */ /* Do not need above838 function unless later we add lazy close of inodes or unless the839 kernel forgets to call us with the same number of releases (closes)840 as opens */841 .show_options = cifs_show_options,842 .umount_begin = cifs_umount_begin,843 .freeze_fs = cifs_freeze,844#ifdef CONFIG_CIFS_STATS2845 .show_stats = cifs_show_stats,846#endif847};848 849/*850 * Get root dentry from superblock according to prefix path mount option.851 * Return dentry with refcount + 1 on success and NULL otherwise.852 */853static struct dentry *854cifs_get_root(struct smb3_fs_context *ctx, struct super_block *sb)855{856 struct dentry *dentry;857 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);858 char *full_path = NULL;859 char *s, *p;860 char sep;861 862 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)863 return dget(sb->s_root);864 865 full_path = cifs_build_path_to_root(ctx, cifs_sb,866 cifs_sb_master_tcon(cifs_sb), 0);867 if (full_path == NULL)868 return ERR_PTR(-ENOMEM);869 870 cifs_dbg(FYI, "Get root dentry for %s\n", full_path);871 872 sep = CIFS_DIR_SEP(cifs_sb);873 dentry = dget(sb->s_root);874 s = full_path;875 876 do {877 struct inode *dir = d_inode(dentry);878 struct dentry *child;879 880 if (!S_ISDIR(dir->i_mode)) {881 dput(dentry);882 dentry = ERR_PTR(-ENOTDIR);883 break;884 }885 886 /* skip separators */887 while (*s == sep)888 s++;889 if (!*s)890 break;891 p = s++;892 /* next separator */893 while (*s && *s != sep)894 s++;895 896 child = lookup_positive_unlocked(p, dentry, s - p);897 dput(dentry);898 dentry = child;899 } while (!IS_ERR(dentry));900 kfree(full_path);901 return dentry;902}903 904static int cifs_set_super(struct super_block *sb, void *data)905{906 struct cifs_mnt_data *mnt_data = data;907 sb->s_fs_info = mnt_data->cifs_sb;908 return set_anon_super(sb, NULL);909}910 911struct dentry *912cifs_smb3_do_mount(struct file_system_type *fs_type,913 int flags, struct smb3_fs_context *old_ctx)914{915 struct cifs_mnt_data mnt_data;916 struct cifs_sb_info *cifs_sb;917 struct super_block *sb;918 struct dentry *root;919 int rc;920 921 if (cifsFYI) {922 cifs_dbg(FYI, "%s: devname=%s flags=0x%x\n", __func__,923 old_ctx->source, flags);924 } else {925 cifs_info("Attempting to mount %s\n", old_ctx->source);926 }927 928 cifs_sb = kzalloc(sizeof(*cifs_sb), GFP_KERNEL);929 if (!cifs_sb)930 return ERR_PTR(-ENOMEM);931 932 cifs_sb->ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);933 if (!cifs_sb->ctx) {934 root = ERR_PTR(-ENOMEM);935 goto out;936 }937 rc = smb3_fs_context_dup(cifs_sb->ctx, old_ctx);938 if (rc) {939 root = ERR_PTR(rc);940 goto out;941 }942 943 rc = cifs_setup_cifs_sb(cifs_sb);944 if (rc) {945 root = ERR_PTR(rc);946 goto out;947 }948 949 rc = cifs_mount(cifs_sb, cifs_sb->ctx);950 if (rc) {951 if (!(flags & SB_SILENT))952 cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",953 rc);954 root = ERR_PTR(rc);955 goto out;956 }957 958 mnt_data.ctx = cifs_sb->ctx;959 mnt_data.cifs_sb = cifs_sb;960 mnt_data.flags = flags;961 962 /* BB should we make this contingent on mount parm? */963 flags |= SB_NODIRATIME | SB_NOATIME;964 965 sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);966 if (IS_ERR(sb)) {967 cifs_umount(cifs_sb);968 return ERR_CAST(sb);969 }970 971 if (sb->s_root) {972 cifs_dbg(FYI, "Use existing superblock\n");973 cifs_umount(cifs_sb);974 cifs_sb = NULL;975 } else {976 rc = cifs_read_super(sb);977 if (rc) {978 root = ERR_PTR(rc);979 goto out_super;980 }981 982 sb->s_flags |= SB_ACTIVE;983 }984 985 root = cifs_get_root(cifs_sb ? cifs_sb->ctx : old_ctx, sb);986 if (IS_ERR(root))987 goto out_super;988 989 if (cifs_sb)990 cifs_sb->root = dget(root);991 992 cifs_dbg(FYI, "dentry root is: %p\n", root);993 return root;994 995out_super:996 deactivate_locked_super(sb);997 return root;998out:999 kfree(cifs_sb->prepath);1000 smb3_cleanup_fs_context(cifs_sb->ctx);1001 kfree(cifs_sb);1002 return root;1003}1004 1005static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)1006{1007 struct cifsFileInfo *cfile = file->private_data;1008 struct cifs_tcon *tcon;1009 1010 /*1011 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate1012 * the cached file length1013 */1014 if (whence != SEEK_SET && whence != SEEK_CUR) {1015 int rc;1016 struct inode *inode = file_inode(file);1017 1018 /*1019 * We need to be sure that all dirty pages are written and the1020 * server has the newest file length.1021 */1022 if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&1023 inode->i_mapping->nrpages != 0) {1024 rc = filemap_fdatawait(inode->i_mapping);1025 if (rc) {1026 mapping_set_error(inode->i_mapping, rc);1027 return rc;1028 }1029 }1030 /*1031 * Some applications poll for the file length in this strange1032 * way so we must seek to end on non-oplocked files by1033 * setting the revalidate time to zero.1034 */1035 CIFS_I(inode)->time = 0;1036 1037 rc = cifs_revalidate_file_attr(file);1038 if (rc < 0)1039 return (loff_t)rc;1040 }1041 if (cfile && cfile->tlink) {1042 tcon = tlink_tcon(cfile->tlink);1043 if (tcon->ses->server->ops->llseek)1044 return tcon->ses->server->ops->llseek(file, tcon,1045 offset, whence);1046 }1047 return generic_file_llseek(file, offset, whence);1048}1049 1050static int1051cifs_setlease(struct file *file, int arg, struct file_lease **lease, void **priv)1052{1053 /*1054 * Note that this is called by vfs setlease with i_lock held to1055 * protect *lease from going away.1056 */1057 struct inode *inode = file_inode(file);1058 struct cifsFileInfo *cfile = file->private_data;1059 1060 /* Check if file is oplocked if this is request for new lease */1061 if (arg == F_UNLCK ||1062 ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||1063 ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))1064 return generic_setlease(file, arg, lease, priv);1065 else if (tlink_tcon(cfile->tlink)->local_lease &&1066 !CIFS_CACHE_READ(CIFS_I(inode)))1067 /*1068 * If the server claims to support oplock on this file, then we1069 * still need to check oplock even if the local_lease mount1070 * option is set, but there are servers which do not support1071 * oplock for which this mount option may be useful if the user1072 * knows that the file won't be changed on the server by anyone1073 * else.1074 */1075 return generic_setlease(file, arg, lease, priv);1076 else1077 return -EAGAIN;1078}1079 1080struct file_system_type cifs_fs_type = {1081 .owner = THIS_MODULE,1082 .name = "cifs",1083 .init_fs_context = smb3_init_fs_context,1084 .parameters = smb3_fs_parameters,1085 .kill_sb = cifs_kill_sb,1086 .fs_flags = FS_RENAME_DOES_D_MOVE,1087};1088MODULE_ALIAS_FS("cifs");1089 1090struct file_system_type smb3_fs_type = {1091 .owner = THIS_MODULE,1092 .name = "smb3",1093 .init_fs_context = smb3_init_fs_context,1094 .parameters = smb3_fs_parameters,1095 .kill_sb = cifs_kill_sb,1096 .fs_flags = FS_RENAME_DOES_D_MOVE,1097};1098MODULE_ALIAS_FS("smb3");1099MODULE_ALIAS("smb3");1100 1101const struct inode_operations cifs_dir_inode_ops = {1102 .create = cifs_create,1103 .atomic_open = cifs_atomic_open,1104 .lookup = cifs_lookup,1105 .getattr = cifs_getattr,1106 .unlink = cifs_unlink,1107 .link = cifs_hardlink,1108 .mkdir = cifs_mkdir,1109 .rmdir = cifs_rmdir,1110 .rename = cifs_rename2,1111 .permission = cifs_permission,1112 .setattr = cifs_setattr,1113 .symlink = cifs_symlink,1114 .mknod = cifs_mknod,1115 .listxattr = cifs_listxattr,1116 .get_acl = cifs_get_acl,1117 .set_acl = cifs_set_acl,1118};1119 1120const struct inode_operations cifs_file_inode_ops = {1121 .setattr = cifs_setattr,1122 .getattr = cifs_getattr,1123 .permission = cifs_permission,1124 .listxattr = cifs_listxattr,1125 .fiemap = cifs_fiemap,1126 .get_acl = cifs_get_acl,1127 .set_acl = cifs_set_acl,1128};1129 1130const char *cifs_get_link(struct dentry *dentry, struct inode *inode,1131 struct delayed_call *done)1132{1133 char *target_path;1134 1135 if (!dentry)1136 return ERR_PTR(-ECHILD);1137 1138 target_path = kmalloc(PATH_MAX, GFP_KERNEL);1139 if (!target_path)1140 return ERR_PTR(-ENOMEM);1141 1142 spin_lock(&inode->i_lock);1143 if (likely(CIFS_I(inode)->symlink_target)) {1144 strscpy(target_path, CIFS_I(inode)->symlink_target, PATH_MAX);1145 } else {1146 kfree(target_path);1147 target_path = ERR_PTR(-EOPNOTSUPP);1148 }1149 spin_unlock(&inode->i_lock);1150 1151 if (!IS_ERR(target_path))1152 set_delayed_call(done, kfree_link, target_path);1153 1154 return target_path;1155}1156 1157const struct inode_operations cifs_symlink_inode_ops = {1158 .get_link = cifs_get_link,1159 .setattr = cifs_setattr,1160 .permission = cifs_permission,1161 .listxattr = cifs_listxattr,1162};1163 1164/*1165 * Advance the EOF marker to after the source range.1166 */1167static int cifs_precopy_set_eof(struct inode *src_inode, struct cifsInodeInfo *src_cifsi,1168 struct cifs_tcon *src_tcon,1169 unsigned int xid, loff_t src_end)1170{1171 struct cifsFileInfo *writeable_srcfile;1172 int rc = -EINVAL;1173 1174 writeable_srcfile = find_writable_file(src_cifsi, FIND_WR_FSUID_ONLY);1175 if (writeable_srcfile) {1176 if (src_tcon->ses->server->ops->set_file_size)1177 rc = src_tcon->ses->server->ops->set_file_size(1178 xid, src_tcon, writeable_srcfile,1179 src_inode->i_size, true /* no need to set sparse */);1180 else1181 rc = -ENOSYS;1182 cifsFileInfo_put(writeable_srcfile);1183 cifs_dbg(FYI, "SetFSize for copychunk rc = %d\n", rc);1184 }1185 1186 if (rc < 0)1187 goto set_failed;1188 1189 netfs_resize_file(&src_cifsi->netfs, src_end, true);1190 fscache_resize_cookie(cifs_inode_cookie(src_inode), src_end);1191 return 0;1192 1193set_failed:1194 return filemap_write_and_wait(src_inode->i_mapping);1195}1196 1197/*1198 * Flush out either the folio that overlaps the beginning of a range in which1199 * pos resides or the folio that overlaps the end of a range unless that folio1200 * is entirely within the range we're going to invalidate. We extend the flush1201 * bounds to encompass the folio.1202 */1203static int cifs_flush_folio(struct inode *inode, loff_t pos, loff_t *_fstart, loff_t *_fend,1204 bool first)1205{1206 struct folio *folio;1207 unsigned long long fpos, fend;1208 pgoff_t index = pos / PAGE_SIZE;1209 size_t size;1210 int rc = 0;1211 1212 folio = filemap_get_folio(inode->i_mapping, index);1213 if (IS_ERR(folio))1214 return 0;1215 1216 size = folio_size(folio);1217 fpos = folio_pos(folio);1218 fend = fpos + size - 1;1219 *_fstart = min_t(unsigned long long, *_fstart, fpos);1220 *_fend = max_t(unsigned long long, *_fend, fend);1221 if ((first && pos == fpos) || (!first && pos == fend))1222 goto out;1223 1224 rc = filemap_write_and_wait_range(inode->i_mapping, fpos, fend);1225out:1226 folio_put(folio);1227 return rc;1228}1229 1230static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,1231 struct file *dst_file, loff_t destoff, loff_t len,1232 unsigned int remap_flags)1233{1234 struct inode *src_inode = file_inode(src_file);1235 struct inode *target_inode = file_inode(dst_file);1236 struct cifsInodeInfo *src_cifsi = CIFS_I(src_inode);1237 struct cifsInodeInfo *target_cifsi = CIFS_I(target_inode);1238 struct cifsFileInfo *smb_file_src = src_file->private_data;1239 struct cifsFileInfo *smb_file_target = dst_file->private_data;1240 struct cifs_tcon *target_tcon, *src_tcon;1241 unsigned long long destend, fstart, fend, old_size, new_size;1242 unsigned int xid;1243 int rc;1244 1245 if (remap_flags & REMAP_FILE_DEDUP)1246 return -EOPNOTSUPP;1247 if (remap_flags & ~REMAP_FILE_ADVISORY)1248 return -EINVAL;1249 1250 cifs_dbg(FYI, "clone range\n");1251 1252 xid = get_xid();1253 1254 if (!smb_file_src || !smb_file_target) {1255 rc = -EBADF;1256 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");1257 goto out;1258 }1259 1260 src_tcon = tlink_tcon(smb_file_src->tlink);1261 target_tcon = tlink_tcon(smb_file_target->tlink);1262 1263 /*1264 * Note: cifs case is easier than btrfs since server responsible for1265 * checks for proper open modes and file type and if it wants1266 * server could even support copy of range where source = target1267 */1268 lock_two_nondirectories(target_inode, src_inode);1269 1270 if (len == 0)1271 len = src_inode->i_size - off;1272 1273 cifs_dbg(FYI, "clone range\n");1274 1275 /* Flush the source buffer */1276 rc = filemap_write_and_wait_range(src_inode->i_mapping, off,1277 off + len - 1);1278 if (rc)1279 goto unlock;1280 1281 /* The server-side copy will fail if the source crosses the EOF marker.1282 * Advance the EOF marker after the flush above to the end of the range1283 * if it's short of that.1284 */1285 if (src_cifsi->netfs.remote_i_size < off + len) {1286 rc = cifs_precopy_set_eof(src_inode, src_cifsi, src_tcon, xid, off + len);1287 if (rc < 0)1288 goto unlock;1289 }1290 1291 new_size = destoff + len;1292 destend = destoff + len - 1;1293 1294 /* Flush the folios at either end of the destination range to prevent1295 * accidental loss of dirty data outside of the range.1296 */1297 fstart = destoff;1298 fend = destend;1299 1300 rc = cifs_flush_folio(target_inode, destoff, &fstart, &fend, true);1301 if (rc)1302 goto unlock;1303 rc = cifs_flush_folio(target_inode, destend, &fstart, &fend, false);1304 if (rc)1305 goto unlock;1306 if (fend > target_cifsi->netfs.zero_point)1307 target_cifsi->netfs.zero_point = fend + 1;1308 old_size = target_cifsi->netfs.remote_i_size;1309 1310 /* Discard all the folios that overlap the destination region. */1311 cifs_dbg(FYI, "about to discard pages %llx-%llx\n", fstart, fend);1312 truncate_inode_pages_range(&target_inode->i_data, fstart, fend);1313 1314 fscache_invalidate(cifs_inode_cookie(target_inode), NULL,1315 i_size_read(target_inode), 0);1316 1317 rc = -EOPNOTSUPP;1318 if (target_tcon->ses->server->ops->duplicate_extents) {1319 rc = target_tcon->ses->server->ops->duplicate_extents(xid,1320 smb_file_src, smb_file_target, off, len, destoff);1321 if (rc == 0 && new_size > old_size) {1322 truncate_setsize(target_inode, new_size);1323 fscache_resize_cookie(cifs_inode_cookie(target_inode),1324 new_size);1325 }1326 if (rc == 0 && new_size > target_cifsi->netfs.zero_point)1327 target_cifsi->netfs.zero_point = new_size;1328 }1329 1330 /* force revalidate of size and timestamps of target file now1331 that target is updated on the server */1332 CIFS_I(target_inode)->time = 0;1333unlock:1334 /* although unlocking in the reverse order from locking is not1335 strictly necessary here it is a little cleaner to be consistent */1336 unlock_two_nondirectories(src_inode, target_inode);1337out:1338 free_xid(xid);1339 return rc < 0 ? rc : len;1340}1341 1342ssize_t cifs_file_copychunk_range(unsigned int xid,1343 struct file *src_file, loff_t off,1344 struct file *dst_file, loff_t destoff,1345 size_t len, unsigned int flags)1346{1347 struct inode *src_inode = file_inode(src_file);1348 struct inode *target_inode = file_inode(dst_file);1349 struct cifsInodeInfo *src_cifsi = CIFS_I(src_inode);1350 struct cifsInodeInfo *target_cifsi = CIFS_I(target_inode);1351 struct cifsFileInfo *smb_file_src;1352 struct cifsFileInfo *smb_file_target;1353 struct cifs_tcon *src_tcon;1354 struct cifs_tcon *target_tcon;1355 ssize_t rc;1356 1357 cifs_dbg(FYI, "copychunk range\n");1358 1359 if (!src_file->private_data || !dst_file->private_data) {1360 rc = -EBADF;1361 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");1362 goto out;1363 }1364 1365 rc = -EXDEV;1366 smb_file_target = dst_file->private_data;1367 smb_file_src = src_file->private_data;1368 src_tcon = tlink_tcon(smb_file_src->tlink);1369 target_tcon = tlink_tcon(smb_file_target->tlink);1370 1371 if (src_tcon->ses != target_tcon->ses) {1372 cifs_dbg(FYI, "source and target of copy not on same server\n");1373 goto out;1374 }1375 1376 rc = -EOPNOTSUPP;1377 if (!target_tcon->ses->server->ops->copychunk_range)1378 goto out;1379 1380 /*1381 * Note: cifs case is easier than btrfs since server responsible for1382 * checks for proper open modes and file type and if it wants1383 * server could even support copy of range where source = target1384 */1385 lock_two_nondirectories(target_inode, src_inode);1386 1387 cifs_dbg(FYI, "about to flush pages\n");1388 1389 rc = filemap_write_and_wait_range(src_inode->i_mapping, off,1390 off + len - 1);1391 if (rc)1392 goto unlock;1393 1394 /* The server-side copy will fail if the source crosses the EOF marker.1395 * Advance the EOF marker after the flush above to the end of the range1396 * if it's short of that.1397 */1398 if (src_cifsi->netfs.remote_i_size < off + len) {1399 rc = cifs_precopy_set_eof(src_inode, src_cifsi, src_tcon, xid, off + len);1400 if (rc < 0)1401 goto unlock;1402 }1403 1404 /* Flush and invalidate all the folios in the destination region. If1405 * the copy was successful, then some of the flush is extra overhead,1406 * but we need to allow for the copy failing in some way (eg. ENOSPC).1407 */1408 rc = filemap_invalidate_inode(target_inode, true, destoff, destoff + len - 1);1409 if (rc)1410 goto unlock;1411 1412 fscache_invalidate(cifs_inode_cookie(target_inode), NULL,1413 i_size_read(target_inode), 0);1414 1415 rc = file_modified(dst_file);1416 if (!rc) {1417 rc = target_tcon->ses->server->ops->copychunk_range(xid,1418 smb_file_src, smb_file_target, off, len, destoff);1419 if (rc > 0 && destoff + rc > i_size_read(target_inode)) {1420 truncate_setsize(target_inode, destoff + rc);1421 netfs_resize_file(&target_cifsi->netfs,1422 i_size_read(target_inode), true);1423 fscache_resize_cookie(cifs_inode_cookie(target_inode),1424 i_size_read(target_inode));1425 }1426 if (rc > 0 && destoff + rc > target_cifsi->netfs.zero_point)1427 target_cifsi->netfs.zero_point = destoff + rc;1428 }1429 1430 file_accessed(src_file);1431 1432 /* force revalidate of size and timestamps of target file now1433 * that target is updated on the server1434 */1435 CIFS_I(target_inode)->time = 0;1436 1437unlock:1438 /* although unlocking in the reverse order from locking is not1439 * strictly necessary here it is a little cleaner to be consistent1440 */1441 unlock_two_nondirectories(src_inode, target_inode);1442 1443out:1444 return rc;1445}1446 1447/*1448 * Directory operations under CIFS/SMB2/SMB3 are synchronous, so fsync()1449 * is a dummy operation.1450 */1451static int cifs_dir_fsync(struct file *file, loff_t start, loff_t end, int datasync)1452{1453 cifs_dbg(FYI, "Sync directory - name: %pD datasync: 0x%x\n",1454 file, datasync);1455 1456 return 0;1457}1458 1459static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off,1460 struct file *dst_file, loff_t destoff,1461 size_t len, unsigned int flags)1462{1463 unsigned int xid = get_xid();1464 ssize_t rc;1465 struct cifsFileInfo *cfile = dst_file->private_data;1466 1467 if (cfile->swapfile) {1468 rc = -EOPNOTSUPP;1469 free_xid(xid);1470 return rc;1471 }1472 1473 rc = cifs_file_copychunk_range(xid, src_file, off, dst_file, destoff,1474 len, flags);1475 free_xid(xid);1476 1477 if (rc == -EOPNOTSUPP || rc == -EXDEV)1478 rc = splice_copy_file_range(src_file, off, dst_file,1479 destoff, len);1480 return rc;1481}1482 1483const struct file_operations cifs_file_ops = {1484 .read_iter = cifs_loose_read_iter,1485 .write_iter = cifs_file_write_iter,1486 .open = cifs_open,1487 .release = cifs_close,1488 .lock = cifs_lock,1489 .flock = cifs_flock,1490 .fsync = cifs_fsync,1491 .flush = cifs_flush,1492 .mmap = cifs_file_mmap,1493 .splice_read = filemap_splice_read,1494 .splice_write = iter_file_splice_write,1495 .llseek = cifs_llseek,1496 .unlocked_ioctl = cifs_ioctl,1497 .copy_file_range = cifs_copy_file_range,1498 .remap_file_range = cifs_remap_file_range,1499 .setlease = cifs_setlease,1500 .fallocate = cifs_fallocate,1501};1502 1503const struct file_operations cifs_file_strict_ops = {1504 .read_iter = cifs_strict_readv,1505 .write_iter = cifs_strict_writev,1506 .open = cifs_open,1507 .release = cifs_close,1508 .lock = cifs_lock,1509 .flock = cifs_flock,1510 .fsync = cifs_strict_fsync,1511 .flush = cifs_flush,1512 .mmap = cifs_file_strict_mmap,1513 .splice_read = filemap_splice_read,1514 .splice_write = iter_file_splice_write,1515 .llseek = cifs_llseek,1516 .unlocked_ioctl = cifs_ioctl,1517 .copy_file_range = cifs_copy_file_range,1518 .remap_file_range = cifs_remap_file_range,1519 .setlease = cifs_setlease,1520 .fallocate = cifs_fallocate,1521};1522 1523const struct file_operations cifs_file_direct_ops = {1524 .read_iter = netfs_unbuffered_read_iter,1525 .write_iter = netfs_file_write_iter,1526 .open = cifs_open,1527 .release = cifs_close,1528 .lock = cifs_lock,1529 .flock = cifs_flock,1530 .fsync = cifs_fsync,1531 .flush = cifs_flush,1532 .mmap = cifs_file_mmap,1533 .splice_read = copy_splice_read,1534 .splice_write = iter_file_splice_write,1535 .unlocked_ioctl = cifs_ioctl,1536 .copy_file_range = cifs_copy_file_range,1537 .remap_file_range = cifs_remap_file_range,1538 .llseek = cifs_llseek,1539 .setlease = cifs_setlease,1540 .fallocate = cifs_fallocate,1541};1542 1543const struct file_operations cifs_file_nobrl_ops = {1544 .read_iter = cifs_loose_read_iter,1545 .write_iter = cifs_file_write_iter,1546 .open = cifs_open,1547 .release = cifs_close,1548 .fsync = cifs_fsync,1549 .flush = cifs_flush,1550 .mmap = cifs_file_mmap,1551 .splice_read = filemap_splice_read,1552 .splice_write = iter_file_splice_write,1553 .llseek = cifs_llseek,1554 .unlocked_ioctl = cifs_ioctl,1555 .copy_file_range = cifs_copy_file_range,1556 .remap_file_range = cifs_remap_file_range,1557 .setlease = cifs_setlease,1558 .fallocate = cifs_fallocate,1559};1560 1561const struct file_operations cifs_file_strict_nobrl_ops = {1562 .read_iter = cifs_strict_readv,1563 .write_iter = cifs_strict_writev,1564 .open = cifs_open,1565 .release = cifs_close,1566 .fsync = cifs_strict_fsync,1567 .flush = cifs_flush,1568 .mmap = cifs_file_strict_mmap,1569 .splice_read = filemap_splice_read,1570 .splice_write = iter_file_splice_write,1571 .llseek = cifs_llseek,1572 .unlocked_ioctl = cifs_ioctl,1573 .copy_file_range = cifs_copy_file_range,1574 .remap_file_range = cifs_remap_file_range,1575 .setlease = cifs_setlease,1576 .fallocate = cifs_fallocate,1577};1578 1579const struct file_operations cifs_file_direct_nobrl_ops = {1580 .read_iter = netfs_unbuffered_read_iter,1581 .write_iter = netfs_file_write_iter,1582 .open = cifs_open,1583 .release = cifs_close,1584 .fsync = cifs_fsync,1585 .flush = cifs_flush,1586 .mmap = cifs_file_mmap,1587 .splice_read = copy_splice_read,1588 .splice_write = iter_file_splice_write,1589 .unlocked_ioctl = cifs_ioctl,1590 .copy_file_range = cifs_copy_file_range,1591 .remap_file_range = cifs_remap_file_range,1592 .llseek = cifs_llseek,1593 .setlease = cifs_setlease,1594 .fallocate = cifs_fallocate,1595};1596 1597const struct file_operations cifs_dir_ops = {1598 .iterate_shared = cifs_readdir,1599 .release = cifs_closedir,1600 .read = generic_read_dir,1601 .unlocked_ioctl = cifs_ioctl,1602 .copy_file_range = cifs_copy_file_range,1603 .remap_file_range = cifs_remap_file_range,1604 .llseek = generic_file_llseek,1605 .fsync = cifs_dir_fsync,1606};1607 1608static void1609cifs_init_once(void *inode)1610{1611 struct cifsInodeInfo *cifsi = inode;1612 1613 inode_init_once(&cifsi->netfs.inode);1614 init_rwsem(&cifsi->lock_sem);1615}1616 1617static int __init1618cifs_init_inodecache(void)1619{1620 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",1621 sizeof(struct cifsInodeInfo),1622 0, (SLAB_RECLAIM_ACCOUNT|1623 SLAB_ACCOUNT),1624 cifs_init_once);1625 if (cifs_inode_cachep == NULL)1626 return -ENOMEM;1627 1628 return 0;1629}1630 1631static void1632cifs_destroy_inodecache(void)1633{1634 /*1635 * Make sure all delayed rcu free inodes are flushed before we1636 * destroy cache.1637 */1638 rcu_barrier();1639 kmem_cache_destroy(cifs_inode_cachep);1640}1641 1642static int1643cifs_init_request_bufs(void)1644{1645 /*1646 * SMB2 maximum header size is bigger than CIFS one - no problems to1647 * allocate some more bytes for CIFS.1648 */1649 size_t max_hdr_size = MAX_SMB2_HDR_SIZE;1650 1651 if (CIFSMaxBufSize < 8192) {1652 /* Buffer size can not be smaller than 2 * PATH_MAX since maximum1653 Unicode path name has to fit in any SMB/CIFS path based frames */1654 CIFSMaxBufSize = 8192;1655 } else if (CIFSMaxBufSize > 1024*127) {1656 CIFSMaxBufSize = 1024 * 127;1657 } else {1658 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/1659 }1660/*1661 cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",1662 CIFSMaxBufSize, CIFSMaxBufSize);1663*/1664 cifs_req_cachep = kmem_cache_create_usercopy("cifs_request",1665 CIFSMaxBufSize + max_hdr_size, 0,1666 SLAB_HWCACHE_ALIGN, 0,1667 CIFSMaxBufSize + max_hdr_size,1668 NULL);1669 if (cifs_req_cachep == NULL)1670 return -ENOMEM;1671 1672 if (cifs_min_rcv < 1)1673 cifs_min_rcv = 1;1674 else if (cifs_min_rcv > 64) {1675 cifs_min_rcv = 64;1676 cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");1677 }1678 1679 cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,1680 cifs_req_cachep);1681 1682 if (cifs_req_poolp == NULL) {1683 kmem_cache_destroy(cifs_req_cachep);1684 return -ENOMEM;1685 }1686 /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and1687 almost all handle based requests (but not write response, nor is it1688 sufficient for path based requests). A smaller size would have1689 been more efficient (compacting multiple slab items on one 4k page)1690 for the case in which debug was on, but this larger size allows1691 more SMBs to use small buffer alloc and is still much more1692 efficient to alloc 1 per page off the slab compared to 17K (5page)1693 alloc of large cifs buffers even when page debugging is on */1694 cifs_sm_req_cachep = kmem_cache_create_usercopy("cifs_small_rq",1695 MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,1696 0, MAX_CIFS_SMALL_BUFFER_SIZE, NULL);1697 if (cifs_sm_req_cachep == NULL) {1698 mempool_destroy(cifs_req_poolp);1699 kmem_cache_destroy(cifs_req_cachep);1700 return -ENOMEM;1701 }1702 1703 if (cifs_min_small < 2)1704 cifs_min_small = 2;1705 else if (cifs_min_small > 256) {1706 cifs_min_small = 256;1707 cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");1708 }1709 1710 cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,1711 cifs_sm_req_cachep);1712 1713 if (cifs_sm_req_poolp == NULL) {1714 mempool_destroy(cifs_req_poolp);1715 kmem_cache_destroy(cifs_req_cachep);1716 kmem_cache_destroy(cifs_sm_req_cachep);1717 return -ENOMEM;1718 }1719 1720 return 0;1721}1722 1723static void1724cifs_destroy_request_bufs(void)1725{1726 mempool_destroy(cifs_req_poolp);1727 kmem_cache_destroy(cifs_req_cachep);1728 mempool_destroy(cifs_sm_req_poolp);1729 kmem_cache_destroy(cifs_sm_req_cachep);1730}1731 1732static int init_mids(void)1733{1734 cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",1735 sizeof(struct mid_q_entry), 0,1736 SLAB_HWCACHE_ALIGN, NULL);1737 if (cifs_mid_cachep == NULL)1738 return -ENOMEM;1739 1740 /* 3 is a reasonable minimum number of simultaneous operations */1741 cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);1742 if (cifs_mid_poolp == NULL) {1743 kmem_cache_destroy(cifs_mid_cachep);1744 return -ENOMEM;1745 }1746 1747 return 0;1748}1749 1750static void destroy_mids(void)1751{1752 mempool_destroy(cifs_mid_poolp);1753 kmem_cache_destroy(cifs_mid_cachep);1754}1755 1756static int cifs_init_netfs(void)1757{1758 cifs_io_request_cachep =1759 kmem_cache_create("cifs_io_request",1760 sizeof(struct cifs_io_request), 0,1761 SLAB_HWCACHE_ALIGN, NULL);1762 if (!cifs_io_request_cachep)1763 goto nomem_req;1764 1765 if (mempool_init_slab_pool(&cifs_io_request_pool, 100, cifs_io_request_cachep) < 0)1766 goto nomem_reqpool;1767 1768 cifs_io_subrequest_cachep =1769 kmem_cache_create("cifs_io_subrequest",1770 sizeof(struct cifs_io_subrequest), 0,1771 SLAB_HWCACHE_ALIGN, NULL);1772 if (!cifs_io_subrequest_cachep)1773 goto nomem_subreq;1774 1775 if (mempool_init_slab_pool(&cifs_io_subrequest_pool, 100, cifs_io_subrequest_cachep) < 0)1776 goto nomem_subreqpool;1777 1778 return 0;1779 1780nomem_subreqpool:1781 kmem_cache_destroy(cifs_io_subrequest_cachep);1782nomem_subreq:1783 mempool_exit(&cifs_io_request_pool);1784nomem_reqpool:1785 kmem_cache_destroy(cifs_io_request_cachep);1786nomem_req:1787 return -ENOMEM;1788}1789 1790static void cifs_destroy_netfs(void)1791{1792 mempool_exit(&cifs_io_subrequest_pool);1793 kmem_cache_destroy(cifs_io_subrequest_cachep);1794 mempool_exit(&cifs_io_request_pool);1795 kmem_cache_destroy(cifs_io_request_cachep);1796}1797 1798static int __init1799init_cifs(void)1800{1801 int rc = 0;1802 cifs_proc_init();1803 INIT_LIST_HEAD(&cifs_tcp_ses_list);1804/*1805 * Initialize Global counters1806 */1807 atomic_set(&sesInfoAllocCount, 0);1808 atomic_set(&tconInfoAllocCount, 0);1809 atomic_set(&tcpSesNextId, 0);1810 atomic_set(&tcpSesAllocCount, 0);1811 atomic_set(&tcpSesReconnectCount, 0);1812 atomic_set(&tconInfoReconnectCount, 0);1813 1814 atomic_set(&buf_alloc_count, 0);1815 atomic_set(&small_buf_alloc_count, 0);1816#ifdef CONFIG_CIFS_STATS21817 atomic_set(&total_buf_alloc_count, 0);1818 atomic_set(&total_small_buf_alloc_count, 0);1819 if (slow_rsp_threshold < 1)1820 cifs_dbg(FYI, "slow_response_threshold msgs disabled\n");1821 else if (slow_rsp_threshold > 32767)1822 cifs_dbg(VFS,1823 "slow response threshold set higher than recommended (0 to 32767)\n");1824#endif /* CONFIG_CIFS_STATS2 */1825 1826 atomic_set(&mid_count, 0);1827 GlobalCurrentXid = 0;1828 GlobalTotalActiveXid = 0;1829 GlobalMaxActiveXid = 0;1830 spin_lock_init(&cifs_tcp_ses_lock);1831 spin_lock_init(&GlobalMid_Lock);1832 1833 cifs_lock_secret = get_random_u32();1834 1835 if (cifs_max_pending < 2) {1836 cifs_max_pending = 2;1837 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");1838 } else if (cifs_max_pending > CIFS_MAX_REQ) {1839 cifs_max_pending = CIFS_MAX_REQ;1840 cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",1841 CIFS_MAX_REQ);1842 }1843 1844 /* Limit max to about 18 hours, and setting to zero disables directory entry caching */1845 if (dir_cache_timeout > 65000) {1846 dir_cache_timeout = 65000;1847 cifs_dbg(VFS, "dir_cache_timeout set to max of 65000 seconds\n");1848 }1849 1850 cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1851 if (!cifsiod_wq) {1852 rc = -ENOMEM;1853 goto out_clean_proc;1854 }1855 1856 /*1857 * Consider in future setting limit!=0 maybe to min(num_of_cores - 1, 3)1858 * so that we don't launch too many worker threads but1859 * Documentation/core-api/workqueue.rst recommends setting it to 01860 */1861 1862 /* WQ_UNBOUND allows decrypt tasks to run on any CPU */1863 decrypt_wq = alloc_workqueue("smb3decryptd",1864 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1865 if (!decrypt_wq) {1866 rc = -ENOMEM;1867 goto out_destroy_cifsiod_wq;1868 }1869 1870 fileinfo_put_wq = alloc_workqueue("cifsfileinfoput",1871 WQ_UNBOUND|WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1872 if (!fileinfo_put_wq) {1873 rc = -ENOMEM;1874 goto out_destroy_decrypt_wq;1875 }1876 1877 cifsoplockd_wq = alloc_workqueue("cifsoplockd",1878 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1879 if (!cifsoplockd_wq) {1880 rc = -ENOMEM;1881 goto out_destroy_fileinfo_put_wq;1882 }1883 1884 deferredclose_wq = alloc_workqueue("deferredclose",1885 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1886 if (!deferredclose_wq) {1887 rc = -ENOMEM;1888 goto out_destroy_cifsoplockd_wq;1889 }1890 1891 serverclose_wq = alloc_workqueue("serverclose",1892 WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);1893 if (!serverclose_wq) {1894 rc = -ENOMEM;1895 goto out_destroy_deferredclose_wq;1896 }1897 1898 rc = cifs_init_inodecache();1899 if (rc)1900 goto out_destroy_serverclose_wq;1901 1902 rc = cifs_init_netfs();1903 if (rc)1904 goto out_destroy_inodecache;1905 1906 rc = init_mids();1907 if (rc)1908 goto out_destroy_netfs;1909 1910 rc = cifs_init_request_bufs();1911 if (rc)1912 goto out_destroy_mids;1913 1914#ifdef CONFIG_CIFS_DFS_UPCALL1915 rc = dfs_cache_init();1916 if (rc)1917 goto out_destroy_request_bufs;1918#endif /* CONFIG_CIFS_DFS_UPCALL */1919#ifdef CONFIG_CIFS_UPCALL1920 rc = init_cifs_spnego();1921 if (rc)1922 goto out_destroy_dfs_cache;1923#endif /* CONFIG_CIFS_UPCALL */1924#ifdef CONFIG_CIFS_SWN_UPCALL1925 rc = cifs_genl_init();1926 if (rc)1927 goto out_register_key_type;1928#endif /* CONFIG_CIFS_SWN_UPCALL */1929 1930 rc = init_cifs_idmap();1931 if (rc)1932 goto out_cifs_swn_init;1933 1934 rc = register_filesystem(&cifs_fs_type);1935 if (rc)1936 goto out_init_cifs_idmap;1937 1938 rc = register_filesystem(&smb3_fs_type);1939 if (rc) {1940 unregister_filesystem(&cifs_fs_type);1941 goto out_init_cifs_idmap;1942 }1943 1944 return 0;1945 1946out_init_cifs_idmap:1947 exit_cifs_idmap();1948out_cifs_swn_init:1949#ifdef CONFIG_CIFS_SWN_UPCALL1950 cifs_genl_exit();1951out_register_key_type:1952#endif1953#ifdef CONFIG_CIFS_UPCALL1954 exit_cifs_spnego();1955out_destroy_dfs_cache:1956#endif1957#ifdef CONFIG_CIFS_DFS_UPCALL1958 dfs_cache_destroy();1959out_destroy_request_bufs:1960#endif1961 cifs_destroy_request_bufs();1962out_destroy_mids:1963 destroy_mids();1964out_destroy_netfs:1965 cifs_destroy_netfs();1966out_destroy_inodecache:1967 cifs_destroy_inodecache();1968out_destroy_serverclose_wq:1969 destroy_workqueue(serverclose_wq);1970out_destroy_deferredclose_wq:1971 destroy_workqueue(deferredclose_wq);1972out_destroy_cifsoplockd_wq:1973 destroy_workqueue(cifsoplockd_wq);1974out_destroy_fileinfo_put_wq:1975 destroy_workqueue(fileinfo_put_wq);1976out_destroy_decrypt_wq:1977 destroy_workqueue(decrypt_wq);1978out_destroy_cifsiod_wq:1979 destroy_workqueue(cifsiod_wq);1980out_clean_proc:1981 cifs_proc_clean();1982 return rc;1983}1984 1985static void __exit1986exit_cifs(void)1987{1988 cifs_dbg(NOISY, "exit_smb3\n");1989 unregister_filesystem(&cifs_fs_type);1990 unregister_filesystem(&smb3_fs_type);1991 cifs_release_automount_timer();1992 exit_cifs_idmap();1993#ifdef CONFIG_CIFS_SWN_UPCALL1994 cifs_genl_exit();1995#endif1996#ifdef CONFIG_CIFS_UPCALL1997 exit_cifs_spnego();1998#endif1999#ifdef CONFIG_CIFS_DFS_UPCALL2000 dfs_cache_destroy();2001#endif2002 cifs_destroy_request_bufs();2003 destroy_mids();2004 cifs_destroy_netfs();2005 cifs_destroy_inodecache();2006 destroy_workqueue(deferredclose_wq);2007 destroy_workqueue(cifsoplockd_wq);2008 destroy_workqueue(decrypt_wq);2009 destroy_workqueue(fileinfo_put_wq);2010 destroy_workqueue(serverclose_wq);2011 destroy_workqueue(cifsiod_wq);2012 cifs_proc_clean();2013}2014 2015MODULE_AUTHOR("Steve French");2016MODULE_LICENSE("GPL"); /* combination of LGPL + GPL source behaves as GPL */2017MODULE_DESCRIPTION2018 ("VFS to access SMB3 servers e.g. Samba, Macs, Azure and Windows (and "2019 "also older servers complying with the SNIA CIFS Specification)");2020MODULE_VERSION(CIFS_VERSION);2021MODULE_SOFTDEP("ecb");2022MODULE_SOFTDEP("hmac");2023MODULE_SOFTDEP("md5");2024MODULE_SOFTDEP("nls");2025MODULE_SOFTDEP("aes");2026MODULE_SOFTDEP("cmac");2027MODULE_SOFTDEP("sha256");2028MODULE_SOFTDEP("sha512");2029MODULE_SOFTDEP("aead2");2030MODULE_SOFTDEP("ccm");2031MODULE_SOFTDEP("gcm");2032module_init(init_cifs)2033module_exit(exit_cifs)2034