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