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