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