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