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 * Jeremy Allison (jra@samba.org) 7 * 8 */ 9#ifndef _CIFS_GLOB_H 10#define _CIFS_GLOB_H 11 12#include <linux/in.h> 13#include <linux/in6.h> 14#include <linux/inet.h> 15#include <linux/slab.h> 16#include <linux/scatterlist.h> 17#include <linux/mm.h> 18#include <linux/mempool.h> 19#include <linux/workqueue.h> 20#include <linux/utsname.h> 21#include <linux/sched/mm.h> 22#include <linux/netfs.h> 23#include "cifs_fs_sb.h" 24#include "cifsacl.h" 25#include <crypto/internal/hash.h> 26#include <uapi/linux/cifs/cifs_mount.h> 27#include "../common/smb2pdu.h" 28#include "smb2pdu.h" 29#include <linux/filelock.h> 30 31#define SMB_PATH_MAX 260 32#define CIFS_PORT 445 33#define RFC1001_PORT 139 34 35/* 36 * The sizes of various internal tables and strings 37 */ 38#define MAX_UID_INFO 16 39#define MAX_SES_INFO 2 40#define MAX_TCON_INFO 4 41 42#define MAX_TREE_SIZE (2 + CIFS_NI_MAXHOST + 1 + CIFS_MAX_SHARE_LEN + 1) 43 44#define CIFS_MIN_RCV_POOL 4 45 46#define MAX_REOPEN_ATT 5 /* these many maximum attempts to reopen a file */ 47/* 48 * default attribute cache timeout (jiffies) 49 */ 50#define CIFS_DEF_ACTIMEO (1 * HZ) 51 52/* 53 * max sleep time before retry to server 54 */ 55#define CIFS_MAX_SLEEP 2000 56 57/* 58 * max attribute cache timeout (jiffies) - 2^30 59 */ 60#define CIFS_MAX_ACTIMEO (1 << 30) 61 62/* 63 * Max persistent and resilient handle timeout (milliseconds). 64 * Windows durable max was 960000 (16 minutes) 65 */ 66#define SMB3_MAX_HANDLE_TIMEOUT 960000 67 68/* 69 * MAX_REQ is the maximum number of requests that WE will send 70 * on one socket concurrently. 71 */ 72#define CIFS_MAX_REQ 32767 73 74#define RFC1001_NAME_LEN 15 75#define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1) 76 77/* maximum length of ip addr as a string (including ipv6 and sctp) */ 78#define SERVER_NAME_LENGTH 80 79#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1) 80 81/* echo interval in seconds */ 82#define SMB_ECHO_INTERVAL_MIN 1 83#define SMB_ECHO_INTERVAL_MAX 600 84#define SMB_ECHO_INTERVAL_DEFAULT 60 85 86/* smb multichannel query server interfaces interval in seconds */ 87#define SMB_INTERFACE_POLL_INTERVAL 600 88 89/* maximum number of PDUs in one compound */ 90#define MAX_COMPOUND 7 91 92/* 93 * Default number of credits to keep available for SMB3. 94 * This value is chosen somewhat arbitrarily. The Windows client 95 * defaults to 128 credits, the Windows server allows clients up to 96 * 512 credits (or 8K for later versions), and the NetApp server 97 * does not limit clients at all. Choose a high enough default value 98 * such that the client shouldn't limit performance, but allow mount 99 * to override (until you approach 64K, where we limit credits to 65000 100 * to reduce possibility of seeing more server credit overflow bugs. 101 */ 102#define SMB2_MAX_CREDITS_AVAILABLE 32000 103 104#include "cifspdu.h" 105 106#ifndef XATTR_DOS_ATTRIB 107#define XATTR_DOS_ATTRIB "user.DOSATTRIB" 108#endif 109 110#define CIFS_MAX_WORKSTATION_LEN (__NEW_UTS_LEN + 1) /* reasonable max for client */ 111 112#define CIFS_DFS_ROOT_SES(ses) ((ses)->dfs_root_ses ?: (ses)) 113 114/* 115 * CIFS vfs client Status information (based on what we know.) 116 */ 117 118/* associated with each connection */ 119enum statusEnum { 120 CifsNew = 0, 121 CifsGood, 122 CifsExiting, 123 CifsNeedReconnect, 124 CifsNeedNegotiate, 125 CifsInNegotiate, 126}; 127 128/* associated with each smb session */ 129enum ses_status_enum { 130 SES_NEW = 0, 131 SES_GOOD, 132 SES_EXITING, 133 SES_NEED_RECON, 134 SES_IN_SETUP 135}; 136 137/* associated with each tree connection to the server */ 138enum tid_status_enum { 139 TID_NEW = 0, 140 TID_GOOD, 141 TID_EXITING, 142 TID_NEED_RECON, 143 TID_NEED_TCON, 144 TID_IN_TCON, 145 TID_NEED_FILES_INVALIDATE, /* currently unused */ 146 TID_IN_FILES_INVALIDATE 147}; 148 149enum securityEnum { 150 Unspecified = 0, /* not specified */ 151 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */ 152 RawNTLMSSP, /* NTLMSSP without SPNEGO, NTLMv2 hash */ 153 Kerberos, /* Kerberos via SPNEGO */ 154}; 155 156enum cifs_reparse_type { 157 CIFS_REPARSE_TYPE_NFS, 158 CIFS_REPARSE_TYPE_WSL, 159 CIFS_REPARSE_TYPE_DEFAULT = CIFS_REPARSE_TYPE_NFS, 160}; 161 162static inline const char *cifs_reparse_type_str(enum cifs_reparse_type type) 163{ 164 switch (type) { 165 case CIFS_REPARSE_TYPE_NFS: 166 return "nfs"; 167 case CIFS_REPARSE_TYPE_WSL: 168 return "wsl"; 169 default: 170 return "unknown"; 171 } 172} 173 174struct session_key { 175 unsigned int len; 176 char *response; 177}; 178 179/* crypto hashing related structure/fields, not specific to a sec mech */ 180struct cifs_secmech { 181 struct shash_desc *hmacmd5; /* hmacmd5 hash function, for NTLMv2/CR1 hashes */ 182 struct shash_desc *md5; /* md5 hash function, for CIFS/SMB1 signatures */ 183 struct shash_desc *hmacsha256; /* hmac-sha256 hash function, for SMB2 signatures */ 184 struct shash_desc *sha512; /* sha512 hash function, for SMB3.1.1 preauth hash */ 185 struct shash_desc *aes_cmac; /* block-cipher based MAC function, for SMB3 signatures */ 186 187 struct crypto_aead *enc; /* smb3 encryption AEAD TFM (AES-CCM and AES-GCM) */ 188 struct crypto_aead *dec; /* smb3 decryption AEAD TFM (AES-CCM and AES-GCM) */ 189}; 190 191/* per smb session structure/fields */ 192struct ntlmssp_auth { 193 bool sesskey_per_smbsess; /* whether session key is per smb session */ 194 __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */ 195 __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */ 196 unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */ 197 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */ 198}; 199 200struct cifs_cred { 201 int uid; 202 int gid; 203 int mode; 204 int cecount; 205 struct cifs_sid osid; 206 struct cifs_sid gsid; 207 struct cifs_ntace *ntaces; 208 struct cifs_ace *aces; 209}; 210 211struct cifs_open_info_data { 212 bool adjust_tz; 213 union { 214 bool reparse_point; 215 bool symlink; 216 }; 217 struct { 218 /* ioctl response buffer */ 219 struct { 220 int buftype; 221 struct kvec iov; 222 } io; 223 __u32 tag; 224 union { 225 struct reparse_data_buffer *buf; 226 struct reparse_posix_data *posix; 227 }; 228 } reparse; 229 struct { 230 __u8 eas[SMB2_WSL_MAX_QUERY_EA_RESP_SIZE]; 231 unsigned int eas_len; 232 } wsl; 233 char *symlink_target; 234 struct cifs_sid posix_owner; 235 struct cifs_sid posix_group; 236 union { 237 struct smb2_file_all_info fi; 238 struct smb311_posix_qinfo posix_fi; 239 }; 240}; 241 242/* 243 ***************************************************************** 244 * Except the CIFS PDUs themselves all the 245 * globally interesting structs should go here 246 ***************************************************************** 247 */ 248 249/* 250 * A smb_rqst represents a complete request to be issued to a server. It's 251 * formed by a kvec array, followed by an array of pages. Page data is assumed 252 * to start at the beginning of the first page. 253 */ 254struct smb_rqst { 255 struct kvec *rq_iov; /* array of kvecs */ 256 unsigned int rq_nvec; /* number of kvecs in array */ 257 size_t rq_iter_size; /* Amount of data in ->rq_iter */ 258 struct iov_iter rq_iter; /* Data iterator */ 259 struct xarray rq_buffer; /* Page buffer for encryption */ 260}; 261 262struct mid_q_entry; 263struct TCP_Server_Info; 264struct cifsFileInfo; 265struct cifs_ses; 266struct cifs_tcon; 267struct dfs_info3_param; 268struct cifs_fattr; 269struct smb3_fs_context; 270struct cifs_fid; 271struct cifs_readdata; 272struct cifs_writedata; 273struct cifs_io_parms; 274struct cifs_search_info; 275struct cifsInodeInfo; 276struct cifs_open_parms; 277struct cifs_credits; 278 279struct smb_version_operations { 280 int (*send_cancel)(struct TCP_Server_Info *, struct smb_rqst *, 281 struct mid_q_entry *); 282 bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *); 283 /* setup request: allocate mid, sign message */ 284 struct mid_q_entry *(*setup_request)(struct cifs_ses *, 285 struct TCP_Server_Info *, 286 struct smb_rqst *); 287 /* setup async request: allocate mid, sign message */ 288 struct mid_q_entry *(*setup_async_request)(struct TCP_Server_Info *, 289 struct smb_rqst *); 290 /* check response: verify signature, map error */ 291 int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *, 292 bool); 293 void (*add_credits)(struct TCP_Server_Info *server, 294 const struct cifs_credits *credits, 295 const int optype); 296 void (*set_credits)(struct TCP_Server_Info *, const int); 297 int * (*get_credits_field)(struct TCP_Server_Info *, const int); 298 unsigned int (*get_credits)(struct mid_q_entry *); 299 __u64 (*get_next_mid)(struct TCP_Server_Info *); 300 void (*revert_current_mid)(struct TCP_Server_Info *server, 301 const unsigned int val); 302 /* data offset from read response message */ 303 unsigned int (*read_data_offset)(char *); 304 /* 305 * Data length from read response message 306 * When in_remaining is true, the returned data length is in 307 * message field DataRemaining for out-of-band data read (e.g through 308 * Memory Registration RDMA write in SMBD). 309 * Otherwise, the returned data length is in message field DataLength. 310 */ 311 unsigned int (*read_data_length)(char *, bool in_remaining); 312 /* map smb to linux error */ 313 int (*map_error)(char *, bool); 314 /* find mid corresponding to the response message */ 315 struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *); 316 void (*dump_detail)(void *buf, struct TCP_Server_Info *ptcp_info); 317 void (*clear_stats)(struct cifs_tcon *); 318 void (*print_stats)(struct seq_file *m, struct cifs_tcon *); 319 void (*dump_share_caps)(struct seq_file *, struct cifs_tcon *); 320 /* verify the message */ 321 int (*check_message)(char *, unsigned int, struct TCP_Server_Info *); 322 bool (*is_oplock_break)(char *, struct TCP_Server_Info *); 323 int (*handle_cancelled_mid)(struct mid_q_entry *, struct TCP_Server_Info *); 324 void (*downgrade_oplock)(struct TCP_Server_Info *server, 325 struct cifsInodeInfo *cinode, __u32 oplock, 326 unsigned int epoch, bool *purge_cache); 327 /* process transaction2 response */ 328 bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *, 329 char *, int); 330 /* check if we need to negotiate */ 331 bool (*need_neg)(struct TCP_Server_Info *); 332 /* negotiate to the server */ 333 int (*negotiate)(const unsigned int xid, 334 struct cifs_ses *ses, 335 struct TCP_Server_Info *server); 336 /* set negotiated write size */ 337 unsigned int (*negotiate_wsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx); 338 /* set negotiated read size */ 339 unsigned int (*negotiate_rsize)(struct cifs_tcon *tcon, struct smb3_fs_context *ctx); 340 /* setup smb sessionn */ 341 int (*sess_setup)(const unsigned int, struct cifs_ses *, 342 struct TCP_Server_Info *server, 343 const struct nls_table *); 344 /* close smb session */ 345 int (*logoff)(const unsigned int, struct cifs_ses *); 346 /* connect to a server share */ 347 int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *, 348 struct cifs_tcon *, const struct nls_table *); 349 /* close tree connecion */ 350 int (*tree_disconnect)(const unsigned int, struct cifs_tcon *); 351 /* get DFS referrals */ 352 int (*get_dfs_refer)(const unsigned int, struct cifs_ses *, 353 const char *, struct dfs_info3_param **, 354 unsigned int *, const struct nls_table *, int); 355 /* informational QFS call */ 356 void (*qfs_tcon)(const unsigned int, struct cifs_tcon *, 357 struct cifs_sb_info *); 358 /* query for server interfaces */ 359 int (*query_server_interfaces)(const unsigned int, struct cifs_tcon *, 360 bool); 361 /* check if a path is accessible or not */ 362 int (*is_path_accessible)(const unsigned int, struct cifs_tcon *, 363 struct cifs_sb_info *, const char *); 364 /* query path data from the server */ 365 int (*query_path_info)(const unsigned int xid, 366 struct cifs_tcon *tcon, 367 struct cifs_sb_info *cifs_sb, 368 const char *full_path, 369 struct cifs_open_info_data *data); 370 /* query file data from the server */ 371 int (*query_file_info)(const unsigned int xid, struct cifs_tcon *tcon, 372 struct cifsFileInfo *cfile, struct cifs_open_info_data *data); 373 /* query reparse point to determine which type of special file */ 374 int (*query_reparse_point)(const unsigned int xid, 375 struct cifs_tcon *tcon, 376 struct cifs_sb_info *cifs_sb, 377 const char *full_path, 378 u32 *tag, struct kvec *rsp, 379 int *rsp_buftype); 380 /* get server index number */ 381 int (*get_srv_inum)(const unsigned int xid, struct cifs_tcon *tcon, 382 struct cifs_sb_info *cifs_sb, const char *full_path, u64 *uniqueid, 383 struct cifs_open_info_data *data); 384 /* set size by path */ 385 int (*set_path_size)(const unsigned int, struct cifs_tcon *, 386 const char *, __u64, struct cifs_sb_info *, bool, 387 struct dentry *); 388 /* set size by file handle */ 389 int (*set_file_size)(const unsigned int, struct cifs_tcon *, 390 struct cifsFileInfo *, __u64, bool); 391 /* set attributes */ 392 int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *, 393 const unsigned int); 394 int (*set_compression)(const unsigned int, struct cifs_tcon *, 395 struct cifsFileInfo *); 396 /* check if we can send an echo or nor */ 397 bool (*can_echo)(struct TCP_Server_Info *); 398 /* send echo request */ 399 int (*echo)(struct TCP_Server_Info *); 400 /* create directory */ 401 int (*posix_mkdir)(const unsigned int xid, struct inode *inode, 402 umode_t mode, struct cifs_tcon *tcon, 403 const char *full_path, 404 struct cifs_sb_info *cifs_sb); 405 int (*mkdir)(const unsigned int xid, struct inode *inode, umode_t mode, 406 struct cifs_tcon *tcon, const char *name, 407 struct cifs_sb_info *sb); 408 /* set info on created directory */ 409 void (*mkdir_setinfo)(struct inode *, const char *, 410 struct cifs_sb_info *, struct cifs_tcon *, 411 const unsigned int); 412 /* remove directory */ 413 int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *, 414 struct cifs_sb_info *); 415 /* unlink file */ 416 int (*unlink)(const unsigned int, struct cifs_tcon *, const char *, 417 struct cifs_sb_info *, struct dentry *); 418 /* open, rename and delete file */ 419 int (*rename_pending_delete)(const char *, struct dentry *, 420 const unsigned int); 421 /* send rename request */ 422 int (*rename)(const unsigned int xid, 423 struct cifs_tcon *tcon, 424 struct dentry *source_dentry, 425 const char *from_name, const char *to_name, 426 struct cifs_sb_info *cifs_sb); 427 /* send create hardlink request */ 428 int (*create_hardlink)(const unsigned int xid, 429 struct cifs_tcon *tcon, 430 struct dentry *source_dentry, 431 const char *from_name, const char *to_name, 432 struct cifs_sb_info *cifs_sb); 433 /* query symlink target */ 434 int (*query_symlink)(const unsigned int xid, 435 struct cifs_tcon *tcon, 436 struct cifs_sb_info *cifs_sb, 437 const char *full_path, 438 char **target_path); 439 /* open a file for non-posix mounts */ 440 int (*open)(const unsigned int xid, struct cifs_open_parms *oparms, __u32 *oplock, 441 void *buf); 442 /* set fid protocol-specific info */ 443 void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32); 444 /* close a file */ 445 int (*close)(const unsigned int, struct cifs_tcon *, 446 struct cifs_fid *); 447 /* close a file, returning file attributes and timestamps */ 448 int (*close_getattr)(const unsigned int xid, struct cifs_tcon *tcon, 449 struct cifsFileInfo *pfile_info); 450 /* send a flush request to the server */ 451 int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *); 452 /* async read from the server */ 453 int (*async_readv)(struct cifs_readdata *); 454 /* async write to the server */ 455 int (*async_writev)(struct cifs_writedata *, 456 void (*release)(struct kref *)); 457 /* sync read from the server */ 458 int (*sync_read)(const unsigned int, struct cifs_fid *, 459 struct cifs_io_parms *, unsigned int *, char **, 460 int *); 461 /* sync write to the server */ 462 int (*sync_write)(const unsigned int, struct cifs_fid *, 463 struct cifs_io_parms *, unsigned int *, struct kvec *, 464 unsigned long); 465 /* open dir, start readdir */ 466 int (*query_dir_first)(const unsigned int, struct cifs_tcon *, 467 const char *, struct cifs_sb_info *, 468 struct cifs_fid *, __u16, 469 struct cifs_search_info *); 470 /* continue readdir */ 471 int (*query_dir_next)(const unsigned int, struct cifs_tcon *, 472 struct cifs_fid *, 473 __u16, struct cifs_search_info *srch_inf); 474 /* close dir */ 475 int (*close_dir)(const unsigned int, struct cifs_tcon *, 476 struct cifs_fid *); 477 /* calculate a size of SMB message */ 478 unsigned int (*calc_smb_size)(void *buf); 479 /* check for STATUS_PENDING and process the response if yes */ 480 bool (*is_status_pending)(char *buf, struct TCP_Server_Info *server); 481 /* check for STATUS_NETWORK_SESSION_EXPIRED */ 482 bool (*is_session_expired)(char *); 483 /* send oplock break response */ 484 int (*oplock_response)(struct cifs_tcon *tcon, __u64 persistent_fid, __u64 volatile_fid, 485 __u16 net_fid, struct cifsInodeInfo *cifs_inode); 486 /* query remote filesystem */ 487 int (*queryfs)(const unsigned int, struct cifs_tcon *, 488 struct cifs_sb_info *, struct kstatfs *); 489 /* send mandatory brlock to the server */ 490 int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64, 491 __u64, __u32, int, int, bool); 492 /* unlock range of mandatory locks */ 493 int (*mand_unlock_range)(struct cifsFileInfo *, struct file_lock *, 494 const unsigned int); 495 /* push brlocks from the cache to the server */ 496 int (*push_mand_locks)(struct cifsFileInfo *); 497 /* get lease key of the inode */ 498 void (*get_lease_key)(struct inode *, struct cifs_fid *); 499 /* set lease key of the inode */ 500 void (*set_lease_key)(struct inode *, struct cifs_fid *); 501 /* generate new lease key */ 502 void (*new_lease_key)(struct cifs_fid *); 503 int (*generate_signingkey)(struct cifs_ses *ses, 504 struct TCP_Server_Info *server); 505 int (*calc_signature)(struct smb_rqst *, struct TCP_Server_Info *, 506 bool allocate_crypto); 507 int (*set_integrity)(const unsigned int, struct cifs_tcon *tcon, 508 struct cifsFileInfo *src_file); 509 int (*enum_snapshots)(const unsigned int xid, struct cifs_tcon *tcon, 510 struct cifsFileInfo *src_file, void __user *); 511 int (*notify)(const unsigned int xid, struct file *pfile, 512 void __user *pbuf, bool return_changes); 513 int (*query_mf_symlink)(unsigned int, struct cifs_tcon *, 514 struct cifs_sb_info *, const unsigned char *, 515 char *, unsigned int *); 516 int (*create_mf_symlink)(unsigned int, struct cifs_tcon *, 517 struct cifs_sb_info *, const unsigned char *, 518 char *, unsigned int *); 519 /* if we can do cache read operations */ 520 bool (*is_read_op)(__u32); 521 /* set oplock level for the inode */ 522 void (*set_oplock_level)(struct cifsInodeInfo *, __u32, unsigned int, 523 bool *); 524 /* create lease context buffer for CREATE request */ 525 char * (*create_lease_buf)(u8 *lease_key, u8 oplock); 526 /* parse lease context buffer and return oplock/epoch info */ 527 __u8 (*parse_lease_buf)(void *buf, unsigned int *epoch, char *lkey); 528 ssize_t (*copychunk_range)(const unsigned int, 529 struct cifsFileInfo *src_file, 530 struct cifsFileInfo *target_file, 531 u64 src_off, u64 len, u64 dest_off); 532 int (*duplicate_extents)(const unsigned int, struct cifsFileInfo *src, 533 struct cifsFileInfo *target_file, u64 src_off, u64 len, 534 u64 dest_off); 535 int (*validate_negotiate)(const unsigned int, struct cifs_tcon *); 536 ssize_t (*query_all_EAs)(const unsigned int, struct cifs_tcon *, 537 const unsigned char *, const unsigned char *, char *, 538 size_t, struct cifs_sb_info *); 539 int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *, 540 const char *, const void *, const __u16, 541 const struct nls_table *, struct cifs_sb_info *); 542 struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *, 543 const char *, u32 *, u32); 544 struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *, 545 const struct cifs_fid *, u32 *, u32); 546 int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *, 547 int); 548 /* writepages retry size */ 549 unsigned int (*wp_retry_size)(struct inode *); 550 /* get mtu credits */ 551 int (*wait_mtu_credits)(struct TCP_Server_Info *, unsigned int, 552 unsigned int *, struct cifs_credits *); 553 /* adjust previously taken mtu credits to request size */ 554 int (*adjust_credits)(struct TCP_Server_Info *server, 555 struct cifs_credits *credits, 556 const unsigned int payload_size); 557 /* check if we need to issue closedir */ 558 bool (*dir_needs_close)(struct cifsFileInfo *); 559 long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t, 560 loff_t); 561 /* init transform request - used for encryption for now */ 562 int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst, 563 struct smb_rqst *, struct smb_rqst *); 564 int (*is_transform_hdr)(void *buf); 565 int (*receive_transform)(struct TCP_Server_Info *, 566 struct mid_q_entry **, char **, int *); 567 enum securityEnum (*select_sectype)(struct TCP_Server_Info *, 568 enum securityEnum); 569 int (*next_header)(struct TCP_Server_Info *server, char *buf, 570 unsigned int *noff); 571 /* ioctl passthrough for query_info */ 572 int (*ioctl_query_info)(const unsigned int xid, 573 struct cifs_tcon *tcon, 574 struct cifs_sb_info *cifs_sb, 575 __le16 *path, int is_dir, 576 unsigned long p); 577 /* make unix special files (block, char, fifo, socket) */ 578 int (*make_node)(unsigned int xid, 579 struct inode *inode, 580 struct dentry *dentry, 581 struct cifs_tcon *tcon, 582 const char *full_path, 583 umode_t mode, 584 dev_t device_number); 585 /* version specific fiemap implementation */ 586 int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *, 587 struct fiemap_extent_info *, u64, u64); 588 /* version specific llseek implementation */ 589 loff_t (*llseek)(struct file *, struct cifs_tcon *, loff_t, int); 590 /* Check for STATUS_IO_TIMEOUT */ 591 bool (*is_status_io_timeout)(char *buf); 592 /* Check for STATUS_NETWORK_NAME_DELETED */ 593 bool (*is_network_name_deleted)(char *buf, struct TCP_Server_Info *srv); 594 int (*parse_reparse_point)(struct cifs_sb_info *cifs_sb, 595 struct kvec *rsp_iov, 596 struct cifs_open_info_data *data); 597 int (*create_reparse_symlink)(const unsigned int xid, 598 struct inode *inode, 599 struct dentry *dentry, 600 struct cifs_tcon *tcon, 601 const char *full_path, 602 const char *symname); 603}; 604 605struct smb_version_values { 606 char *version_string; 607 __u16 protocol_id; 608 __u32 req_capabilities; 609 __u32 large_lock_type; 610 __u32 exclusive_lock_type; 611 __u32 shared_lock_type; 612 __u32 unlock_lock_type; 613 size_t header_preamble_size; 614 size_t header_size; 615 size_t max_header_size; 616 size_t read_rsp_size; 617 __le16 lock_cmd; 618 unsigned int cap_unix; 619 unsigned int cap_nt_find; 620 unsigned int cap_large_files; 621 __u16 signing_enabled; 622 __u16 signing_required; 623 size_t create_lease_size; 624}; 625 626#define HEADER_SIZE(server) (server->vals->header_size) 627#define MAX_HEADER_SIZE(server) (server->vals->max_header_size) 628#define HEADER_PREAMBLE_SIZE(server) (server->vals->header_preamble_size) 629#define MID_HEADER_SIZE(server) (HEADER_SIZE(server) - 1 - HEADER_PREAMBLE_SIZE(server)) 630 631/** 632 * CIFS superblock mount flags (mnt_cifs_flags) to consider when 633 * trying to reuse existing superblock for a new mount 634 */ 635#define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \ 636 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \ 637 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \ 638 CIFS_MOUNT_MAP_SFM_CHR | \ 639 CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \ 640 CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \ 641 CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \ 642 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \ 643 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \ 644 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \ 645 CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \ 646 CIFS_MOUNT_UID_FROM_ACL | CIFS_MOUNT_NO_HANDLE_CACHE | \ 647 CIFS_MOUNT_NO_DFS | CIFS_MOUNT_MODE_FROM_SID | \ 648 CIFS_MOUNT_RO_CACHE | CIFS_MOUNT_RW_CACHE) 649 650/** 651 * Generic VFS superblock mount flags (s_flags) to consider when 652 * trying to reuse existing superblock for a new mount 653 */ 654#define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \ 655 SB_NODEV | SB_SYNCHRONOUS) 656 657struct cifs_mnt_data { 658 struct cifs_sb_info *cifs_sb; 659 struct smb3_fs_context *ctx; 660 int flags; 661}; 662 663static inline unsigned int 664get_rfc1002_length(void *buf) 665{ 666 return be32_to_cpu(*((__be32 *)buf)) & 0xffffff; 667} 668 669static inline void 670inc_rfc1001_len(void *buf, int count) 671{ 672 be32_add_cpu((__be32 *)buf, count); 673} 674 675struct TCP_Server_Info { 676 struct list_head tcp_ses_list; 677 struct list_head smb_ses_list; 678 spinlock_t srv_lock; /* protect anything here that is not protected */ 679 __u64 conn_id; /* connection identifier (useful for debugging) */ 680 int srv_count; /* reference counter */ 681 /* 15 character server name + 0x20 16th byte indicating type = srv */ 682 char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL]; 683 struct smb_version_operations *ops; 684 struct smb_version_values *vals; 685 /* updates to tcpStatus protected by cifs_tcp_ses_lock */ 686 enum statusEnum tcpStatus; /* what we think the status is */ 687 char *hostname; /* hostname portion of UNC string */ 688 struct socket *ssocket; 689 struct sockaddr_storage dstaddr; 690 struct sockaddr_storage srcaddr; /* locally bind to this IP */ 691#ifdef CONFIG_NET_NS 692 struct net *net; 693#endif 694 wait_queue_head_t response_q; 695 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/ 696 spinlock_t mid_lock; /* protect mid queue and it's entries */ 697 struct list_head pending_mid_q; 698 bool noblocksnd; /* use blocking sendmsg */ 699 bool noautotune; /* do not autotune send buf sizes */ 700 bool nosharesock; 701 bool tcp_nodelay; 702 bool terminate; 703 unsigned int credits; /* send no more requests at once */ 704 unsigned int max_credits; /* can override large 32000 default at mnt */ 705 unsigned int in_flight; /* number of requests on the wire to server */ 706 unsigned int max_in_flight; /* max number of requests that were on wire */ 707 spinlock_t req_lock; /* protect the two values above */ 708 struct mutex _srv_mutex; 709 unsigned int nofs_flag; 710 struct task_struct *tsk; 711 char server_GUID[16]; 712 __u16 sec_mode; 713 bool sign; /* is signing enabled on this connection? */ 714 bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */ 715 bool session_estab; /* mark when very first sess is established */ 716 int echo_credits; /* echo reserved slots */ 717 int oplock_credits; /* oplock break reserved slots */ 718 bool echoes:1; /* enable echoes */ 719 __u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */ 720 u16 dialect; /* dialect index that server chose */ 721 bool oplocks:1; /* enable oplocks */ 722 unsigned int maxReq; /* Clients should submit no more */ 723 /* than maxReq distinct unanswered SMBs to the server when using */ 724 /* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */ 725 unsigned int maxBuf; /* maxBuf specifies the maximum */ 726 /* message size the server can send or receive for non-raw SMBs */ 727 /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */ 728 /* when socket is setup (and during reconnect) before NegProt sent */ 729 unsigned int max_rw; /* maxRw specifies the maximum */ 730 /* message size the server can send or receive for */ 731 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */ 732 unsigned int capabilities; /* selective disabling of caps by smb sess */ 733 int timeAdj; /* Adjust for difference in server time zone in sec */ 734 __u64 CurrentMid; /* multiplex id - rotating counter, protected by GlobalMid_Lock */ 735 char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */ 736 /* 16th byte of RFC1001 workstation name is always null */ 737 char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL]; 738 __u32 sequence_number; /* for signing, protected by srv_mutex */ 739 __u32 reconnect_instance; /* incremented on each reconnect */ 740 struct session_key session_key; 741 unsigned long lstrp; /* when we got last response from this server */ 742 struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */ 743#define CIFS_NEGFLAVOR_UNENCAP 1 /* wct == 17, but no ext_sec */ 744#define CIFS_NEGFLAVOR_EXTENDED 2 /* wct == 17, ext_sec bit set */ 745 char negflavor; /* NEGOTIATE response flavor */ 746 /* extended security flavors that server supports */ 747 bool sec_ntlmssp; /* supports NTLMSSP */ 748 bool sec_kerberosu2u; /* supports U2U Kerberos */ 749 bool sec_kerberos; /* supports plain Kerberos */ 750 bool sec_mskerberos; /* supports legacy MS Kerberos */ 751 bool large_buf; /* is current buffer large? */ 752 /* use SMBD connection instead of socket */ 753 bool rdma; 754 /* point to the SMBD connection if RDMA is used instead of socket */ 755 struct smbd_connection *smbd_conn; 756 struct delayed_work echo; /* echo ping workqueue job */ 757 char *smallbuf; /* pointer to current "small" buffer */ 758 char *bigbuf; /* pointer to current "big" buffer */ 759 /* Total size of this PDU. Only valid from cifs_demultiplex_thread */ 760 unsigned int pdu_size; 761 unsigned int total_read; /* total amount of data read in this pass */ 762 atomic_t in_send; /* requests trying to send */ 763 atomic_t num_waiters; /* blocked waiting to get in sendrecv */ 764#ifdef CONFIG_CIFS_STATS2 765 atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */ 766 atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */ 767 __u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */ 768 __u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS]; 769 __u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS]; 770#endif /* STATS2 */ 771 unsigned int max_read; 772 unsigned int max_write; 773 unsigned int min_offload; 774 unsigned int retrans; 775 struct { 776 bool requested; /* "compress" mount option set*/ 777 bool enabled; /* actually negotiated with server */ 778 __le16 alg; /* preferred alg negotiated with server */ 779 } compression; 780 __u16 signing_algorithm; 781 __le16 cipher_type; 782 /* save initital negprot hash */ 783 __u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE]; 784 bool signing_negotiated; /* true if valid signing context rcvd from server */ 785 bool posix_ext_supported; 786 struct delayed_work reconnect; /* reconnect workqueue job */ 787 struct mutex reconnect_mutex; /* prevent simultaneous reconnects */ 788 unsigned long echo_interval; 789 790 /* 791 * Number of targets available for reconnect. The more targets 792 * the more tasks have to wait to let the demultiplex thread 793 * reconnect. 794 */ 795 int nr_targets; 796 bool noblockcnt; /* use non-blocking connect() */ 797 798 /* 799 * If this is a session channel, 800 * primary_server holds the ref-counted 801 * pointer to primary channel connection for the session. 802 */ 803#define SERVER_IS_CHAN(server) (!!(server)->primary_server) 804 struct TCP_Server_Info *primary_server; 805 __u16 channel_sequence_num; /* incremented on primary channel on each chan reconnect */ 806 807#ifdef CONFIG_CIFS_SWN_UPCALL 808 bool use_swn_dstaddr; 809 struct sockaddr_storage swn_dstaddr; 810#endif 811 struct mutex refpath_lock; /* protects leaf_fullpath */ 812 /* 813 * leaf_fullpath: Canonical DFS referral path related to this 814 * connection. 815 * It is used in DFS cache refresher, reconnect and may 816 * change due to nested DFS links. 817 * 818 * Protected by @refpath_lock and @srv_lock. The @refpath_lock is 819 * mostly used for not requiring a copy of @leaf_fullpath when getting 820 * cached or new DFS referrals (which might also sleep during I/O). 821 * While @srv_lock is held for making string and NULL comparions against 822 * both fields as in mount(2) and cache refresh. 823 * 824 * format: \\HOST\SHARE[\OPTIONAL PATH] 825 */ 826 char *leaf_fullpath; 827}; 828 829static inline bool is_smb1(struct TCP_Server_Info *server) 830{ 831 return HEADER_PREAMBLE_SIZE(server) != 0; 832} 833 834static inline void cifs_server_lock(struct TCP_Server_Info *server) 835{ 836 unsigned int nofs_flag = memalloc_nofs_save(); 837 838 mutex_lock(&server->_srv_mutex); 839 server->nofs_flag = nofs_flag; 840} 841 842static inline void cifs_server_unlock(struct TCP_Server_Info *server) 843{ 844 unsigned int nofs_flag = server->nofs_flag; 845 846 mutex_unlock(&server->_srv_mutex); 847 memalloc_nofs_restore(nofs_flag); 848} 849 850struct cifs_credits { 851 unsigned int value; 852 unsigned int instance; 853}; 854 855static inline unsigned int 856in_flight(struct TCP_Server_Info *server) 857{ 858 unsigned int num; 859 860 spin_lock(&server->req_lock); 861 num = server->in_flight; 862 spin_unlock(&server->req_lock); 863 return num; 864} 865 866static inline bool 867has_credits(struct TCP_Server_Info *server, int *credits, int num_credits) 868{ 869 int num; 870 871 spin_lock(&server->req_lock); 872 num = *credits; 873 spin_unlock(&server->req_lock); 874 return num >= num_credits; 875} 876 877static inline void 878add_credits(struct TCP_Server_Info *server, const struct cifs_credits *credits, 879 const int optype) 880{ 881 server->ops->add_credits(server, credits, optype); 882} 883 884static inline void 885add_credits_and_wake_if(struct TCP_Server_Info *server, 886 const struct cifs_credits *credits, const int optype) 887{ 888 if (credits->value) { 889 server->ops->add_credits(server, credits, optype); 890 wake_up(&server->request_q); 891 } 892} 893 894static inline void 895set_credits(struct TCP_Server_Info *server, const int val) 896{ 897 server->ops->set_credits(server, val); 898} 899 900static inline int 901adjust_credits(struct TCP_Server_Info *server, struct cifs_credits *credits, 902 const unsigned int payload_size) 903{ 904 return server->ops->adjust_credits ? 905 server->ops->adjust_credits(server, credits, payload_size) : 0; 906} 907 908static inline __le64 909get_next_mid64(struct TCP_Server_Info *server) 910{ 911 return cpu_to_le64(server->ops->get_next_mid(server)); 912} 913 914static inline __le16 915get_next_mid(struct TCP_Server_Info *server) 916{ 917 __u16 mid = server->ops->get_next_mid(server); 918 /* 919 * The value in the SMB header should be little endian for easy 920 * on-the-wire decoding. 921 */ 922 return cpu_to_le16(mid); 923} 924 925static inline void 926revert_current_mid(struct TCP_Server_Info *server, const unsigned int val) 927{ 928 if (server->ops->revert_current_mid) 929 server->ops->revert_current_mid(server, val); 930} 931 932static inline void 933revert_current_mid_from_hdr(struct TCP_Server_Info *server, 934 const struct smb2_hdr *shdr) 935{ 936 unsigned int num = le16_to_cpu(shdr->CreditCharge); 937 938 return revert_current_mid(server, num > 0 ? num : 1); 939} 940 941static inline __u16 942get_mid(const struct smb_hdr *smb) 943{ 944 return le16_to_cpu(smb->Mid); 945} 946 947static inline bool 948compare_mid(__u16 mid, const struct smb_hdr *smb) 949{ 950 return mid == le16_to_cpu(smb->Mid); 951} 952 953/* 954 * When the server supports very large reads and writes via POSIX extensions, 955 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not 956 * including the RFC1001 length. 957 * 958 * Note that this might make for "interesting" allocation problems during 959 * writeback however as we have to allocate an array of pointers for the 960 * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096. 961 * 962 * For reads, there is a similar problem as we need to allocate an array 963 * of kvecs to handle the receive, though that should only need to be done 964 * once. 965 */ 966#define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4) 967#define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4) 968 969/* 970 * When the server doesn't allow large posix writes, only allow a rsize/wsize 971 * of 2^17-1 minus the size of the call header. That allows for a read or 972 * write up to the maximum size described by RFC1002. 973 */ 974#define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4) 975#define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4) 976 977#define CIFS_DEFAULT_IOSIZE (1024 * 1024) 978 979/* 980 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to 981 * those values when posix extensions aren't in force. In actuality here, we 982 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem 983 * to be ok with the extra byte even though Windows doesn't send writes that 984 * are that large. 985 * 986 * Citation: 987 * 988 * https://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx 989 */ 990#define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024) 991#define CIFS_DEFAULT_NON_POSIX_WSIZE (65536) 992 993/* 994 * Macros to allow the TCP_Server_Info->net field and related code to drop out 995 * when CONFIG_NET_NS isn't set. 996 */ 997 998#ifdef CONFIG_NET_NS 999 1000static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv) 1001{ 1002 return srv->net; 1003} 1004 1005static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net) 1006{ 1007 srv->net = net; 1008} 1009 1010#else 1011 1012static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv) 1013{ 1014 return &init_net; 1015} 1016 1017static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net) 1018{ 1019} 1020 1021#endif 1022 1023struct cifs_server_iface { 1024 struct list_head iface_head; 1025 struct kref refcount; 1026 size_t speed; 1027 size_t weight_fulfilled; 1028 unsigned int num_channels; 1029 unsigned int rdma_capable : 1; 1030 unsigned int rss_capable : 1; 1031 unsigned int is_active : 1; /* unset if non existent */ 1032 struct sockaddr_storage sockaddr; 1033}; 1034 1035/* release iface when last ref is dropped */ 1036static inline void 1037release_iface(struct kref *ref) 1038{ 1039 struct cifs_server_iface *iface = container_of(ref, 1040 struct cifs_server_iface, 1041 refcount); 1042 kfree(iface); 1043} 1044 1045struct cifs_chan { 1046 unsigned int in_reconnect : 1; /* if session setup in progress for this channel */ 1047 struct TCP_Server_Info *server; 1048 struct cifs_server_iface *iface; /* interface in use */ 1049 __u8 signkey[SMB3_SIGN_KEY_SIZE]; 1050}; 1051 1052#define CIFS_SES_FLAG_SCALE_CHANNELS (0x1) 1053 1054/* 1055 * Session structure. One of these for each uid session with a particular host 1056 */ 1057struct cifs_ses { 1058 struct list_head smb_ses_list; 1059 struct list_head rlist; /* reconnect list */ 1060 struct list_head tcon_list; 1061 struct cifs_tcon *tcon_ipc; 1062 spinlock_t ses_lock; /* protect anything here that is not protected */ 1063 struct mutex session_mutex; 1064 struct TCP_Server_Info *server; /* pointer to server info */ 1065 int ses_count; /* reference counter */ 1066 enum ses_status_enum ses_status; /* updates protected by cifs_tcp_ses_lock */ 1067 unsigned int overrideSecFlg; /* if non-zero override global sec flags */ 1068 char *serverOS; /* name of operating system underlying server */ 1069 char *serverNOS; /* name of network operating system of server */ 1070 char *serverDomain; /* security realm of server */ 1071 __u64 Suid; /* remote smb uid */ 1072 kuid_t linux_uid; /* overriding owner of files on the mount */ 1073 kuid_t cred_uid; /* owner of credentials */ 1074 unsigned int capabilities; 1075 char ip_addr[INET6_ADDRSTRLEN + 1]; /* Max ipv6 (or v4) addr string len */ 1076 char *user_name; /* must not be null except during init of sess 1077 and after mount option parsing we fill it */ 1078 char *domainName; 1079 char *password; 1080 char *password2; /* When key rotation used, new password may be set before it expires */ 1081 char workstation_name[CIFS_MAX_WORKSTATION_LEN]; 1082 struct session_key auth_key; 1083 struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */ 1084 enum securityEnum sectype; /* what security flavor was specified? */ 1085 bool sign; /* is signing required? */ 1086 bool domainAuto:1; 1087 bool expired_pwd; /* track if access denied or expired pwd so can know if need to update */ 1088 unsigned int flags; 1089 __u16 session_flags; 1090 __u8 smb3signingkey[SMB3_SIGN_KEY_SIZE]; 1091 __u8 smb3encryptionkey[SMB3_ENC_DEC_KEY_SIZE]; 1092 __u8 smb3decryptionkey[SMB3_ENC_DEC_KEY_SIZE]; 1093 __u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE]; 1094 1095 /* 1096 * Network interfaces available on the server this session is 1097 * connected to. 1098 * 1099 * Other channels can be opened by connecting and binding this 1100 * session to interfaces from this list. 1101 * 1102 * iface_lock should be taken when accessing any of these fields 1103 */ 1104 spinlock_t iface_lock; 1105 /* ========= begin: protected by iface_lock ======== */ 1106 struct list_head iface_list; 1107 size_t iface_count; 1108 unsigned long iface_last_update; /* jiffies */ 1109 /* ========= end: protected by iface_lock ======== */ 1110 1111 spinlock_t chan_lock; 1112 /* ========= begin: protected by chan_lock ======== */ 1113#define CIFS_MAX_CHANNELS 16 1114#define CIFS_INVAL_CHAN_INDEX (-1) 1115#define CIFS_ALL_CHANNELS_SET(ses) \ 1116 ((1UL << (ses)->chan_count) - 1) 1117#define CIFS_ALL_CHANS_GOOD(ses) \ 1118 (!(ses)->chans_need_reconnect) 1119#define CIFS_ALL_CHANS_NEED_RECONNECT(ses) \ 1120 ((ses)->chans_need_reconnect == CIFS_ALL_CHANNELS_SET(ses)) 1121#define CIFS_SET_ALL_CHANS_NEED_RECONNECT(ses) \ 1122 ((ses)->chans_need_reconnect = CIFS_ALL_CHANNELS_SET(ses)) 1123#define CIFS_CHAN_NEEDS_RECONNECT(ses, index) \ 1124 test_bit((index), &(ses)->chans_need_reconnect) 1125#define CIFS_CHAN_IN_RECONNECT(ses, index) \ 1126 ((ses)->chans[(index)].in_reconnect) 1127 1128 struct cifs_chan chans[CIFS_MAX_CHANNELS]; 1129 size_t chan_count; 1130 size_t chan_max; 1131 atomic_t chan_seq; /* round robin state */ 1132 1133 /* 1134 * chans_need_reconnect is a bitmap indicating which of the channels 1135 * under this smb session needs to be reconnected. 1136 * If not multichannel session, only one bit will be used. 1137 * 1138 * We will ask for sess and tcon reconnection only if all the 1139 * channels are marked for needing reconnection. This will 1140 * enable the sessions on top to continue to live till any 1141 * of the channels below are active. 1142 */ 1143 unsigned long chans_need_reconnect; 1144 /* ========= end: protected by chan_lock ======== */ 1145 struct cifs_ses *dfs_root_ses; 1146 struct nls_table *local_nls; 1147}; 1148 1149static inline bool 1150cap_unix(struct cifs_ses *ses) 1151{ 1152 return ses->server->vals->cap_unix & ses->capabilities; 1153} 1154 1155/* 1156 * common struct for holding inode info when searching for or updating an 1157 * inode with new info 1158 */ 1159 1160#define CIFS_FATTR_JUNCTION 0x1 1161#define CIFS_FATTR_DELETE_PENDING 0x2 1162#define CIFS_FATTR_NEED_REVAL 0x4 1163#define CIFS_FATTR_INO_COLLISION 0x8 1164#define CIFS_FATTR_UNKNOWN_NLINK 0x10 1165#define CIFS_FATTR_FAKE_ROOT_INO 0x20 1166 1167struct cifs_fattr { 1168 u32 cf_flags; 1169 u32 cf_cifsattrs; 1170 u64 cf_uniqueid; 1171 u64 cf_eof; 1172 u64 cf_bytes; 1173 u64 cf_createtime; 1174 kuid_t cf_uid; 1175 kgid_t cf_gid; 1176 umode_t cf_mode; 1177 dev_t cf_rdev; 1178 unsigned int cf_nlink; 1179 unsigned int cf_dtype; 1180 struct timespec64 cf_atime; 1181 struct timespec64 cf_mtime; 1182 struct timespec64 cf_ctime; 1183 u32 cf_cifstag; 1184 char *cf_symlink_target; 1185}; 1186 1187/* 1188 * there is one of these for each connection to a resource on a particular 1189 * session 1190 */ 1191struct cifs_tcon { 1192 struct list_head tcon_list; 1193 int debug_id; /* Debugging for tracing */ 1194 int tc_count; 1195 struct list_head rlist; /* reconnect list */ 1196 spinlock_t tc_lock; /* protect anything here that is not protected */ 1197 atomic_t num_local_opens; /* num of all opens including disconnected */ 1198 atomic_t num_remote_opens; /* num of all network opens on server */ 1199 struct list_head openFileList; 1200 spinlock_t open_file_lock; /* protects list above */ 1201 struct cifs_ses *ses; /* pointer to session associated with */ 1202 char tree_name[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */ 1203 char *nativeFileSystem; 1204 char *password; /* for share-level security */ 1205 __u32 tid; /* The 4 byte tree id */ 1206 __u16 Flags; /* optional support bits */ 1207 enum tid_status_enum status; 1208 atomic_t num_smbs_sent; 1209 union { 1210 struct { 1211 atomic_t num_writes; 1212 atomic_t num_reads; 1213 atomic_t num_flushes; 1214 atomic_t num_oplock_brks; 1215 atomic_t num_opens; 1216 atomic_t num_closes; 1217 atomic_t num_deletes; 1218 atomic_t num_mkdirs; 1219 atomic_t num_posixopens; 1220 atomic_t num_posixmkdirs; 1221 atomic_t num_rmdirs; 1222 atomic_t num_renames; 1223 atomic_t num_t2renames; 1224 atomic_t num_ffirst; 1225 atomic_t num_fnext; 1226 atomic_t num_fclose; 1227 atomic_t num_hardlinks; 1228 atomic_t num_symlinks; 1229 atomic_t num_locks; 1230 atomic_t num_acl_get; 1231 atomic_t num_acl_set; 1232 } cifs_stats; 1233 struct { 1234 atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS]; 1235 atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS]; 1236 } smb2_stats; 1237 } stats; 1238 __u64 bytes_read; 1239 __u64 bytes_written; 1240 spinlock_t stat_lock; /* protects the two fields above */ 1241 time64_t stats_from_time; 1242 FILE_SYSTEM_DEVICE_INFO fsDevInfo; 1243 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */ 1244 FILE_SYSTEM_UNIX_INFO fsUnixInfo; 1245 bool ipc:1; /* set if connection to IPC$ share (always also pipe) */ 1246 bool pipe:1; /* set if connection to pipe share */ 1247 bool print:1; /* set if connection to printer share */ 1248 bool retry:1; 1249 bool nocase:1; 1250 bool nohandlecache:1; /* if strange server resource prob can turn off */ 1251 bool nodelete:1; 1252 bool seal:1; /* transport encryption for this mounted share */ 1253 bool unix_ext:1; /* if false disable Linux extensions to CIFS protocol 1254 for this mount even if server would support */ 1255 bool posix_extensions; /* if true SMB3.11 posix extensions enabled */ 1256 bool local_lease:1; /* check leases (only) on local system not remote */ 1257 bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */ 1258 bool broken_sparse_sup; /* if server or share does not support sparse */ 1259 bool need_reconnect:1; /* connection reset, tid now invalid */ 1260 bool need_reopen_files:1; /* need to reopen tcon file handles */ 1261 bool use_resilient:1; /* use resilient instead of durable handles */ 1262 bool use_persistent:1; /* use persistent instead of durable handles */ 1263 bool no_lease:1; /* Do not request leases on files or directories */ 1264 bool use_witness:1; /* use witness protocol */ 1265 __le32 capabilities; 1266 __u32 share_flags; 1267 __u32 maximal_access; 1268 __u32 vol_serial_number; 1269 __le64 vol_create_time; 1270 __u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */ 1271 __u32 handle_timeout; /* persistent and durable handle timeout in ms */ 1272 __u32 ss_flags; /* sector size flags */ 1273 __u32 perf_sector_size; /* best sector size for perf */ 1274 __u32 max_chunks; 1275 __u32 max_bytes_chunk; 1276 __u32 max_bytes_copy; 1277 __u32 max_cached_dirs; 1278#ifdef CONFIG_CIFS_FSCACHE 1279 u64 resource_id; /* server resource id */ 1280 bool fscache_acquired; /* T if we've tried acquiring a cookie */ 1281 struct fscache_volume *fscache; /* cookie for share */ 1282 struct mutex fscache_lock; /* Prevent regetting a cookie */ 1283#endif 1284 struct list_head pending_opens; /* list of incomplete opens */ 1285 struct cached_fids *cfids; 1286 /* BB add field for back pointer to sb struct(s)? */ 1287#ifdef CONFIG_CIFS_DFS_UPCALL 1288 struct delayed_work dfs_cache_work; 1289#endif 1290 struct delayed_work query_interfaces; /* query interfaces workqueue job */ 1291 char *origin_fullpath; /* canonical copy of smb3_fs_context::source */ 1292}; 1293 1294/* 1295 * This is a refcounted and timestamped container for a tcon pointer. The 1296 * container holds a tcon reference. It is considered safe to free one of 1297 * these when the tl_count goes to 0. The tl_time is the time of the last 1298 * "get" on the container. 1299 */ 1300struct tcon_link { 1301 struct rb_node tl_rbnode; 1302 kuid_t tl_uid; 1303 unsigned long tl_flags; 1304#define TCON_LINK_MASTER 0 1305#define TCON_LINK_PENDING 1 1306#define TCON_LINK_IN_TREE 2 1307 unsigned long tl_time; 1308 atomic_t tl_count; 1309 struct cifs_tcon *tl_tcon; 1310}; 1311 1312extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb); 1313extern void smb3_free_compound_rqst(int num_rqst, struct smb_rqst *rqst); 1314 1315static inline struct cifs_tcon * 1316tlink_tcon(struct tcon_link *tlink) 1317{ 1318 return tlink->tl_tcon; 1319} 1320 1321static inline struct tcon_link * 1322cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb) 1323{ 1324 return cifs_sb->master_tlink; 1325} 1326 1327extern void cifs_put_tlink(struct tcon_link *tlink); 1328 1329static inline struct tcon_link * 1330cifs_get_tlink(struct tcon_link *tlink) 1331{ 1332 if (tlink && !IS_ERR(tlink)) 1333 atomic_inc(&tlink->tl_count); 1334 return tlink; 1335} 1336 1337/* This function is always expected to succeed */ 1338extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb); 1339 1340#define CIFS_OPLOCK_NO_CHANGE 0xfe 1341 1342struct cifs_pending_open { 1343 struct list_head olist; 1344 struct tcon_link *tlink; 1345 __u8 lease_key[16]; 1346 __u32 oplock; 1347}; 1348 1349struct cifs_deferred_close { 1350 struct list_head dlist; 1351 struct tcon_link *tlink; 1352 __u16 netfid; 1353 __u64 persistent_fid; 1354 __u64 volatile_fid; 1355}; 1356 1357/* 1358 * This info hangs off the cifsFileInfo structure, pointed to by llist. 1359 * This is used to track byte stream locks on the file 1360 */ 1361struct cifsLockInfo { 1362 struct list_head llist; /* pointer to next cifsLockInfo */ 1363 struct list_head blist; /* pointer to locks blocked on this */ 1364 wait_queue_head_t block_q; 1365 __u64 offset; 1366 __u64 length; 1367 __u32 pid; 1368 __u16 type; 1369 __u16 flags; 1370}; 1371 1372/* 1373 * One of these for each open instance of a file 1374 */ 1375struct cifs_search_info { 1376 loff_t index_of_last_entry; 1377 __u16 entries_in_buffer; 1378 __u16 info_level; 1379 __u32 resume_key; 1380 char *ntwrk_buf_start; 1381 char *srch_entries_start; 1382 char *last_entry; 1383 const char *presume_name; 1384 unsigned int resume_name_len; 1385 bool endOfSearch:1; 1386 bool emptyDir:1; 1387 bool unicode:1; 1388 bool smallBuf:1; /* so we know which buf_release function to call */ 1389}; 1390 1391#define ACL_NO_MODE ((umode_t)(-1)) 1392struct cifs_open_parms { 1393 struct cifs_tcon *tcon; 1394 struct cifs_sb_info *cifs_sb; 1395 int disposition; 1396 int desired_access; 1397 int create_options; 1398 const char *path; 1399 struct cifs_fid *fid; 1400 umode_t mode; 1401 bool reconnect:1; 1402 bool replay:1; /* indicates that this open is for a replay */ 1403 struct kvec *ea_cctx; 1404}; 1405 1406struct cifs_fid { 1407 __u16 netfid; 1408 __u64 persistent_fid; /* persist file id for smb2 */ 1409 __u64 volatile_fid; /* volatile file id for smb2 */ 1410 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for smb2 */ 1411 __u8 create_guid[16]; 1412 __u32 access; 1413 struct cifs_pending_open *pending_open; 1414 unsigned int epoch; 1415#ifdef CONFIG_CIFS_DEBUG2 1416 __u64 mid; 1417#endif /* CIFS_DEBUG2 */ 1418 bool purge_cache; 1419}; 1420 1421struct cifs_fid_locks { 1422 struct list_head llist; 1423 struct cifsFileInfo *cfile; /* fid that owns locks */ 1424 struct list_head locks; /* locks held by fid above */ 1425}; 1426 1427struct cifsFileInfo { 1428 /* following two lists are protected by tcon->open_file_lock */ 1429 struct list_head tlist; /* pointer to next fid owned by tcon */ 1430 struct list_head flist; /* next fid (file instance) for this inode */ 1431 /* lock list below protected by cifsi->lock_sem */ 1432 struct cifs_fid_locks *llist; /* brlocks held by this fid */ 1433 kuid_t uid; /* allows finding which FileInfo structure */ 1434 __u32 pid; /* process id who opened file */ 1435 struct cifs_fid fid; /* file id from remote */ 1436 struct list_head rlist; /* reconnect list */ 1437 /* BB add lock scope info here if needed */ 1438 /* lock scope id (0 if none) */ 1439 struct dentry *dentry; 1440 struct tcon_link *tlink; 1441 unsigned int f_flags; 1442 bool invalidHandle:1; /* file closed via session abend */ 1443 bool swapfile:1; 1444 bool oplock_break_cancelled:1; 1445 bool status_file_deleted:1; /* file has been deleted */ 1446 bool offload:1; /* offload final part of _put to a wq */ 1447 unsigned int oplock_epoch; /* epoch from the lease break */ 1448 __u32 oplock_level; /* oplock/lease level from the lease break */ 1449 int count; 1450 spinlock_t file_info_lock; /* protects four flag/count fields above */ 1451 struct mutex fh_mutex; /* prevents reopen race after dead ses*/ 1452 struct cifs_search_info srch_inf; 1453 struct work_struct oplock_break; /* work for oplock breaks */ 1454 struct work_struct put; /* work for the final part of _put */ 1455 struct work_struct serverclose; /* work for serverclose */ 1456 struct delayed_work deferred; 1457 bool deferred_close_scheduled; /* Flag to indicate close is scheduled */ 1458 char *symlink_target; 1459}; 1460 1461struct cifs_io_parms { 1462 __u16 netfid; 1463 __u64 persistent_fid; /* persist file id for smb2 */ 1464 __u64 volatile_fid; /* volatile file id for smb2 */ 1465 __u32 pid; 1466 __u64 offset; 1467 unsigned int length; 1468 struct cifs_tcon *tcon; 1469 struct TCP_Server_Info *server; 1470}; 1471 1472struct cifs_aio_ctx { 1473 struct kref refcount; 1474 struct list_head list; 1475 struct mutex aio_mutex; 1476 struct completion done; 1477 struct iov_iter iter; 1478 struct kiocb *iocb; 1479 struct cifsFileInfo *cfile; 1480 struct bio_vec *bv; 1481 loff_t pos; 1482 unsigned int nr_pinned_pages; 1483 ssize_t rc; 1484 unsigned int len; 1485 unsigned int total_len; 1486 unsigned int bv_need_unpin; /* If ->bv[] needs unpinning */ 1487 bool should_dirty; 1488 /* 1489 * Indicates if this aio_ctx is for direct_io, 1490 * If yes, iter is a copy of the user passed iov_iter 1491 */ 1492 bool direct_io; 1493}; 1494 1495/* asynchronous read support */ 1496struct cifs_readdata { 1497 struct kref refcount; 1498 struct list_head list; 1499 struct completion done; 1500 struct cifsFileInfo *cfile; 1501 struct address_space *mapping; 1502 struct cifs_aio_ctx *ctx; 1503 __u64 offset; 1504 ssize_t got_bytes; 1505 unsigned int bytes; 1506 pid_t pid; 1507 int result; 1508 struct work_struct work; 1509 struct iov_iter iter; 1510 struct kvec iov[2]; 1511 struct TCP_Server_Info *server; 1512#ifdef CONFIG_CIFS_SMB_DIRECT 1513 struct smbd_mr *mr; 1514#endif 1515 struct cifs_credits credits; 1516}; 1517 1518/* asynchronous write support */ 1519struct cifs_writedata { 1520 struct kref refcount; 1521 struct list_head list; 1522 struct completion done; 1523 enum writeback_sync_modes sync_mode; 1524 struct work_struct work; 1525 struct cifsFileInfo *cfile; 1526 struct cifs_aio_ctx *ctx; 1527 struct iov_iter iter; 1528 struct bio_vec *bv; 1529 __u64 offset; 1530 pid_t pid; 1531 unsigned int bytes; 1532 int result; 1533 struct TCP_Server_Info *server; 1534#ifdef CONFIG_CIFS_SMB_DIRECT 1535 struct smbd_mr *mr; 1536#endif 1537 struct cifs_credits credits; 1538 bool replay; 1539}; 1540 1541/* 1542 * Take a reference on the file private data. Must be called with 1543 * cfile->file_info_lock held. 1544 */ 1545static inline void 1546cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file) 1547{ 1548 ++cifs_file->count; 1549} 1550 1551struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file); 1552void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_hdlr, 1553 bool offload); 1554void cifsFileInfo_put(struct cifsFileInfo *cifs_file); 1555 1556#define CIFS_CACHE_READ_FLG 1 1557#define CIFS_CACHE_HANDLE_FLG 2 1558#define CIFS_CACHE_RH_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_HANDLE_FLG) 1559#define CIFS_CACHE_WRITE_FLG 4 1560#define CIFS_CACHE_RW_FLG (CIFS_CACHE_READ_FLG | CIFS_CACHE_WRITE_FLG) 1561#define CIFS_CACHE_RHW_FLG (CIFS_CACHE_RW_FLG | CIFS_CACHE_HANDLE_FLG) 1562 1563#define CIFS_CACHE_READ(cinode) ((cinode->oplock & CIFS_CACHE_READ_FLG) || (CIFS_SB(cinode->netfs.inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE)) 1564#define CIFS_CACHE_HANDLE(cinode) (cinode->oplock & CIFS_CACHE_HANDLE_FLG) 1565#define CIFS_CACHE_WRITE(cinode) ((cinode->oplock & CIFS_CACHE_WRITE_FLG) || (CIFS_SB(cinode->netfs.inode.i_sb)->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)) 1566 1567/* 1568 * One of these for each file inode 1569 */ 1570 1571struct cifsInodeInfo { 1572 struct netfs_inode netfs; /* Netfslib context and vfs inode */ 1573 bool can_cache_brlcks; 1574 struct list_head llist; /* locks helb by this inode */ 1575 /* 1576 * NOTE: Some code paths call down_read(lock_sem) twice, so 1577 * we must always use cifs_down_write() instead of down_write() 1578 * for this semaphore to avoid deadlocks. 1579 */ 1580 struct rw_semaphore lock_sem; /* protect the fields above */ 1581 /* BB add in lists for dirty pages i.e. write caching info for oplock */ 1582 struct list_head openFileList; 1583 spinlock_t open_file_lock; /* protects openFileList */ 1584 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */ 1585 unsigned int oplock; /* oplock/lease level we have */ 1586 unsigned int epoch; /* used to track lease state changes */ 1587#define CIFS_INODE_PENDING_OPLOCK_BREAK (0) /* oplock break in progress */ 1588#define CIFS_INODE_PENDING_WRITERS (1) /* Writes in progress */ 1589#define CIFS_INODE_FLAG_UNUSED (2) /* Unused flag */ 1590#define CIFS_INO_DELETE_PENDING (3) /* delete pending on server */ 1591#define CIFS_INO_INVALID_MAPPING (4) /* pagecache is invalid */ 1592#define CIFS_INO_LOCK (5) /* lock bit for synchronization */ 1593#define CIFS_INO_MODIFIED_ATTR (6) /* Indicate change in mtime/ctime */ 1594#define CIFS_INO_CLOSE_ON_LOCK (7) /* Not to defer the close when lock is set */ 1595 unsigned long flags; 1596 spinlock_t writers_lock; 1597 unsigned int writers; /* Number of writers on this inode */ 1598 unsigned long time; /* jiffies of last update of inode */ 1599 u64 uniqueid; /* server inode number */ 1600 u64 createtime; /* creation time on server */ 1601 __u8 lease_key[SMB2_LEASE_KEY_SIZE]; /* lease key for this inode */ 1602 struct list_head deferred_closes; /* list of deferred closes */ 1603 spinlock_t deferred_lock; /* protection on deferred list */ 1604 bool lease_granted; /* Flag to indicate whether lease or oplock is granted. */ 1605 char *symlink_target; 1606 __u32 reparse_tag; 1607}; 1608 1609static inline struct cifsInodeInfo * 1610CIFS_I(struct inode *inode) 1611{ 1612 return container_of(inode, struct cifsInodeInfo, netfs.inode); 1613} 1614 1615static inline struct cifs_sb_info * 1616CIFS_SB(struct super_block *sb) 1617{ 1618 return sb->s_fs_info; 1619} 1620 1621static inline struct cifs_sb_info * 1622CIFS_FILE_SB(struct file *file) 1623{ 1624 return CIFS_SB(file_inode(file)->i_sb); 1625} 1626 1627static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb) 1628{ 1629 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) 1630 return '/'; 1631 else 1632 return '\\'; 1633} 1634 1635static inline void 1636convert_delimiter(char *path, char delim) 1637{ 1638 char old_delim, *pos; 1639 1640 if (delim == '/') 1641 old_delim = '\\'; 1642 else 1643 old_delim = '/'; 1644 1645 pos = path; 1646 while ((pos = strchr(pos, old_delim))) 1647 *pos = delim; 1648} 1649 1650#define cifs_stats_inc atomic_inc 1651 1652static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon, 1653 unsigned int bytes) 1654{ 1655 if (bytes) { 1656 spin_lock(&tcon->stat_lock); 1657 tcon->bytes_written += bytes; 1658 spin_unlock(&tcon->stat_lock); 1659 } 1660} 1661 1662static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon, 1663 unsigned int bytes) 1664{ 1665 spin_lock(&tcon->stat_lock); 1666 tcon->bytes_read += bytes; 1667 spin_unlock(&tcon->stat_lock); 1668} 1669 1670 1671/* 1672 * This is the prototype for the mid receive function. This function is for 1673 * receiving the rest of the SMB frame, starting with the WordCount (which is 1674 * just after the MID in struct smb_hdr). Note: 1675 * 1676 * - This will be called by cifsd, with no locks held. 1677 * - The mid will still be on the pending_mid_q. 1678 * - mid->resp_buf will point to the current buffer. 1679 * 1680 * Returns zero on a successful receive, or an error. The receive state in 1681 * the TCP_Server_Info will also be updated. 1682 */ 1683typedef int (mid_receive_t)(struct TCP_Server_Info *server, 1684 struct mid_q_entry *mid); 1685 1686/* 1687 * This is the prototype for the mid callback function. This is called once the 1688 * mid has been received off of the socket. When creating one, take special 1689 * care to avoid deadlocks. Things to bear in mind: 1690 * 1691 * - it will be called by cifsd, with no locks held 1692 * - the mid will be removed from any lists 1693 */ 1694typedef void (mid_callback_t)(struct mid_q_entry *mid); 1695 1696/* 1697 * This is the protopyte for mid handle function. This is called once the mid 1698 * has been recognized after decryption of the message. 1699 */ 1700typedef int (mid_handle_t)(struct TCP_Server_Info *server, 1701 struct mid_q_entry *mid); 1702 1703/* one of these for every pending CIFS request to the server */ 1704struct mid_q_entry { 1705 struct list_head qhead; /* mids waiting on reply from this server */ 1706 struct kref refcount; 1707 struct TCP_Server_Info *server; /* server corresponding to this mid */ 1708 __u64 mid; /* multiplex id */ 1709 __u16 credits; /* number of credits consumed by this mid */ 1710 __u16 credits_received; /* number of credits from the response */ 1711 __u32 pid; /* process id */ 1712 __u32 sequence_number; /* for CIFS signing */ 1713 unsigned long when_alloc; /* when mid was created */ 1714#ifdef CONFIG_CIFS_STATS2 1715 unsigned long when_sent; /* time when smb send finished */ 1716 unsigned long when_received; /* when demux complete (taken off wire) */ 1717#endif 1718 mid_receive_t *receive; /* call receive callback */ 1719 mid_callback_t *callback; /* call completion callback */ 1720 mid_handle_t *handle; /* call handle mid callback */ 1721 void *callback_data; /* general purpose pointer for callback */ 1722 struct task_struct *creator; 1723 void *resp_buf; /* pointer to received SMB header */ 1724 unsigned int resp_buf_size; 1725 int mid_state; /* wish this were enum but can not pass to wait_event */ 1726 unsigned int mid_flags; 1727 __le16 command; /* smb command code */ 1728 unsigned int optype; /* operation type */ 1729 bool large_buf:1; /* if valid response, is pointer to large buf */ 1730 bool multiRsp:1; /* multiple trans2 responses for one request */ 1731 bool multiEnd:1; /* both received */ 1732 bool decrypted:1; /* decrypted entry */ 1733}; 1734 1735struct close_cancelled_open { 1736 struct cifs_fid fid; 1737 struct cifs_tcon *tcon; 1738 struct work_struct work; 1739 __u64 mid; 1740 __u16 cmd; 1741}; 1742 1743/* Make code in transport.c a little cleaner by moving 1744 update of optional stats into function below */ 1745static inline void cifs_in_send_inc(struct TCP_Server_Info *server) 1746{ 1747 atomic_inc(&server->in_send); 1748} 1749 1750static inline void cifs_in_send_dec(struct TCP_Server_Info *server) 1751{ 1752 atomic_dec(&server->in_send); 1753} 1754 1755static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server) 1756{ 1757 atomic_inc(&server->num_waiters); 1758} 1759 1760static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server) 1761{ 1762 atomic_dec(&server->num_waiters); 1763} 1764 1765#ifdef CONFIG_CIFS_STATS2 1766static inline void cifs_save_when_sent(struct mid_q_entry *mid) 1767{ 1768 mid->when_sent = jiffies; 1769} 1770#else 1771static inline void cifs_save_when_sent(struct mid_q_entry *mid) 1772{ 1773} 1774#endif 1775 1776/* for pending dnotify requests */ 1777struct dir_notify_req { 1778 struct list_head lhead; 1779 __le16 Pid; 1780 __le16 PidHigh; 1781 __u16 Mid; 1782 __u16 Tid; 1783 __u16 Uid; 1784 __u16 netfid; 1785 __u32 filter; /* CompletionFilter (for multishot) */ 1786 int multishot; 1787 struct file *pfile; 1788}; 1789 1790struct dfs_info3_param { 1791 int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/ 1792 int path_consumed; 1793 int server_type; 1794 int ref_flag; 1795 char *path_name; 1796 char *node_name; 1797 int ttl; 1798}; 1799 1800struct file_list { 1801 struct list_head list; 1802 struct cifsFileInfo *cfile; 1803}; 1804 1805struct cifs_mount_ctx { 1806 struct cifs_sb_info *cifs_sb; 1807 struct smb3_fs_context *fs_ctx; 1808 unsigned int xid; 1809 struct TCP_Server_Info *server; 1810 struct cifs_ses *ses; 1811 struct cifs_tcon *tcon; 1812}; 1813 1814static inline void __free_dfs_info_param(struct dfs_info3_param *param) 1815{ 1816 kfree(param->path_name); 1817 kfree(param->node_name); 1818} 1819 1820static inline void free_dfs_info_param(struct dfs_info3_param *param) 1821{ 1822 if (param) 1823 __free_dfs_info_param(param); 1824} 1825 1826static inline void zfree_dfs_info_param(struct dfs_info3_param *param) 1827{ 1828 if (param) { 1829 __free_dfs_info_param(param); 1830 memset(param, 0, sizeof(*param)); 1831 } 1832} 1833 1834static inline void free_dfs_info_array(struct dfs_info3_param *param, 1835 int number_of_items) 1836{ 1837 int i; 1838 1839 if ((number_of_items == 0) || (param == NULL)) 1840 return; 1841 for (i = 0; i < number_of_items; i++) { 1842 kfree(param[i].path_name); 1843 kfree(param[i].node_name); 1844 } 1845 kfree(param); 1846} 1847 1848static inline bool is_interrupt_error(int error) 1849{ 1850 switch (error) { 1851 case -EINTR: 1852 case -ERESTARTSYS: 1853 case -ERESTARTNOHAND: 1854 case -ERESTARTNOINTR: 1855 return true; 1856 } 1857 return false; 1858} 1859 1860static inline bool is_retryable_error(int error) 1861{ 1862 if (is_interrupt_error(error) || error == -EAGAIN) 1863 return true; 1864 return false; 1865} 1866 1867static inline bool is_replayable_error(int error) 1868{ 1869 if (error == -EAGAIN || error == -ECONNABORTED) 1870 return true; 1871 return false; 1872} 1873 1874 1875/* cifs_get_writable_file() flags */ 1876#define FIND_WR_ANY 0 1877#define FIND_WR_FSUID_ONLY 1 1878#define FIND_WR_WITH_DELETE 2 1879 1880#define MID_FREE 0 1881#define MID_REQUEST_ALLOCATED 1 1882#define MID_REQUEST_SUBMITTED 2 1883#define MID_RESPONSE_RECEIVED 4 1884#define MID_RETRY_NEEDED 8 /* session closed while this request out */ 1885#define MID_RESPONSE_MALFORMED 0x10 1886#define MID_SHUTDOWN 0x20 1887#define MID_RESPONSE_READY 0x40 /* ready for other process handle the rsp */ 1888 1889/* Flags */ 1890#define MID_WAIT_CANCELLED 1 /* Cancelled while waiting for response */ 1891#define MID_DELETED 2 /* Mid has been dequeued/deleted */ 1892 1893/* Types of response buffer returned from SendReceive2 */ 1894#define CIFS_NO_BUFFER 0 /* Response buffer not returned */ 1895#define CIFS_SMALL_BUFFER 1 1896#define CIFS_LARGE_BUFFER 2 1897#define CIFS_IOVEC 4 /* array of response buffers */ 1898 1899/* Type of Request to SendReceive2 */ 1900#define CIFS_BLOCKING_OP 1 /* operation can block */ 1901#define CIFS_NON_BLOCKING 2 /* do not block waiting for credits */ 1902#define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */ 1903#define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */ 1904#define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */ 1905#define CIFS_NO_RSP_BUF 0x040 /* no response buffer required */ 1906 1907/* Type of request operation */ 1908#define CIFS_ECHO_OP 0x080 /* echo request */ 1909#define CIFS_OBREAK_OP 0x0100 /* oplock break request */ 1910#define CIFS_NEG_OP 0x0200 /* negotiate request */ 1911#define CIFS_CP_CREATE_CLOSE_OP 0x0400 /* compound create+close request */ 1912/* Lower bitmask values are reserved by others below. */ 1913#define CIFS_SESS_OP 0x2000 /* session setup request */ 1914#define CIFS_OP_MASK 0x2780 /* mask request type */ 1915 1916#define CIFS_HAS_CREDITS 0x0400 /* already has credits */ 1917#define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */ 1918#define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */ 1919 1920/* Security Flags: indicate type of session setup needed */ 1921#define CIFSSEC_MAY_SIGN 0x00001 1922#define CIFSSEC_MAY_NTLMV2 0x00004 1923#define CIFSSEC_MAY_KRB5 0x00008 1924#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */ 1925#define CIFSSEC_MAY_NTLMSSP 0x00080 /* raw ntlmssp with ntlmv2 */ 1926 1927#define CIFSSEC_MUST_SIGN 0x01001 1928/* note that only one of the following can be set so the 1929result of setting MUST flags more than once will be to 1930require use of the stronger protocol */ 1931#define CIFSSEC_MUST_NTLMV2 0x04004 1932#define CIFSSEC_MUST_KRB5 0x08008 1933#ifdef CONFIG_CIFS_UPCALL 1934#define CIFSSEC_MASK 0x8F08F /* flags supported if no weak allowed */ 1935#else 1936#define CIFSSEC_MASK 0x87087 /* flags supported if no weak allowed */ 1937#endif /* UPCALL */ 1938#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */ 1939#define CIFSSEC_MUST_NTLMSSP 0x80080 /* raw ntlmssp with ntlmv2 */ 1940 1941#define CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_NTLMSSP) 1942#define CIFSSEC_MAX (CIFSSEC_MUST_NTLMV2) 1943#define CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP) 1944/* 1945 ***************************************************************** 1946 * All constants go here 1947 ***************************************************************** 1948 */ 1949 1950#define UID_HASH (16) 1951 1952/* 1953 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the 1954 * following to be declared. 1955 */ 1956 1957/**************************************************************************** 1958 * Here are all the locks (spinlock, mutex, semaphore) in cifs.ko, arranged according 1959 * to the locking order. i.e. if two locks are to be held together, the lock that 1960 * appears higher in this list needs to be taken before the other. 1961 * 1962 * If you hold a lock that is lower in this list, and you need to take a higher lock 1963 * (or if you think that one of the functions that you're calling may need to), first 1964 * drop the lock you hold, pick up the higher lock, then the lower one. This will 1965 * ensure that locks are picked up only in one direction in the below table 1966 * (top to bottom). 1967 * 1968 * Also, if you expect a function to be called with a lock held, explicitly document 1969 * this in the comments on top of your function definition. 1970 * 1971 * And also, try to keep the critical sections (lock hold time) to be as minimal as 1972 * possible. Blocking / calling other functions with a lock held always increase 1973 * the risk of a possible deadlock. 1974 * 1975 * Following this rule will avoid unnecessary deadlocks, which can get really hard to 1976 * debug. Also, any new lock that you introduce, please add to this list in the correct 1977 * order. 1978 * 1979 * Please populate this list whenever you introduce new locks in your changes. Or in 1980 * case I've missed some existing locks. Please ensure that it's added in the list 1981 * based on the locking order expected. 1982 * 1983 * ===================================================================================== 1984 * Lock Protects Initialization fn 1985 * ===================================================================================== 1986 * vol_list_lock 1987 * vol_info->ctx_lock vol_info->ctx 1988 * cifs_sb_info->tlink_tree_lock cifs_sb_info->tlink_tree cifs_setup_cifs_sb 1989 * TCP_Server_Info-> TCP_Server_Info cifs_get_tcp_session 1990 * reconnect_mutex 1991 * TCP_Server_Info->srv_mutex TCP_Server_Info cifs_get_tcp_session 1992 * cifs_ses->session_mutex cifs_ses sesInfoAlloc 1993 * cifs_tcon 1994 * cifs_tcon->open_file_lock cifs_tcon->openFileList tconInfoAlloc 1995 * cifs_tcon->pending_opens 1996 * cifs_tcon->stat_lock cifs_tcon->bytes_read tconInfoAlloc 1997 * cifs_tcon->bytes_written 1998 * cifs_tcp_ses_lock cifs_tcp_ses_list sesInfoAlloc 1999 * GlobalMid_Lock GlobalMaxActiveXid init_cifs 2000 * GlobalCurrentXid 2001 * GlobalTotalActiveXid 2002 * TCP_Server_Info->srv_lock (anything in struct not protected by another lock and can change) 2003 * TCP_Server_Info->mid_lock TCP_Server_Info->pending_mid_q cifs_get_tcp_session 2004 * ->CurrentMid 2005 * (any changes in mid_q_entry fields) 2006 * TCP_Server_Info->req_lock TCP_Server_Info->in_flight cifs_get_tcp_session 2007 * ->credits 2008 * ->echo_credits 2009 * ->oplock_credits 2010 * ->reconnect_instance 2011 * cifs_ses->ses_lock (anything that is not protected by another lock and can change) 2012 * cifs_ses->iface_lock cifs_ses->iface_list sesInfoAlloc 2013 * ->iface_count 2014 * ->iface_last_update 2015 * cifs_ses->chan_lock cifs_ses->chans 2016 * ->chans_need_reconnect 2017 * ->chans_in_reconnect 2018 * cifs_tcon->tc_lock (anything that is not protected by another lock and can change) 2019 * cifsInodeInfo->open_file_lock cifsInodeInfo->openFileList cifs_alloc_inode 2020 * cifsInodeInfo->writers_lock cifsInodeInfo->writers cifsInodeInfo_alloc 2021 * cifsInodeInfo->lock_sem cifsInodeInfo->llist cifs_init_once 2022 * ->can_cache_brlcks 2023 * cifsInodeInfo->deferred_lock cifsInodeInfo->deferred_closes cifsInodeInfo_alloc 2024 * cached_fid->fid_mutex cifs_tcon->crfid tcon_info_alloc 2025 * cifsFileInfo->fh_mutex cifsFileInfo cifs_new_fileinfo 2026 * cifsFileInfo->file_info_lock cifsFileInfo->count cifs_new_fileinfo 2027 * ->invalidHandle initiate_cifs_search 2028 * ->oplock_break_cancelled 2029 * cifs_aio_ctx->aio_mutex cifs_aio_ctx cifs_aio_ctx_alloc 2030 ****************************************************************************/ 2031 2032#ifdef DECLARE_GLOBALS_HERE 2033#define GLOBAL_EXTERN 2034#else 2035#define GLOBAL_EXTERN extern 2036#endif 2037 2038/* 2039 * the list of TCP_Server_Info structures, ie each of the sockets 2040 * connecting our client to a distinct server (ip address), is 2041 * chained together by cifs_tcp_ses_list. The list of all our SMB 2042 * sessions (and from that the tree connections) can be found 2043 * by iterating over cifs_tcp_ses_list 2044 */ 2045extern struct list_head cifs_tcp_ses_list; 2046 2047/* 2048 * This lock protects the cifs_tcp_ses_list, the list of smb sessions per 2049 * tcp session, and the list of tcon's per smb session. It also protects 2050 * the reference counters for the server, smb session, and tcon. 2051 * generally the locks should be taken in order tcp_ses_lock before 2052 * tcon->open_file_lock and that before file->file_info_lock since the 2053 * structure order is cifs_socket-->cifs_ses-->cifs_tcon-->cifs_file 2054 */ 2055extern spinlock_t cifs_tcp_ses_lock; 2056 2057/* 2058 * Global transaction id (XID) information 2059 */ 2060extern unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */ 2061extern unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */ 2062extern unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */ 2063extern spinlock_t GlobalMid_Lock; /* protects above & list operations on midQ entries */ 2064 2065/* 2066 * Global counters, updated atomically 2067 */ 2068extern atomic_t sesInfoAllocCount; 2069extern atomic_t tconInfoAllocCount; 2070extern atomic_t tcpSesNextId; 2071extern atomic_t tcpSesAllocCount; 2072extern atomic_t tcpSesReconnectCount; 2073extern atomic_t tconInfoReconnectCount; 2074 2075/* Various Debug counters */ 2076extern atomic_t buf_alloc_count; /* current number allocated */ 2077extern atomic_t small_buf_alloc_count; 2078#ifdef CONFIG_CIFS_STATS2 2079extern atomic_t total_buf_alloc_count; /* total allocated over all time */ 2080extern atomic_t total_small_buf_alloc_count; 2081extern unsigned int slow_rsp_threshold; /* number of secs before logging */ 2082#endif 2083 2084/* Misc globals */ 2085extern bool enable_oplocks; /* enable or disable oplocks */ 2086extern bool lookupCacheEnabled; 2087extern unsigned int global_secflags; /* if on, session setup sent 2088 with more secure ntlmssp2 challenge/resp */ 2089extern unsigned int sign_CIFS_PDUs; /* enable smb packet signing */ 2090extern bool enable_gcm_256; /* allow optional negotiate of strongest signing (aes-gcm-256) */ 2091extern bool require_gcm_256; /* require use of strongest signing (aes-gcm-256) */ 2092extern bool enable_negotiate_signing; /* request use of faster (GMAC) signing if available */ 2093extern bool linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/ 2094extern unsigned int CIFSMaxBufSize; /* max size not including hdr */ 2095extern unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */ 2096extern unsigned int cifs_min_small; /* min size of small buf pool */ 2097extern unsigned int cifs_max_pending; /* MAX requests at once to server*/ 2098extern unsigned int dir_cache_timeout; /* max time for directory lease caching of dir */ 2099extern bool disable_legacy_dialects; /* forbid vers=1.0 and vers=2.0 mounts */ 2100extern atomic_t mid_count; 2101 2102void cifs_oplock_break(struct work_struct *work); 2103void cifs_queue_oplock_break(struct cifsFileInfo *cfile); 2104void smb2_deferred_work_close(struct work_struct *work); 2105 2106extern const struct slow_work_ops cifs_oplock_break_ops; 2107extern struct workqueue_struct *cifsiod_wq; 2108extern struct workqueue_struct *decrypt_wq; 2109extern struct workqueue_struct *fileinfo_put_wq; 2110extern struct workqueue_struct *cifsoplockd_wq; 2111extern struct workqueue_struct *deferredclose_wq; 2112extern struct workqueue_struct *serverclose_wq; 2113extern __u32 cifs_lock_secret; 2114 2115extern mempool_t *cifs_sm_req_poolp; 2116extern mempool_t *cifs_req_poolp; 2117extern mempool_t *cifs_mid_poolp; 2118 2119/* Operations for different SMB versions */ 2120#define SMB1_VERSION_STRING "1.0" 2121#define SMB20_VERSION_STRING "2.0" 2122#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2123extern struct smb_version_operations smb1_operations; 2124extern struct smb_version_values smb1_values; 2125extern struct smb_version_operations smb20_operations; 2126extern struct smb_version_values smb20_values; 2127#endif /* CIFS_ALLOW_INSECURE_LEGACY */ 2128#define SMB21_VERSION_STRING "2.1" 2129extern struct smb_version_operations smb21_operations; 2130extern struct smb_version_values smb21_values; 2131#define SMBDEFAULT_VERSION_STRING "default" 2132extern struct smb_version_values smbdefault_values; 2133#define SMB3ANY_VERSION_STRING "3" 2134extern struct smb_version_values smb3any_values; 2135#define SMB30_VERSION_STRING "3.0" 2136extern struct smb_version_operations smb30_operations; 2137extern struct smb_version_values smb30_values; 2138#define SMB302_VERSION_STRING "3.02" 2139#define ALT_SMB302_VERSION_STRING "3.0.2" 2140/*extern struct smb_version_operations smb302_operations;*/ /* not needed yet */ 2141extern struct smb_version_values smb302_values; 2142#define SMB311_VERSION_STRING "3.1.1" 2143#define ALT_SMB311_VERSION_STRING "3.11" 2144extern struct smb_version_operations smb311_operations; 2145extern struct smb_version_values smb311_values; 2146 2147static inline char *get_security_type_str(enum securityEnum sectype) 2148{ 2149 switch (sectype) { 2150 case RawNTLMSSP: 2151 return "RawNTLMSSP"; 2152 case Kerberos: 2153 return "Kerberos"; 2154 case NTLMv2: 2155 return "NTLMv2"; 2156 default: 2157 return "Unknown"; 2158 } 2159} 2160 2161static inline bool is_smb1_server(struct TCP_Server_Info *server) 2162{ 2163 return strcmp(server->vals->version_string, SMB1_VERSION_STRING) == 0; 2164} 2165 2166static inline bool is_tcon_dfs(struct cifs_tcon *tcon) 2167{ 2168 /* 2169 * For SMB1, see MS-CIFS 2.4.55 SMB_COM_TREE_CONNECT_ANDX (0x75) and MS-CIFS 3.3.4.4 DFS 2170 * Subsystem Notifies That a Share Is a DFS Share. 2171 * 2172 * For SMB2+, see MS-SMB2 2.2.10 SMB2 TREE_CONNECT Response and MS-SMB2 3.3.4.14 Server 2173 * Application Updates a Share. 2174 */ 2175 if (!tcon || !tcon->ses || !tcon->ses->server) 2176 return false; 2177 return is_smb1_server(tcon->ses->server) ? tcon->Flags & SMB_SHARE_IS_IN_DFS : 2178 tcon->share_flags & (SHI1005_FLAGS_DFS | SHI1005_FLAGS_DFS_ROOT); 2179} 2180 2181static inline bool cifs_is_referral_server(struct cifs_tcon *tcon, 2182 const struct dfs_info3_param *ref) 2183{ 2184 /* 2185 * Check if all targets are capable of handling DFS referrals as per 2186 * MS-DFSC 2.2.4 RESP_GET_DFS_REFERRAL. 2187 */ 2188 return is_tcon_dfs(tcon) || (ref && (ref->flags & DFSREF_REFERRAL_SERVER)); 2189} 2190 2191static inline u64 cifs_flock_len(const struct file_lock *fl) 2192{ 2193 return (u64)fl->fl_end - fl->fl_start + 1; 2194} 2195 2196static inline size_t ntlmssp_workstation_name_size(const struct cifs_ses *ses) 2197{ 2198 if (WARN_ON_ONCE(!ses || !ses->server)) 2199 return 0; 2200 /* 2201 * Make workstation name no more than 15 chars when using insecure dialects as some legacy 2202 * servers do require it during NTLMSSP. 2203 */ 2204 if (ses->server->dialect <= SMB20_PROT_ID) 2205 return min_t(size_t, sizeof(ses->workstation_name), RFC1001_NAME_LEN_WITH_NULL); 2206 return sizeof(ses->workstation_name); 2207} 2208 2209static inline void move_cifs_info_to_smb2(struct smb2_file_all_info *dst, const FILE_ALL_INFO *src) 2210{ 2211 memcpy(dst, src, (size_t)((u8 *)&src->AccessFlags - (u8 *)src)); 2212 dst->AccessFlags = src->AccessFlags; 2213 dst->CurrentByteOffset = src->CurrentByteOffset; 2214 dst->Mode = src->Mode; 2215 dst->AlignmentRequirement = src->AlignmentRequirement; 2216 dst->FileNameLength = src->FileNameLength; 2217} 2218 2219static inline int cifs_get_num_sgs(const struct smb_rqst *rqst, 2220 int num_rqst, 2221 const u8 *sig) 2222{ 2223 unsigned int len, skip; 2224 unsigned int nents = 0; 2225 unsigned long addr; 2226 size_t data_size; 2227 int i, j; 2228 2229 /* 2230 * The first rqst has a transform header where the first 20 bytes are 2231 * not part of the encrypted blob. 2232 */ 2233 skip = 20; 2234 2235 /* Assumes the first rqst has a transform header as the first iov. 2236 * I.e. 2237 * rqst[0].rq_iov[0] is transform header 2238 * rqst[0].rq_iov[1+] data to be encrypted/decrypted 2239 * rqst[1+].rq_iov[0+] data to be encrypted/decrypted 2240 */ 2241 for (i = 0; i < num_rqst; i++) { 2242 data_size = iov_iter_count(&rqst[i].rq_iter); 2243 2244 /* We really don't want a mixture of pinned and unpinned pages 2245 * in the sglist. It's hard to keep track of which is what. 2246 * Instead, we convert to a BVEC-type iterator higher up. 2247 */ 2248 if (data_size && 2249 WARN_ON_ONCE(user_backed_iter(&rqst[i].rq_iter))) 2250 return -EIO; 2251 2252 /* We also don't want to have any extra refs or pins to clean 2253 * up in the sglist. 2254 */ 2255 if (data_size && 2256 WARN_ON_ONCE(iov_iter_extract_will_pin(&rqst[i].rq_iter))) 2257 return -EIO; 2258 2259 for (j = 0; j < rqst[i].rq_nvec; j++) { 2260 struct kvec *iov = &rqst[i].rq_iov[j]; 2261 2262 addr = (unsigned long)iov->iov_base + skip; 2263 if (unlikely(is_vmalloc_addr((void *)addr))) { 2264 len = iov->iov_len - skip; 2265 nents += DIV_ROUND_UP(offset_in_page(addr) + len, 2266 PAGE_SIZE); 2267 } else { 2268 nents++; 2269 } 2270 skip = 0; 2271 } 2272 if (data_size) 2273 nents += iov_iter_npages(&rqst[i].rq_iter, INT_MAX); 2274 } 2275 nents += DIV_ROUND_UP(offset_in_page(sig) + SMB2_SIGNATURE_SIZE, PAGE_SIZE); 2276 return nents; 2277} 2278 2279/* We can not use the normal sg_set_buf() as we will sometimes pass a 2280 * stack object as buf. 2281 */ 2282static inline void cifs_sg_set_buf(struct sg_table *sgtable, 2283 const void *buf, 2284 unsigned int buflen) 2285{ 2286 unsigned long addr = (unsigned long)buf; 2287 unsigned int off = offset_in_page(addr); 2288 2289 addr &= PAGE_MASK; 2290 if (unlikely(is_vmalloc_addr((void *)addr))) { 2291 do { 2292 unsigned int len = min_t(unsigned int, buflen, PAGE_SIZE - off); 2293 2294 sg_set_page(&sgtable->sgl[sgtable->nents++], 2295 vmalloc_to_page((void *)addr), len, off); 2296 2297 off = 0; 2298 addr += PAGE_SIZE; 2299 buflen -= len; 2300 } while (buflen); 2301 } else { 2302 sg_set_page(&sgtable->sgl[sgtable->nents++], 2303 virt_to_page((void *)addr), buflen, off); 2304 } 2305} 2306 2307#define CIFS_OPARMS(_cifs_sb, _tcon, _path, _da, _cd, _co, _mode) \ 2308 ((struct cifs_open_parms) { \ 2309 .tcon = _tcon, \ 2310 .path = _path, \ 2311 .desired_access = (_da), \ 2312 .disposition = (_cd), \ 2313 .create_options = cifs_create_options(_cifs_sb, (_co)), \ 2314 .mode = (_mode), \ 2315 .cifs_sb = _cifs_sb, \ 2316 }) 2317 2318struct smb2_compound_vars { 2319 struct cifs_open_parms oparms; 2320 struct kvec rsp_iov[MAX_COMPOUND]; 2321 struct smb_rqst rqst[MAX_COMPOUND]; 2322 struct kvec open_iov[SMB2_CREATE_IOV_SIZE]; 2323 struct kvec qi_iov; 2324 struct kvec io_iov[SMB2_IOCTL_IOV_SIZE]; 2325 struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE]; 2326 struct kvec close_iov; 2327 struct smb2_file_rename_info rename_info; 2328 struct smb2_file_link_info link_info; 2329 struct kvec ea_iov; 2330}; 2331 2332static inline bool cifs_ses_exiting(struct cifs_ses *ses) 2333{ 2334 bool ret; 2335 2336 spin_lock(&ses->ses_lock); 2337 ret = ses->ses_status == SES_EXITING; 2338 spin_unlock(&ses->ses_lock); 2339 return ret; 2340} 2341 2342#endif /* _CIFS_GLOB_H */ 2343