fs/cifs/cifsglob.h

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