fs/cifs/cifsglob.h

   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/mempool.h>
  26 #include <linux/workqueue.h>
  27 #include "cifs_fs_sb.h"
  28 #include "cifsacl.h"
  29 #include <crypto/internal/hash.h>
  30 #include <linux/scatterlist.h>
  31 #ifdef CONFIG_CIFS_SMB2
  32 #include "smb2pdu.h"
  33 #endif
  34
  35 /*
  36  * The sizes of various internal tables and strings
  37  */
  38 #define MAX_UID_INFO 16
  39 #define MAX_SES_INFO 2
  40 #define MAX_TCON_INFO 4
  41
  42 #define MAX_TREE_SIZE (2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1)
  43 #define MAX_SERVER_SIZE 15
  44 #define MAX_SHARE_SIZE 80
  45 #define MAX_USERNAME_SIZE 256   /* reasonable maximum for current servers */
  46 #define MAX_PASSWORD_SIZE 512   /* max for windows seems to be 256 wide chars */
  47
  48 #define CIFS_MIN_RCV_POOL 4
  49
  50 #define MAX_REOPEN_ATT  5 /* these many maximum attempts to reopen a file */
  51 /*
  52  * default attribute cache timeout (jiffies)
  53  */
  54 #define CIFS_DEF_ACTIMEO (1 * HZ)
  55
  56 /*
  57  * max attribute cache timeout (jiffies) - 2^30
  58  */
  59 #define CIFS_MAX_ACTIMEO (1 << 30)
  60
  61 /*
  62  * MAX_REQ is the maximum number of requests that WE will send
  63  * on one socket concurrently.
  64  */
  65 #define CIFS_MAX_REQ 32767
  66
  67 #define RFC1001_NAME_LEN 15
  68 #define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
  69
  70 /* currently length of NIP6_FMT */
  71 #define SERVER_NAME_LENGTH 40
  72 #define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
  73
  74 /* used to define string lengths for reversing unicode strings */
  75 /*         (256+1)*2 = 514                                     */
  76 /*           (max path length + 1 for null) * 2 for unicode    */
  77 #define MAX_NAME 514
  78
  79 /* SMB echo "timeout" -- FIXME: tunable? */
  80 #define SMB_ECHO_INTERVAL (60 * HZ)
  81
  82 #include "cifspdu.h"
  83
  84 #ifndef XATTR_DOS_ATTRIB
  85 #define XATTR_DOS_ATTRIB "user.DOSATTRIB"
  86 #endif
  87
  88 /*
  89  * CIFS vfs client Status information (based on what we know.)
  90  */
  91
  92 /* associated with each tcp and smb session */
  93 enum statusEnum {
  94         CifsNew = 0,
  95         CifsGood,
  96         CifsExiting,
  97         CifsNeedReconnect,
  98         CifsNeedNegotiate
  99 };
 100
 101 enum securityEnum {
 102         LANMAN = 0,                     /* Legacy LANMAN auth */
 103         NTLM,                   /* Legacy NTLM012 auth with NTLM hash */
 104         NTLMv2,                 /* Legacy NTLM auth with NTLMv2 hash */
 105         RawNTLMSSP,             /* NTLMSSP without SPNEGO, NTLMv2 hash */
 106 /*      NTLMSSP, */ /* can use rawNTLMSSP instead of NTLMSSP via SPNEGO */
 107         Kerberos,               /* Kerberos via SPNEGO */
 108 };
 109
 110 enum protocolEnum {
 111         TCP = 0,
 112         SCTP
 113         /* Netbios frames protocol not supported at this time */
 114 };
 115
 116 struct session_key {
 117         unsigned int len;
 118         char *response;
 119 };
 120
 121 /* crypto security descriptor definition */
 122 struct sdesc {
 123         struct shash_desc shash;
 124         char ctx[];
 125 };
 126
 127 /* crypto hashing related structure/fields, not specific to a sec mech */
 128 struct cifs_secmech {
 129         struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
 130         struct crypto_shash *md5; /* md5 hash function */
 131         struct crypto_shash *hmacsha256; /* hmac-sha256 hash function */
 132         struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */
 133         struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
 134         struct sdesc *sdeschmacsha256;  /* ctxt to generate smb2 signature */
 135 };
 136
 137 /* per smb session structure/fields */
 138 struct ntlmssp_auth {
 139         __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
 140         __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
 141         unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
 142         char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
 143 };
 144
 145 struct cifs_cred {
 146         int uid;
 147         int gid;
 148         int mode;
 149         int cecount;
 150         struct cifs_sid osid;
 151         struct cifs_sid gsid;
 152         struct cifs_ntace *ntaces;
 153         struct cifs_ace *aces;
 154 };
 155
 156 /*
 157  *****************************************************************
 158  * Except the CIFS PDUs themselves all the
 159  * globally interesting structs should go here
 160  *****************************************************************
 161  */
 162
 163 enum smb_version {
 164         Smb_1 = 1,
 165         Smb_21,
 166 };
 167
 168 struct mid_q_entry;
 169 struct TCP_Server_Info;
 170 struct cifsFileInfo;
 171 struct cifs_ses;
 172 struct cifs_tcon;
 173 struct dfs_info3_param;
 174 struct cifs_fattr;
 175 struct smb_vol;
 176 struct cifs_fid;
 177 struct cifs_readdata;
 178 struct cifs_writedata;
 179 struct cifs_io_parms;
 180 struct cifs_search_info;
 181
 182 struct smb_version_operations {
 183         int (*send_cancel)(struct TCP_Server_Info *, void *,
 184                            struct mid_q_entry *);
 185         bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
 186         /* setup request: allocate mid, sign message */
 187         int (*setup_request)(struct cifs_ses *, struct kvec *, unsigned int,
 188                              struct mid_q_entry **);
 189         /* setup async request: allocate mid, sign message */
 190         int (*setup_async_request)(struct TCP_Server_Info *, struct kvec *,
 191                                    unsigned int, struct mid_q_entry **);
 192         /* check response: verify signature, map error */
 193         int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
 194                              bool);
 195         void (*add_credits)(struct TCP_Server_Info *, const unsigned int,
 196                             const int);
 197         void (*set_credits)(struct TCP_Server_Info *, const int);
 198         int * (*get_credits_field)(struct TCP_Server_Info *, const int);
 199         unsigned int (*get_credits)(struct mid_q_entry *);
 200         __u64 (*get_next_mid)(struct TCP_Server_Info *);
 201         /* data offset from read response message */
 202         unsigned int (*read_data_offset)(char *);
 203         /* data length from read response message */
 204         unsigned int (*read_data_length)(char *);
 205         /* map smb to linux error */
 206         int (*map_error)(char *, bool);
 207         /* find mid corresponding to the response message */
 208         struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
 209         void (*dump_detail)(void *);
 210         void (*clear_stats)(struct cifs_tcon *);
 211         void (*print_stats)(struct seq_file *m, struct cifs_tcon *);
 212         /* verify the message */
 213         int (*check_message)(char *, unsigned int);
 214         bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
 215         /* process transaction2 response */
 216         bool (*check_trans2)(struct mid_q_entry *, struct TCP_Server_Info *,
 217                              char *, int);
 218         /* check if we need to negotiate */
 219         bool (*need_neg)(struct TCP_Server_Info *);
 220         /* negotiate to the server */
 221         int (*negotiate)(const unsigned int, struct cifs_ses *);
 222         /* set negotiated write size */
 223         unsigned int (*negotiate_wsize)(struct cifs_tcon *, struct smb_vol *);
 224         /* set negotiated read size */
 225         unsigned int (*negotiate_rsize)(struct cifs_tcon *, struct smb_vol *);
 226         /* setup smb sessionn */
 227         int (*sess_setup)(const unsigned int, struct cifs_ses *,
 228                           const struct nls_table *);
 229         /* close smb session */
 230         int (*logoff)(const unsigned int, struct cifs_ses *);
 231         /* connect to a server share */
 232         int (*tree_connect)(const unsigned int, struct cifs_ses *, const char *,
 233                             struct cifs_tcon *, const struct nls_table *);
 234         /* close tree connecion */
 235         int (*tree_disconnect)(const unsigned int, struct cifs_tcon *);
 236         /* get DFS referrals */
 237         int (*get_dfs_refer)(const unsigned int, struct cifs_ses *,
 238                              const char *, struct dfs_info3_param **,
 239                              unsigned int *, const struct nls_table *, int);
 240         /* informational QFS call */
 241         void (*qfs_tcon)(const unsigned int, struct cifs_tcon *);
 242         /* check if a path is accessible or not */
 243         int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
 244                                   struct cifs_sb_info *, const char *);
 245         /* query path data from the server */
 246         int (*query_path_info)(const unsigned int, struct cifs_tcon *,
 247                                struct cifs_sb_info *, const char *,
 248                                FILE_ALL_INFO *, bool *);
 249         /* query file data from the server */
 250         int (*query_file_info)(const unsigned int, struct cifs_tcon *,
 251                                struct cifs_fid *, FILE_ALL_INFO *);
 252         /* get server index number */
 253         int (*get_srv_inum)(const unsigned int, struct cifs_tcon *,
 254                             struct cifs_sb_info *, const char *,
 255                             u64 *uniqueid, FILE_ALL_INFO *);
 256         /* set size by path */
 257         int (*set_path_size)(const unsigned int, struct cifs_tcon *,
 258                              const char *, __u64, struct cifs_sb_info *, bool);
 259         /* set size by file handle */
 260         int (*set_file_size)(const unsigned int, struct cifs_tcon *,
 261                              struct cifsFileInfo *, __u64, bool);
 262         /* set attributes */
 263         int (*set_file_info)(struct inode *, const char *, FILE_BASIC_INFO *,
 264                              const unsigned int);
 265         /* build a full path to the root of the mount */
 266         char * (*build_path_to_root)(struct smb_vol *, struct cifs_sb_info *,
 267                                      struct cifs_tcon *);
 268         /* check if we can send an echo or nor */
 269         bool (*can_echo)(struct TCP_Server_Info *);
 270         /* send echo request */
 271         int (*echo)(struct TCP_Server_Info *);
 272         /* create directory */
 273         int (*mkdir)(const unsigned int, struct cifs_tcon *, const char *,
 274                      struct cifs_sb_info *);
 275         /* set info on created directory */
 276         void (*mkdir_setinfo)(struct inode *, const char *,
 277                               struct cifs_sb_info *, struct cifs_tcon *,
 278                               const unsigned int);
 279         /* remove directory */
 280         int (*rmdir)(const unsigned int, struct cifs_tcon *, const char *,
 281                      struct cifs_sb_info *);
 282         /* unlink file */
 283         int (*unlink)(const unsigned int, struct cifs_tcon *, const char *,
 284                       struct cifs_sb_info *);
 285         /* open, rename and delete file */
 286         int (*rename_pending_delete)(const char *, struct dentry *,
 287                                      const unsigned int);
 288         /* send rename request */
 289         int (*rename)(const unsigned int, struct cifs_tcon *, const char *,
 290                       const char *, struct cifs_sb_info *);
 291         /* send create hardlink request */
 292         int (*create_hardlink)(const unsigned int, struct cifs_tcon *,
 293                                const char *, const char *,
 294                                struct cifs_sb_info *);
 295         /* open a file for non-posix mounts */
 296         int (*open)(const unsigned int, struct cifs_tcon *, const char *, int,
 297                     int, int, struct cifs_fid *, __u32 *, FILE_ALL_INFO *,
 298                     struct cifs_sb_info *);
 299         /* set fid protocol-specific info */
 300         void (*set_fid)(struct cifsFileInfo *, struct cifs_fid *, __u32);
 301         /* close a file */
 302         int (*close)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
 303         /* send a flush request to the server */
 304         int (*flush)(const unsigned int, struct cifs_tcon *, struct cifs_fid *);
 305         /* async read from the server */
 306         int (*async_readv)(struct cifs_readdata *);
 307         /* async write to the server */
 308         int (*async_writev)(struct cifs_writedata *);
 309         /* sync read from the server */
 310         int (*sync_read)(const unsigned int, struct cifsFileInfo *,
 311                          struct cifs_io_parms *, unsigned int *, char **,
 312                          int *);
 313         /* sync write to the server */
 314         int (*sync_write)(const unsigned int, struct cifsFileInfo *,
 315                           struct cifs_io_parms *, unsigned int *, struct kvec *,
 316                           unsigned long);
 317         /* open dir, start readdir */
 318         int (*query_dir_first)(const unsigned int, struct cifs_tcon *,
 319                                const char *, struct cifs_sb_info *,
 320                                struct cifs_fid *, __u16,
 321                                struct cifs_search_info *);
 322         /* continue readdir */
 323         int (*query_dir_next)(const unsigned int, struct cifs_tcon *,
 324                               struct cifs_fid *,
 325                               __u16, struct cifs_search_info *srch_inf);
 326         /* close dir */
 327         int (*close_dir)(const unsigned int, struct cifs_tcon *,
 328                          struct cifs_fid *);
 329         /* calculate a size of SMB message */
 330         unsigned int (*calc_smb_size)(void *);
 331         /* check for STATUS_PENDING and process it in a positive case */
 332         bool (*is_status_pending)(char *, struct TCP_Server_Info *, int);
 333 };
 334
 335 struct smb_version_values {
 336         char            *version_string;
 337         __u32           large_lock_type;
 338         __u32           exclusive_lock_type;
 339         __u32           shared_lock_type;
 340         __u32           unlock_lock_type;
 341         size_t          header_size;
 342         size_t          max_header_size;
 343         size_t          read_rsp_size;
 344         __le16          lock_cmd;
 345         unsigned int    cap_unix;
 346         unsigned int    cap_nt_find;
 347         unsigned int    cap_large_files;
 348 };
 349
 350 #define HEADER_SIZE(server) (server->vals->header_size)
 351 #define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
 352
 353 struct smb_vol {
 354         char *username;
 355         char *password;
 356         char *domainname;
 357         char *UNC;
 358         char *UNCip;
 359         char *iocharset;  /* local code page for mapping to and from Unicode */
 360         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
 361         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
 362         uid_t cred_uid;
 363         uid_t linux_uid;
 364         gid_t linux_gid;
 365         uid_t backupuid;
 366         gid_t backupgid;
 367         umode_t file_mode;
 368         umode_t dir_mode;
 369         unsigned secFlg;
 370         bool retry:1;
 371         bool intr:1;
 372         bool setuids:1;
 373         bool override_uid:1;
 374         bool override_gid:1;
 375         bool dynperm:1;
 376         bool noperm:1;
 377         bool no_psx_acl:1; /* set if posix acl support should be disabled */
 378         bool cifs_acl:1;
 379         bool backupuid_specified; /* mount option  backupuid  is specified */
 380         bool backupgid_specified; /* mount option  backupgid  is specified */
 381         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
 382         bool server_ino:1; /* use inode numbers from server ie UniqueId */
 383         bool direct_io:1;
 384         bool strict_io:1; /* strict cache behavior */
 385         bool remap:1;      /* set to remap seven reserved chars in filenames */
 386         bool posix_paths:1; /* unset to not ask for posix pathnames. */
 387         bool no_linux_ext:1;
 388         bool sfu_emul:1;
 389         bool nullauth:1;   /* attempt to authenticate with null user */
 390         bool nocase:1;     /* request case insensitive filenames */
 391         bool nobrl:1;      /* disable sending byte range locks to srv */
 392         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
 393         bool seal:1;       /* request transport encryption on share */
 394         bool nodfs:1;      /* Do not request DFS, even if available */
 395         bool local_lease:1; /* check leases only on local system, not remote */
 396         bool noblocksnd:1;
 397         bool noautotune:1;
 398         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 399         bool fsc:1;     /* enable fscache */
 400         bool mfsymlinks:1; /* use Minshall+French Symlinks */
 401         bool multiuser:1;
 402         bool rwpidforward:1; /* pid forward for read/write operations */
 403         unsigned int rsize;
 404         unsigned int wsize;
 405         bool sockopt_tcp_nodelay:1;
 406         unsigned short int port;
 407         unsigned long actimeo; /* attribute cache timeout (jiffies) */
 408         struct smb_version_operations *ops;
 409         struct smb_version_values *vals;
 410         char *prepath;
 411         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
 412         struct nls_table *local_nls;
 413 };
 414
 415 #define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
 416                          CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
 417                          CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
 418                          CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
 419                          CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
 420                          CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
 421                          CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
 422                          CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
 423                          CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
 424                          CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
 425
 426 #define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
 427                       MS_NODEV | MS_SYNCHRONOUS)
 428
 429 struct cifs_mnt_data {
 430         struct cifs_sb_info *cifs_sb;
 431         struct smb_vol *vol;
 432         int flags;
 433 };
 434
 435 static inline unsigned int
 436 get_rfc1002_length(void *buf)
 437 {
 438         return be32_to_cpu(*((__be32 *)buf));
 439 }
 440
 441 static inline void
 442 inc_rfc1001_len(void *buf, int count)
 443 {
 444         be32_add_cpu((__be32 *)buf, count);
 445 }
 446
 447 struct TCP_Server_Info {
 448         struct list_head tcp_ses_list;
 449         struct list_head smb_ses_list;
 450         int srv_count; /* reference counter */
 451         /* 15 character server name + 0x20 16th byte indicating type = srv */
 452         char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
 453         struct smb_version_operations   *ops;
 454         struct smb_version_values       *vals;
 455         enum statusEnum tcpStatus; /* what we think the status is */
 456         char *hostname; /* hostname portion of UNC string */
 457         struct socket *ssocket;
 458         struct sockaddr_storage dstaddr;
 459         struct sockaddr_storage srcaddr; /* locally bind to this IP */
 460 #ifdef CONFIG_NET_NS
 461         struct net *net;
 462 #endif
 463         wait_queue_head_t response_q;
 464         wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
 465         struct list_head pending_mid_q;
 466         bool noblocksnd;                /* use blocking sendmsg */
 467         bool noautotune;                /* do not autotune send buf sizes */
 468         bool tcp_nodelay;
 469         int credits;  /* send no more requests at once */
 470         unsigned int in_flight;  /* number of requests on the wire to server */
 471         spinlock_t req_lock;  /* protect the two values above */
 472         struct mutex srv_mutex;
 473         struct task_struct *tsk;
 474         char server_GUID[16];
 475         __u16 sec_mode;
 476         bool session_estab; /* mark when very first sess is established */
 477 #ifdef CONFIG_CIFS_SMB2
 478         int echo_credits;  /* echo reserved slots */
 479         int oplock_credits;  /* oplock break reserved slots */
 480         bool echoes:1; /* enable echoes */
 481 #endif
 482         u16 dialect; /* dialect index that server chose */
 483         enum securityEnum secType;
 484         bool oplocks:1; /* enable oplocks */
 485         unsigned int maxReq;    /* Clients should submit no more */
 486         /* than maxReq distinct unanswered SMBs to the server when using  */
 487         /* multiplexed reads or writes */
 488         unsigned int maxBuf;    /* maxBuf specifies the maximum */
 489         /* message size the server can send or receive for non-raw SMBs */
 490         /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
 491         /* when socket is setup (and during reconnect) before NegProt sent */
 492         unsigned int max_rw;    /* maxRw specifies the maximum */
 493         /* message size the server can send or receive for */
 494         /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
 495         unsigned int max_vcs;   /* maximum number of smb sessions, at least
 496                                    those that can be specified uniquely with
 497                                    vcnumbers */
 498         unsigned int capabilities; /* selective disabling of caps by smb sess */
 499         int timeAdj;  /* Adjust for difference in server time zone in sec */
 500         __u64 CurrentMid;         /* multiplex id - rotating counter */
 501         char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
 502         /* 16th byte of RFC1001 workstation name is always null */
 503         char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
 504         __u32 sequence_number; /* for signing, protected by srv_mutex */
 505         struct session_key session_key;
 506         unsigned long lstrp; /* when we got last response from this server */
 507         struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
 508         /* extended security flavors that server supports */
 509         bool    sec_ntlmssp;            /* supports NTLMSSP */
 510         bool    sec_kerberosu2u;        /* supports U2U Kerberos */
 511         bool    sec_kerberos;           /* supports plain Kerberos */
 512         bool    sec_mskerberos;         /* supports legacy MS Kerberos */
 513         bool    large_buf;              /* is current buffer large? */
 514         struct delayed_work     echo; /* echo ping workqueue job */
 515         struct kvec *iov;       /* reusable kvec array for receives */
 516         unsigned int nr_iov;    /* number of kvecs in array */
 517         char    *smallbuf;      /* pointer to current "small" buffer */
 518         char    *bigbuf;        /* pointer to current "big" buffer */
 519         unsigned int total_read; /* total amount of data read in this pass */
 520 #ifdef CONFIG_CIFS_FSCACHE
 521         struct fscache_cookie   *fscache; /* client index cache cookie */
 522 #endif
 523 #ifdef CONFIG_CIFS_STATS2
 524         atomic_t in_send; /* requests trying to send */
 525         atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
 526 #endif
 527 #ifdef CONFIG_CIFS_SMB2
 528         unsigned int    max_read;
 529         unsigned int    max_write;
 530 #endif /* CONFIG_CIFS_SMB2 */
 531 };
 532
 533 static inline unsigned int
 534 in_flight(struct TCP_Server_Info *server)
 535 {
 536         unsigned int num;
 537         spin_lock(&server->req_lock);
 538         num = server->in_flight;
 539         spin_unlock(&server->req_lock);
 540         return num;
 541 }
 542
 543 static inline bool
 544 has_credits(struct TCP_Server_Info *server, int *credits)
 545 {
 546         int num;
 547         spin_lock(&server->req_lock);
 548         num = *credits;
 549         spin_unlock(&server->req_lock);
 550         return num > 0;
 551 }
 552
 553 static inline void
 554 add_credits(struct TCP_Server_Info *server, const unsigned int add,
 555             const int optype)
 556 {
 557         server->ops->add_credits(server, add, optype);
 558 }
 559
 560 static inline void
 561 set_credits(struct TCP_Server_Info *server, const int val)
 562 {
 563         server->ops->set_credits(server, val);
 564 }
 565
 566 static inline __u64
 567 get_next_mid(struct TCP_Server_Info *server)
 568 {
 569         return server->ops->get_next_mid(server);
 570 }
 571
 572 /*
 573  * When the server supports very large reads and writes via POSIX extensions,
 574  * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
 575  * including the RFC1001 length.
 576  *
 577  * Note that this might make for "interesting" allocation problems during
 578  * writeback however as we have to allocate an array of pointers for the
 579  * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
 580  *
 581  * For reads, there is a similar problem as we need to allocate an array
 582  * of kvecs to handle the receive, though that should only need to be done
 583  * once.
 584  */
 585 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
 586 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
 587
 588 /*
 589  * When the server doesn't allow large posix writes, only allow a rsize/wsize
 590  * of 2^17-1 minus the size of the call header. That allows for a read or
 591  * write up to the maximum size described by RFC1002.
 592  */
 593 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
 594 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
 595
 596 /*
 597  * The default wsize is 1M. find_get_pages seems to return a maximum of 256
 598  * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
 599  * a single wsize request with a single call.
 600  */
 601 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
 602
 603 /*
 604  * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
 605  * those values when posix extensions aren't in force. In actuality here, we
 606  * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
 607  * to be ok with the extra byte even though Windows doesn't send writes that
 608  * are that large.
 609  *
 610  * Citation:
 611  *
 612  * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
 613  */
 614 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
 615 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
 616
 617 /*
 618  * On hosts with high memory, we can't currently support wsize/rsize that are
 619  * larger than we can kmap at once. Cap the rsize/wsize at
 620  * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
 621  * larger than that anyway.
 622  */
 623 #ifdef CONFIG_HIGHMEM
 624 #define CIFS_KMAP_SIZE_LIMIT   (LAST_PKMAP * PAGE_CACHE_SIZE)
 625 #else /* CONFIG_HIGHMEM */
 626 #define CIFS_KMAP_SIZE_LIMIT   (1<<24)
 627 #endif /* CONFIG_HIGHMEM */
 628
 629 #ifdef CONFIG_HIGHMEM
 630 /*
 631  * On arches that have high memory, kmap address space is limited. By
 632  * serializing the kmap operations on those arches, we ensure that we don't
 633  * end up with a bunch of threads in writeback with partially mapped page
 634  * arrays, stuck waiting for kmap to come back. That situation prevents
 635  * progress and can deadlock.
 636  */
 637
 638 extern struct mutex cifs_kmap_mutex;
 639
 640 static inline void
 641 cifs_kmap_lock(void)
 642 {
 643         mutex_lock(&cifs_kmap_mutex);
 644 }
 645
 646 static inline void
 647 cifs_kmap_unlock(void)
 648 {
 649         mutex_unlock(&cifs_kmap_mutex);
 650 }
 651 #else /* !CONFIG_HIGHMEM */
 652 #define cifs_kmap_lock() do { ; } while (0)
 653 #define cifs_kmap_unlock() do { ; } while (0)
 654 #endif /* CONFIG_HIGHMEM */
 655
 656 /*
 657  * Macros to allow the TCP_Server_Info->net field and related code to drop out
 658  * when CONFIG_NET_NS isn't set.
 659  */
 660
 661 #ifdef CONFIG_NET_NS
 662
 663 static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
 664 {
 665         return srv->net;
 666 }
 667
 668 static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
 669 {
 670         srv->net = net;
 671 }
 672
 673 #else
 674
 675 static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
 676 {
 677         return &init_net;
 678 }
 679
 680 static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
 681 {
 682 }
 683
 684 #endif
 685
 686 /*
 687  * Session structure.  One of these for each uid session with a particular host
 688  */
 689 struct cifs_ses {
 690         struct list_head smb_ses_list;
 691         struct list_head tcon_list;
 692         struct mutex session_mutex;
 693         struct TCP_Server_Info *server; /* pointer to server info */
 694         int ses_count;          /* reference counter */
 695         enum statusEnum status;
 696         unsigned overrideSecFlg;  /* if non-zero override global sec flags */
 697         __u16 ipc_tid;          /* special tid for connection to IPC share */
 698         __u16 flags;
 699         __u16 vcnum;
 700         char *serverOS;         /* name of operating system underlying server */
 701         char *serverNOS;        /* name of network operating system of server */
 702         char *serverDomain;     /* security realm of server */
 703         __u64 Suid;             /* remote smb uid  */
 704         uid_t linux_uid;        /* overriding owner of files on the mount */
 705         uid_t cred_uid;         /* owner of credentials */
 706         unsigned int capabilities;
 707         char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
 708                                 TCP names - will ipv6 and sctp addresses fit? */
 709         char *user_name;        /* must not be null except during init of sess
 710                                    and after mount option parsing we fill it */
 711         char *domainName;
 712         char *password;
 713         struct session_key auth_key;
 714         struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
 715         bool need_reconnect:1; /* connection reset, uid now invalid */
 716 #ifdef CONFIG_CIFS_SMB2
 717         __u16 session_flags;
 718 #endif /* CONFIG_CIFS_SMB2 */
 719 };
 720 /* no more than one of the following three session flags may be set */
 721 #define CIFS_SES_NT4 1
 722 #define CIFS_SES_OS2 2
 723 #define CIFS_SES_W9X 4
 724 /* following flag is set for old servers such as OS2 (and Win95?)
 725    which do not negotiate NTLM or POSIX dialects, but instead
 726    negotiate one of the older LANMAN dialects */
 727 #define CIFS_SES_LANMAN 8
 728
 729 static inline bool
 730 cap_unix(struct cifs_ses *ses)
 731 {
 732         return ses->server->vals->cap_unix & ses->capabilities;
 733 }
 734
 735 /*
 736  * there is one of these for each connection to a resource on a particular
 737  * session
 738  */
 739 struct cifs_tcon {
 740         struct list_head tcon_list;
 741         int tc_count;
 742         struct list_head openFileList;
 743         struct cifs_ses *ses;   /* pointer to session associated with */
 744         char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
 745         char *nativeFileSystem;
 746         char *password;         /* for share-level security */
 747         __u32 tid;              /* The 4 byte tree id */
 748         __u16 Flags;            /* optional support bits */
 749         enum statusEnum tidStatus;
 750 #ifdef CONFIG_CIFS_STATS
 751         atomic_t num_smbs_sent;
 752         union {
 753                 struct {
 754                         atomic_t num_writes;
 755                         atomic_t num_reads;
 756                         atomic_t num_flushes;
 757                         atomic_t num_oplock_brks;
 758                         atomic_t num_opens;
 759                         atomic_t num_closes;
 760                         atomic_t num_deletes;
 761                         atomic_t num_mkdirs;
 762                         atomic_t num_posixopens;
 763                         atomic_t num_posixmkdirs;
 764                         atomic_t num_rmdirs;
 765                         atomic_t num_renames;
 766                         atomic_t num_t2renames;
 767                         atomic_t num_ffirst;
 768                         atomic_t num_fnext;
 769                         atomic_t num_fclose;
 770                         atomic_t num_hardlinks;
 771                         atomic_t num_symlinks;
 772                         atomic_t num_locks;
 773                         atomic_t num_acl_get;
 774                         atomic_t num_acl_set;
 775                 } cifs_stats;
 776 #ifdef CONFIG_CIFS_SMB2
 777                 struct {
 778                         atomic_t smb2_com_sent[NUMBER_OF_SMB2_COMMANDS];
 779                         atomic_t smb2_com_failed[NUMBER_OF_SMB2_COMMANDS];
 780                 } smb2_stats;
 781 #endif /* CONFIG_CIFS_SMB2 */
 782         } stats;
 783 #ifdef CONFIG_CIFS_STATS2
 784         unsigned long long time_writes;
 785         unsigned long long time_reads;
 786         unsigned long long time_opens;
 787         unsigned long long time_deletes;
 788         unsigned long long time_closes;
 789         unsigned long long time_mkdirs;
 790         unsigned long long time_rmdirs;
 791         unsigned long long time_renames;
 792         unsigned long long time_t2renames;
 793         unsigned long long time_ffirst;
 794         unsigned long long time_fnext;
 795         unsigned long long time_fclose;
 796 #endif /* CONFIG_CIFS_STATS2 */
 797         __u64    bytes_read;
 798         __u64    bytes_written;
 799         spinlock_t stat_lock;
 800 #endif /* CONFIG_CIFS_STATS */
 801         FILE_SYSTEM_DEVICE_INFO fsDevInfo;
 802         FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
 803         FILE_SYSTEM_UNIX_INFO fsUnixInfo;
 804         bool ipc:1;             /* set if connection to IPC$ eg for RPC/PIPES */
 805         bool retry:1;
 806         bool nocase:1;
 807         bool seal:1;      /* transport encryption for this mounted share */
 808         bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
 809                                 for this mount even if server would support */
 810         bool local_lease:1; /* check leases (only) on local system not remote */
 811         bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
 812         bool need_reconnect:1; /* connection reset, tid now invalid */
 813 #ifdef CONFIG_CIFS_SMB2
 814         bool print:1;           /* set if connection to printer share */
 815         bool bad_network_name:1; /* set if ret status STATUS_BAD_NETWORK_NAME */
 816         __u32 capabilities;
 817         __u32 share_flags;
 818         __u32 maximal_access;
 819         __u32 vol_serial_number;
 820         __le64 vol_create_time;
 821 #endif /* CONFIG_CIFS_SMB2 */
 822 #ifdef CONFIG_CIFS_FSCACHE
 823         u64 resource_id;                /* server resource id */
 824         struct fscache_cookie *fscache; /* cookie for share */
 825 #endif
 826         /* BB add field for back pointer to sb struct(s)? */
 827 };
 828
 829 /*
 830  * This is a refcounted and timestamped container for a tcon pointer. The
 831  * container holds a tcon reference. It is considered safe to free one of
 832  * these when the tl_count goes to 0. The tl_time is the time of the last
 833  * "get" on the container.
 834  */
 835 struct tcon_link {
 836         struct rb_node          tl_rbnode;
 837         uid_t                   tl_uid;
 838         unsigned long           tl_flags;
 839 #define TCON_LINK_MASTER        0
 840 #define TCON_LINK_PENDING       1
 841 #define TCON_LINK_IN_TREE       2
 842         unsigned long           tl_time;
 843         atomic_t                tl_count;
 844         struct cifs_tcon        *tl_tcon;
 845 };
 846
 847 extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
 848
 849 static inline struct cifs_tcon *
 850 tlink_tcon(struct tcon_link *tlink)
 851 {
 852         return tlink->tl_tcon;
 853 }
 854
 855 extern void cifs_put_tlink(struct tcon_link *tlink);
 856
 857 static inline struct tcon_link *
 858 cifs_get_tlink(struct tcon_link *tlink)
 859 {
 860         if (tlink && !IS_ERR(tlink))
 861                 atomic_inc(&tlink->tl_count);
 862         return tlink;
 863 }
 864
 865 /* This function is always expected to succeed */
 866 extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
 867
 868 /*
 869  * This info hangs off the cifsFileInfo structure, pointed to by llist.
 870  * This is used to track byte stream locks on the file
 871  */
 872 struct cifsLockInfo {
 873         struct list_head llist; /* pointer to next cifsLockInfo */
 874         struct list_head blist; /* pointer to locks blocked on this */
 875         wait_queue_head_t block_q;
 876         __u64 offset;
 877         __u64 length;
 878         __u32 pid;
 879         __u32 type;
 880 };
 881
 882 /*
 883  * One of these for each open instance of a file
 884  */
 885 struct cifs_search_info {
 886         loff_t index_of_last_entry;
 887         __u16 entries_in_buffer;
 888         __u16 info_level;
 889         __u32 resume_key;
 890         char *ntwrk_buf_start;
 891         char *srch_entries_start;
 892         char *last_entry;
 893         const char *presume_name;
 894         unsigned int resume_name_len;
 895         bool endOfSearch:1;
 896         bool emptyDir:1;
 897         bool unicode:1;
 898         bool smallBuf:1; /* so we know which buf_release function to call */
 899 };
 900
 901 struct cifs_fid {
 902         __u16 netfid;
 903 #ifdef CONFIG_CIFS_SMB2
 904         __u64 persistent_fid;   /* persist file id for smb2 */
 905         __u64 volatile_fid;     /* volatile file id for smb2 */
 906 #endif
 907 };
 908
 909 struct cifsFileInfo {
 910         struct list_head tlist; /* pointer to next fid owned by tcon */
 911         struct list_head flist; /* next fid (file instance) for this inode */
 912         struct list_head llist; /*
 913                                  * brlocks held by this fid, protected by
 914                                  * lock_mutex from cifsInodeInfo structure
 915                                  */
 916         unsigned int uid;       /* allows finding which FileInfo structure */
 917         __u32 pid;              /* process id who opened file */
 918         struct cifs_fid fid;    /* file id from remote */
 919         /* BB add lock scope info here if needed */ ;
 920         /* lock scope id (0 if none) */
 921         struct dentry *dentry;
 922         unsigned int f_flags;
 923         struct tcon_link *tlink;
 924         bool invalidHandle:1;   /* file closed via session abend */
 925         bool oplock_break_cancelled:1;
 926         int count;              /* refcount protected by cifs_file_list_lock */
 927         struct mutex fh_mutex; /* prevents reopen race after dead ses*/
 928         struct cifs_search_info srch_inf;
 929         struct work_struct oplock_break; /* work for oplock breaks */
 930 };
 931
 932 struct cifs_io_parms {
 933         __u16 netfid;
 934 #ifdef CONFIG_CIFS_SMB2
 935         __u64 persistent_fid;   /* persist file id for smb2 */
 936         __u64 volatile_fid;     /* volatile file id for smb2 */
 937 #endif
 938         __u32 pid;
 939         __u64 offset;
 940         unsigned int length;
 941         struct cifs_tcon *tcon;
 942 };
 943
 944 struct cifs_readdata;
 945
 946 /* asynchronous read support */
 947 struct cifs_readdata {
 948         struct kref                     refcount;
 949         struct list_head                list;
 950         struct completion               done;
 951         struct cifsFileInfo             *cfile;
 952         struct address_space            *mapping;
 953         __u64                           offset;
 954         unsigned int                    bytes;
 955         pid_t                           pid;
 956         int                             result;
 957         struct list_head                pages;
 958         struct work_struct              work;
 959         int (*marshal_iov) (struct cifs_readdata *rdata,
 960                             unsigned int remaining);
 961         unsigned int                    nr_iov;
 962         struct kvec                     iov[1];
 963 };
 964
 965 struct cifs_writedata;
 966
 967 /* asynchronous write support */
 968 struct cifs_writedata {
 969         struct kref                     refcount;
 970         struct list_head                list;
 971         struct completion               done;
 972         enum writeback_sync_modes       sync_mode;
 973         struct work_struct              work;
 974         struct cifsFileInfo             *cfile;
 975         __u64                           offset;
 976         pid_t                           pid;
 977         unsigned int                    bytes;
 978         int                             result;
 979         void (*marshal_iov) (struct kvec *iov,
 980                              struct cifs_writedata *wdata);
 981         unsigned int                    nr_pages;
 982         struct page                     *pages[1];
 983 };
 984
 985 /*
 986  * Take a reference on the file private data. Must be called with
 987  * cifs_file_list_lock held.
 988  */
 989 static inline void
 990 cifsFileInfo_get_locked(struct cifsFileInfo *cifs_file)
 991 {
 992         ++cifs_file->count;
 993 }
 994
 995 struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file);
 996 void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
 997
 998 /*
 999  * One of these for each file inode
1000  */
1001
1002 struct cifsInodeInfo {
1003         bool can_cache_brlcks;
1004         struct mutex lock_mutex;        /*
1005                                          * protect the field above and llist
1006                                          * from every cifsFileInfo structure
1007                                          * from openFileList
1008                                          */
1009         /* BB add in lists for dirty pages i.e. write caching info for oplock */
1010         struct list_head openFileList;
1011         __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
1012         bool clientCanCacheRead;        /* read oplock */
1013         bool clientCanCacheAll;         /* read and writebehind oplock */
1014         bool delete_pending;            /* DELETE_ON_CLOSE is set */
1015         bool invalid_mapping;           /* pagecache is invalid */
1016         unsigned long time;             /* jiffies of last update of inode */
1017         u64  server_eof;                /* current file size on server -- protected by i_lock */
1018         u64  uniqueid;                  /* server inode number */
1019         u64  createtime;                /* creation time on server */
1020 #ifdef CONFIG_CIFS_FSCACHE
1021         struct fscache_cookie *fscache;
1022 #endif
1023         struct inode vfs_inode;
1024 };
1025
1026 static inline struct cifsInodeInfo *
1027 CIFS_I(struct inode *inode)
1028 {
1029         return container_of(inode, struct cifsInodeInfo, vfs_inode);
1030 }
1031
1032 static inline struct cifs_sb_info *
1033 CIFS_SB(struct super_block *sb)
1034 {
1035         return sb->s_fs_info;
1036 }
1037
1038 static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
1039 {
1040         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
1041                 return '/';
1042         else
1043                 return '\\';
1044 }
1045
1046 static inline void
1047 convert_delimiter(char *path, char delim)
1048 {
1049         int i;
1050         char old_delim;
1051
1052         if (path == NULL)
1053                 return;
1054
1055         if (delim == '/')
1056                 old_delim = '\\';
1057         else
1058                 old_delim = '/';
1059
1060         for (i = 0; path[i] != '\0'; i++) {
1061                 if (path[i] == old_delim)
1062                         path[i] = delim;
1063         }
1064 }
1065
1066 static inline char *
1067 build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
1068                    struct cifs_tcon *tcon)
1069 {
1070         if (!vol->ops->build_path_to_root)
1071                 return NULL;
1072         return vol->ops->build_path_to_root(vol, cifs_sb, tcon);
1073 }
1074
1075 #ifdef CONFIG_CIFS_STATS
1076 #define cifs_stats_inc atomic_inc
1077
1078 static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
1079                                             unsigned int bytes)
1080 {
1081         if (bytes) {
1082                 spin_lock(&tcon->stat_lock);
1083                 tcon->bytes_written += bytes;
1084                 spin_unlock(&tcon->stat_lock);
1085         }
1086 }
1087
1088 static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
1089                                          unsigned int bytes)
1090 {
1091         spin_lock(&tcon->stat_lock);
1092         tcon->bytes_read += bytes;
1093         spin_unlock(&tcon->stat_lock);
1094 }
1095 #else
1096
1097 #define  cifs_stats_inc(field) do {} while (0)
1098 #define  cifs_stats_bytes_written(tcon, bytes) do {} while (0)
1099 #define  cifs_stats_bytes_read(tcon, bytes) do {} while (0)
1100
1101 #endif
1102
1103
1104 /*
1105  * This is the prototype for the mid receive function. This function is for
1106  * receiving the rest of the SMB frame, starting with the WordCount (which is
1107  * just after the MID in struct smb_hdr). Note:
1108  *
1109  * - This will be called by cifsd, with no locks held.
1110  * - The mid will still be on the pending_mid_q.
1111  * - mid->resp_buf will point to the current buffer.
1112  *
1113  * Returns zero on a successful receive, or an error. The receive state in
1114  * the TCP_Server_Info will also be updated.
1115  */
1116 typedef int (mid_receive_t)(struct TCP_Server_Info *server,
1117                             struct mid_q_entry *mid);
1118
1119 /*
1120  * This is the prototype for the mid callback function. This is called once the
1121  * mid has been received off of the socket. When creating one, take special
1122  * care to avoid deadlocks. Things to bear in mind:
1123  *
1124  * - it will be called by cifsd, with no locks held
1125  * - the mid will be removed from any lists
1126  */
1127 typedef void (mid_callback_t)(struct mid_q_entry *mid);
1128
1129 /* one of these for every pending CIFS request to the server */
1130 struct mid_q_entry {
1131         struct list_head qhead; /* mids waiting on reply from this server */
1132         struct TCP_Server_Info *server; /* server corresponding to this mid */
1133         __u64 mid;              /* multiplex id */
1134         __u32 pid;              /* process id */
1135         __u32 sequence_number;  /* for CIFS signing */
1136         unsigned long when_alloc;  /* when mid was created */
1137 #ifdef CONFIG_CIFS_STATS2
1138         unsigned long when_sent; /* time when smb send finished */
1139         unsigned long when_received; /* when demux complete (taken off wire) */
1140 #endif
1141         mid_receive_t *receive; /* call receive callback */
1142         mid_callback_t *callback; /* call completion callback */
1143         void *callback_data;      /* general purpose pointer for callback */
1144         void *resp_buf;         /* pointer to received SMB header */
1145         int mid_state;  /* wish this were enum but can not pass to wait_event */
1146         __le16 command;         /* smb command code */
1147         bool large_buf:1;       /* if valid response, is pointer to large buf */
1148         bool multiRsp:1;        /* multiple trans2 responses for one request  */
1149         bool multiEnd:1;        /* both received */
1150 };
1151
1152 /*      Make code in transport.c a little cleaner by moving
1153         update of optional stats into function below */
1154 #ifdef CONFIG_CIFS_STATS2
1155
1156 static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1157 {
1158         atomic_inc(&server->in_send);
1159 }
1160
1161 static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1162 {
1163         atomic_dec(&server->in_send);
1164 }
1165
1166 static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1167 {
1168         atomic_inc(&server->num_waiters);
1169 }
1170
1171 static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1172 {
1173         atomic_dec(&server->num_waiters);
1174 }
1175
1176 static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1177 {
1178         mid->when_sent = jiffies;
1179 }
1180 #else
1181 static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
1182 {
1183 }
1184 static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
1185 {
1186 }
1187
1188 static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
1189 {
1190 }
1191
1192 static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
1193 {
1194 }
1195
1196 static inline void cifs_save_when_sent(struct mid_q_entry *mid)
1197 {
1198 }
1199 #endif
1200
1201 /* for pending dnotify requests */
1202 struct dir_notify_req {
1203         struct list_head lhead;
1204         __le16 Pid;
1205         __le16 PidHigh;
1206         __u16 Mid;
1207         __u16 Tid;
1208         __u16 Uid;
1209         __u16 netfid;
1210         __u32 filter; /* CompletionFilter (for multishot) */
1211         int multishot;
1212         struct file *pfile;
1213 };
1214
1215 struct dfs_info3_param {
1216         int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
1217         int path_consumed;
1218         int server_type;
1219         int ref_flag;
1220         char *path_name;
1221         char *node_name;
1222 };
1223
1224 /*
1225  * common struct for holding inode info when searching for or updating an
1226  * inode with new info
1227  */
1228
1229 #define CIFS_FATTR_DFS_REFERRAL         0x1
1230 #define CIFS_FATTR_DELETE_PENDING       0x2
1231 #define CIFS_FATTR_NEED_REVAL           0x4
1232 #define CIFS_FATTR_INO_COLLISION        0x8
1233
1234 struct cifs_fattr {
1235         u32             cf_flags;
1236         u32             cf_cifsattrs;
1237         u64             cf_uniqueid;
1238         u64             cf_eof;
1239         u64             cf_bytes;
1240         u64             cf_createtime;
1241         uid_t           cf_uid;
1242         gid_t           cf_gid;
1243         umode_t         cf_mode;
1244         dev_t           cf_rdev;
1245         unsigned int    cf_nlink;
1246         unsigned int    cf_dtype;
1247         struct timespec cf_atime;
1248         struct timespec cf_mtime;
1249         struct timespec cf_ctime;
1250 };
1251
1252 static inline void free_dfs_info_param(struct dfs_info3_param *param)
1253 {
1254         if (param) {
1255                 kfree(param->path_name);
1256                 kfree(param->node_name);
1257                 kfree(param);
1258         }
1259 }
1260
1261 static inline void free_dfs_info_array(struct dfs_info3_param *param,
1262                                        int number_of_items)
1263 {
1264         int i;
1265         if ((number_of_items == 0) || (param == NULL))
1266                 return;
1267         for (i = 0; i < number_of_items; i++) {
1268                 kfree(param[i].path_name);
1269                 kfree(param[i].node_name);
1270         }
1271         kfree(param);
1272 }
1273
1274 #define   MID_FREE 0
1275 #define   MID_REQUEST_ALLOCATED 1
1276 #define   MID_REQUEST_SUBMITTED 2
1277 #define   MID_RESPONSE_RECEIVED 4
1278 #define   MID_RETRY_NEEDED      8 /* session closed while this request out */
1279 #define   MID_RESPONSE_MALFORMED 0x10
1280 #define   MID_SHUTDOWN           0x20
1281
1282 /* Types of response buffer returned from SendReceive2 */
1283 #define   CIFS_NO_BUFFER        0    /* Response buffer not returned */
1284 #define   CIFS_SMALL_BUFFER     1
1285 #define   CIFS_LARGE_BUFFER     2
1286 #define   CIFS_IOVEC            4    /* array of response buffers */
1287
1288 /* Type of Request to SendReceive2 */
1289 #define   CIFS_BLOCKING_OP      1    /* operation can block */
1290 #define   CIFS_ASYNC_OP         2    /* do not wait for response */
1291 #define   CIFS_TIMEOUT_MASK 0x003    /* only one of above set in req */
1292 #define   CIFS_LOG_ERROR    0x010    /* log NT STATUS if non-zero */
1293 #define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */
1294 #define   CIFS_NO_RESP      0x040    /* no response buffer required */
1295
1296 /* Type of request operation */
1297 #define   CIFS_ECHO_OP      0x080    /* echo request */
1298 #define   CIFS_OBREAK_OP   0x0100    /* oplock break request */
1299 #define   CIFS_NEG_OP      0x0200    /* negotiate request */
1300 #define   CIFS_OP_MASK     0x0380    /* mask request type */
1301
1302 /* Security Flags: indicate type of session setup needed */
1303 #define   CIFSSEC_MAY_SIGN      0x00001
1304 #define   CIFSSEC_MAY_NTLM      0x00002
1305 #define   CIFSSEC_MAY_NTLMV2    0x00004
1306 #define   CIFSSEC_MAY_KRB5      0x00008
1307 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1308 #define   CIFSSEC_MAY_LANMAN    0x00010
1309 #define   CIFSSEC_MAY_PLNTXT    0x00020
1310 #else
1311 #define   CIFSSEC_MAY_LANMAN    0
1312 #define   CIFSSEC_MAY_PLNTXT    0
1313 #endif /* weak passwords */
1314 #define   CIFSSEC_MAY_SEAL      0x00040 /* not supported yet */
1315 #define   CIFSSEC_MAY_NTLMSSP   0x00080 /* raw ntlmssp with ntlmv2 */
1316
1317 #define   CIFSSEC_MUST_SIGN     0x01001
1318 /* note that only one of the following can be set so the
1319 result of setting MUST flags more than once will be to
1320 require use of the stronger protocol */
1321 #define   CIFSSEC_MUST_NTLM     0x02002
1322 #define   CIFSSEC_MUST_NTLMV2   0x04004
1323 #define   CIFSSEC_MUST_KRB5     0x08008
1324 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1325 #define   CIFSSEC_MUST_LANMAN   0x10010
1326 #define   CIFSSEC_MUST_PLNTXT   0x20020
1327 #ifdef CONFIG_CIFS_UPCALL
1328 #define   CIFSSEC_MASK          0xBF0BF /* allows weak security but also krb5 */
1329 #else
1330 #define   CIFSSEC_MASK          0xB70B7 /* current flags supported if weak */
1331 #endif /* UPCALL */
1332 #else /* do not allow weak pw hash */
1333 #define   CIFSSEC_MUST_LANMAN   0
1334 #define   CIFSSEC_MUST_PLNTXT   0
1335 #ifdef CONFIG_CIFS_UPCALL
1336 #define   CIFSSEC_MASK          0x8F08F /* flags supported if no weak allowed */
1337 #else
1338 #define   CIFSSEC_MASK          0x87087 /* flags supported if no weak allowed */
1339 #endif /* UPCALL */
1340 #endif /* WEAK_PW_HASH */
1341 #define   CIFSSEC_MUST_SEAL     0x40040 /* not supported yet */
1342 #define   CIFSSEC_MUST_NTLMSSP  0x80080 /* raw ntlmssp with ntlmv2 */
1343
1344 #define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2)
1345 #define   CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
1346 #define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_LANMAN | CIFSSEC_MAY_PLNTXT | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
1347 /*
1348  *****************************************************************
1349  * All constants go here
1350  *****************************************************************
1351  */
1352
1353 #define UID_HASH (16)
1354
1355 /*
1356  * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
1357  * following to be declared.
1358  */
1359
1360 /****************************************************************************
1361  *  Locking notes.  All updates to global variables and lists should be
1362  *                  protected by spinlocks or semaphores.
1363  *
1364  *  Spinlocks
1365  *  ---------
1366  *  GlobalMid_Lock protects:
1367  *      list operations on pending_mid_q and oplockQ
1368  *      updates to XID counters, multiplex id  and SMB sequence numbers
1369  *  cifs_file_list_lock protects:
1370  *      list operations on tcp and SMB session lists and tCon lists
1371  *  f_owner.lock protects certain per file struct operations
1372  *  mapping->page_lock protects certain per page operations
1373  *
1374  *  Semaphores
1375  *  ----------
1376  *  sesSem     operations on smb session
1377  *  tconSem    operations on tree connection
1378  *  fh_sem      file handle reconnection operations
1379  *
1380  ****************************************************************************/
1381
1382 #ifdef DECLARE_GLOBALS_HERE
1383 #define GLOBAL_EXTERN
1384 #else
1385 #define GLOBAL_EXTERN extern
1386 #endif
1387
1388 /*
1389  * the list of TCP_Server_Info structures, ie each of the sockets
1390  * connecting our client to a distinct server (ip address), is
1391  * chained together by cifs_tcp_ses_list. The list of all our SMB
1392  * sessions (and from that the tree connections) can be found
1393  * by iterating over cifs_tcp_ses_list
1394  */
1395 GLOBAL_EXTERN struct list_head          cifs_tcp_ses_list;
1396
1397 /*
1398  * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1399  * tcp session, and the list of tcon's per smb session. It also protects
1400  * the reference counters for the server, smb session, and tcon. Finally,
1401  * changes to the tcon->tidStatus should be done while holding this lock.
1402  */
1403 GLOBAL_EXTERN spinlock_t                cifs_tcp_ses_lock;
1404
1405 /*
1406  * This lock protects the cifs_file->llist and cifs_file->flist
1407  * list operations, and updates to some flags (cifs_file->invalidHandle)
1408  * It will be moved to either use the tcon->stat_lock or equivalent later.
1409  * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
1410  * the cifs_tcp_ses_lock must be grabbed first and released last.
1411  */
1412 GLOBAL_EXTERN spinlock_t        cifs_file_list_lock;
1413
1414 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1415 /* Outstanding dir notify requests */
1416 GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1417 /* DirNotify response queue */
1418 GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
1419 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1420
1421 /*
1422  * Global transaction id (XID) information
1423  */
1424 GLOBAL_EXTERN unsigned int GlobalCurrentXid;    /* protected by GlobalMid_Sem */
1425 GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
1426 GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;  /* prot by GlobalMid_Sem */
1427 GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above & list operations */
1428                                           /* on midQ entries */
1429 /*
1430  *  Global counters, updated atomically
1431  */
1432 GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1433 GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1434 GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1435 GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1436 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1437
1438 /* Various Debug counters */
1439 GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
1440 #ifdef CONFIG_CIFS_STATS2
1441 GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1442 GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1443 #endif
1444 GLOBAL_EXTERN atomic_t smBufAllocCount;
1445 GLOBAL_EXTERN atomic_t midCount;
1446
1447 /* Misc globals */
1448 GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
1449 GLOBAL_EXTERN unsigned int lookupCacheEnabled;
1450 GLOBAL_EXTERN unsigned int global_secflags;     /* if on, session setup sent
1451                                 with more secure ntlmssp2 challenge/resp */
1452 GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
1453 GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1454 GLOBAL_EXTERN unsigned int CIFSMaxBufSize;  /* max size not including hdr */
1455 GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
1456 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf pool */
1457 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
1458
1459 #ifdef CONFIG_CIFS_ACL
1460 GLOBAL_EXTERN struct rb_root uidtree;
1461 GLOBAL_EXTERN struct rb_root gidtree;
1462 GLOBAL_EXTERN spinlock_t siduidlock;
1463 GLOBAL_EXTERN spinlock_t sidgidlock;
1464 GLOBAL_EXTERN struct rb_root siduidtree;
1465 GLOBAL_EXTERN struct rb_root sidgidtree;
1466 GLOBAL_EXTERN spinlock_t uidsidlock;
1467 GLOBAL_EXTERN spinlock_t gidsidlock;
1468 #endif /* CONFIG_CIFS_ACL */
1469
1470 void cifs_oplock_break(struct work_struct *work);
1471
1472 extern const struct slow_work_ops cifs_oplock_break_ops;
1473 extern struct workqueue_struct *cifsiod_wq;
1474
1475 extern mempool_t *cifs_mid_poolp;
1476
1477 /* Operations for different SMB versions */
1478 #define SMB1_VERSION_STRING     "1.0"
1479 extern struct smb_version_operations smb1_operations;
1480 extern struct smb_version_values smb1_values;
1481 #define SMB21_VERSION_STRING    "2.1"
1482 extern struct smb_version_operations smb21_operations;
1483 extern struct smb_version_values smb21_values;
1484 #endif  /* _CIFS_GLOB_H */