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