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/workqueue.h>
  26 #include "cifs_fs_sb.h"
  27 #include "cifsacl.h"
  28 #include <crypto/internal/hash.h>
  29 #include <linux/scatterlist.h>
  30
  31 /*
  32  * The sizes of various internal tables and strings
  33  */
  34 #define MAX_UID_INFO 16
  35 #define MAX_SES_INFO 2
  36 #define MAX_TCON_INFO 4
  37
  38 #define MAX_TREE_SIZE (2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1)
  39 #define MAX_SERVER_SIZE 15
  40 #define MAX_SHARE_SIZE 80
  41 #define MAX_USERNAME_SIZE 256   /* reasonable maximum for current servers */
  42 #define MAX_PASSWORD_SIZE 512   /* max for windows seems to be 256 wide chars */
  43
  44 #define CIFS_MIN_RCV_POOL 4
  45
  46 /*
  47  * default attribute cache timeout (jiffies)
  48  */
  49 #define CIFS_DEF_ACTIMEO (1 * HZ)
  50
  51 /*
  52  * max attribute cache timeout (jiffies) - 2^30
  53  */
  54 #define CIFS_MAX_ACTIMEO (1 << 30)
  55
  56 /*
  57  * MAX_REQ is the maximum number of requests that WE will send
  58  * on one socket concurrently.
  59  */
  60 #define CIFS_MAX_REQ 32767
  61
  62 #define RFC1001_NAME_LEN 15
  63 #define RFC1001_NAME_LEN_WITH_NULL (RFC1001_NAME_LEN + 1)
  64
  65 /* currently length of NIP6_FMT */
  66 #define SERVER_NAME_LENGTH 40
  67 #define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
  68
  69 /* used to define string lengths for reversing unicode strings */
  70 /*         (256+1)*2 = 514                                     */
  71 /*           (max path length + 1 for null) * 2 for unicode    */
  72 #define MAX_NAME 514
  73
  74 #include "cifspdu.h"
  75
  76 #ifndef XATTR_DOS_ATTRIB
  77 #define XATTR_DOS_ATTRIB "user.DOSATTRIB"
  78 #endif
  79
  80 /*
  81  * CIFS vfs client Status information (based on what we know.)
  82  */
  83
  84 /* associated with each tcp and smb session */
  85 enum statusEnum {
  86         CifsNew = 0,
  87         CifsGood,
  88         CifsExiting,
  89         CifsNeedReconnect,
  90         CifsNeedNegotiate
  91 };
  92
  93 enum securityEnum {
  94         LANMAN = 0,                     /* Legacy LANMAN auth */
  95         NTLM,                   /* Legacy NTLM012 auth with NTLM hash */
  96         NTLMv2,                 /* Legacy NTLM auth with NTLMv2 hash */
  97         RawNTLMSSP,             /* NTLMSSP without SPNEGO, NTLMv2 hash */
  98 /*      NTLMSSP, */ /* can use rawNTLMSSP instead of NTLMSSP via SPNEGO */
  99         Kerberos,               /* Kerberos via SPNEGO */
 100 };
 101
 102 enum protocolEnum {
 103         TCP = 0,
 104         SCTP
 105         /* Netbios frames protocol not supported at this time */
 106 };
 107
 108 struct session_key {
 109         unsigned int len;
 110         char *response;
 111 };
 112
 113 /* crypto security descriptor definition */
 114 struct sdesc {
 115         struct shash_desc shash;
 116         char ctx[];
 117 };
 118
 119 /* crypto hashing related structure/fields, not specific to a sec mech */
 120 struct cifs_secmech {
 121         struct crypto_shash *hmacmd5; /* hmac-md5 hash function */
 122         struct crypto_shash *md5; /* md5 hash function */
 123         struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */
 124         struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */
 125 };
 126
 127 /* per smb session structure/fields */
 128 struct ntlmssp_auth {
 129         __u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */
 130         __u32 server_flags; /* sent by server in type 2 ntlmssp exchange */
 131         unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */
 132         char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */
 133 };
 134
 135 struct cifs_cred {
 136         int uid;
 137         int gid;
 138         int mode;
 139         int cecount;
 140         struct cifs_sid osid;
 141         struct cifs_sid gsid;
 142         struct cifs_ntace *ntaces;
 143         struct cifs_ace *aces;
 144 };
 145
 146 /*
 147  *****************************************************************
 148  * Except the CIFS PDUs themselves all the
 149  * globally interesting structs should go here
 150  *****************************************************************
 151  */
 152
 153 enum smb_version {
 154         Smb_1 = 1,
 155 };
 156
 157 struct mid_q_entry;
 158 struct TCP_Server_Info;
 159 struct cifsFileInfo;
 160 struct cifs_ses;
 161
 162 struct smb_version_operations {
 163         int (*send_cancel)(struct TCP_Server_Info *, void *,
 164                            struct mid_q_entry *);
 165         bool (*compare_fids)(struct cifsFileInfo *, struct cifsFileInfo *);
 166         /* setup request: allocate mid, sign message */
 167         int (*setup_request)(struct cifs_ses *, struct kvec *, unsigned int,
 168                              struct mid_q_entry **);
 169         /* check response: verify signature, map error */
 170         int (*check_receive)(struct mid_q_entry *, struct TCP_Server_Info *,
 171                              bool);
 172         /* data offset from read response message */
 173         unsigned int (*read_data_offset)(char *);
 174         /* data length from read response message */
 175         unsigned int (*read_data_length)(char *);
 176         /* map smb to linux error */
 177         int (*map_error)(char *, bool);
 178         /* find mid corresponding to the response message */
 179         struct mid_q_entry * (*find_mid)(struct TCP_Server_Info *, char *);
 180         void (*dump_detail)(void *);
 181         /* verify the message */
 182         int (*check_message)(char *, unsigned int);
 183         bool (*is_oplock_break)(char *, struct TCP_Server_Info *);
 184 };
 185
 186 struct smb_version_values {
 187         char            *version_string;
 188         __u32           large_lock_type;
 189         __u32           exclusive_lock_type;
 190         __u32           shared_lock_type;
 191         __u32           unlock_lock_type;
 192         size_t          header_size;
 193         size_t          max_header_size;
 194         size_t          read_rsp_size;
 195 };
 196
 197 #define HEADER_SIZE(server) (server->vals->header_size)
 198 #define MAX_HEADER_SIZE(server) (server->vals->max_header_size)
 199
 200 struct smb_vol {
 201         char *username;
 202         char *password;
 203         char *domainname;
 204         char *UNC;
 205         char *UNCip;
 206         char *iocharset;  /* local code page for mapping to and from Unicode */
 207         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
 208         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
 209         uid_t cred_uid;
 210         uid_t linux_uid;
 211         gid_t linux_gid;
 212         uid_t backupuid;
 213         gid_t backupgid;
 214         umode_t file_mode;
 215         umode_t dir_mode;
 216         unsigned secFlg;
 217         bool retry:1;
 218         bool intr:1;
 219         bool setuids:1;
 220         bool override_uid:1;
 221         bool override_gid:1;
 222         bool dynperm:1;
 223         bool noperm:1;
 224         bool no_psx_acl:1; /* set if posix acl support should be disabled */
 225         bool cifs_acl:1;
 226         bool backupuid_specified; /* mount option  backupuid  is specified */
 227         bool backupgid_specified; /* mount option  backupgid  is specified */
 228         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
 229         bool server_ino:1; /* use inode numbers from server ie UniqueId */
 230         bool direct_io:1;
 231         bool strict_io:1; /* strict cache behavior */
 232         bool remap:1;      /* set to remap seven reserved chars in filenames */
 233         bool posix_paths:1; /* unset to not ask for posix pathnames. */
 234         bool no_linux_ext:1;
 235         bool sfu_emul:1;
 236         bool nullauth:1;   /* attempt to authenticate with null user */
 237         bool nocase:1;     /* request case insensitive filenames */
 238         bool nobrl:1;      /* disable sending byte range locks to srv */
 239         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
 240         bool seal:1;       /* request transport encryption on share */
 241         bool nodfs:1;      /* Do not request DFS, even if available */
 242         bool local_lease:1; /* check leases only on local system, not remote */
 243         bool noblocksnd:1;
 244         bool noautotune:1;
 245         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 246         bool fsc:1;     /* enable fscache */
 247         bool mfsymlinks:1; /* use Minshall+French Symlinks */
 248         bool multiuser:1;
 249         bool rwpidforward:1; /* pid forward for read/write operations */
 250         unsigned int rsize;
 251         unsigned int wsize;
 252         bool sockopt_tcp_nodelay:1;
 253         unsigned short int port;
 254         unsigned long actimeo; /* attribute cache timeout (jiffies) */
 255         struct smb_version_operations *ops;
 256         struct smb_version_values *vals;
 257         char *prepath;
 258         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
 259         struct nls_table *local_nls;
 260 };
 261
 262 #define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \
 263                          CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \
 264                          CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \
 265                          CIFS_MOUNT_UNX_EMUL | CIFS_MOUNT_NO_BRL | \
 266                          CIFS_MOUNT_CIFS_ACL | CIFS_MOUNT_OVERR_UID | \
 267                          CIFS_MOUNT_OVERR_GID | CIFS_MOUNT_DYNPERM | \
 268                          CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \
 269                          CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \
 270                          CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \
 271                          CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID)
 272
 273 #define CIFS_MS_MASK (MS_RDONLY | MS_MANDLOCK | MS_NOEXEC | MS_NOSUID | \
 274                       MS_NODEV | MS_SYNCHRONOUS)
 275
 276 struct cifs_mnt_data {
 277         struct cifs_sb_info *cifs_sb;
 278         struct smb_vol *vol;
 279         int flags;
 280 };
 281
 282 static inline unsigned int
 283 get_rfc1002_length(void *buf)
 284 {
 285         return be32_to_cpu(*((__be32 *)buf));
 286 }
 287
 288 struct TCP_Server_Info {
 289         struct list_head tcp_ses_list;
 290         struct list_head smb_ses_list;
 291         int srv_count; /* reference counter */
 292         /* 15 character server name + 0x20 16th byte indicating type = srv */
 293         char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
 294         struct smb_version_operations   *ops;
 295         struct smb_version_values       *vals;
 296         enum statusEnum tcpStatus; /* what we think the status is */
 297         char *hostname; /* hostname portion of UNC string */
 298         struct socket *ssocket;
 299         struct sockaddr_storage dstaddr;
 300         struct sockaddr_storage srcaddr; /* locally bind to this IP */
 301 #ifdef CONFIG_NET_NS
 302         struct net *net;
 303 #endif
 304         wait_queue_head_t response_q;
 305         wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
 306         struct list_head pending_mid_q;
 307         bool noblocksnd;                /* use blocking sendmsg */
 308         bool noautotune;                /* do not autotune send buf sizes */
 309         bool tcp_nodelay;
 310         int credits;  /* send no more requests at once */
 311         unsigned int in_flight;  /* number of requests on the wire to server */
 312         spinlock_t req_lock;  /* protect the two values above */
 313         struct mutex srv_mutex;
 314         struct task_struct *tsk;
 315         char server_GUID[16];
 316         char sec_mode;
 317         bool session_estab; /* mark when very first sess is established */
 318         u16 dialect; /* dialect index that server chose */
 319         enum securityEnum secType;
 320         bool oplocks:1; /* enable oplocks */
 321         unsigned int maxReq;    /* Clients should submit no more */
 322         /* than maxReq distinct unanswered SMBs to the server when using  */
 323         /* multiplexed reads or writes */
 324         unsigned int maxBuf;    /* maxBuf specifies the maximum */
 325         /* message size the server can send or receive for non-raw SMBs */
 326         /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
 327         /* when socket is setup (and during reconnect) before NegProt sent */
 328         unsigned int max_rw;    /* maxRw specifies the maximum */
 329         /* message size the server can send or receive for */
 330         /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
 331         unsigned int max_vcs;   /* maximum number of smb sessions, at least
 332                                    those that can be specified uniquely with
 333                                    vcnumbers */
 334         int capabilities; /* allow selective disabling of caps by smb sess */
 335         int timeAdj;  /* Adjust for difference in server time zone in sec */
 336         __u64 CurrentMid;         /* multiplex id - rotating counter */
 337         char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
 338         /* 16th byte of RFC1001 workstation name is always null */
 339         char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
 340         __u32 sequence_number; /* for signing, protected by srv_mutex */
 341         struct session_key session_key;
 342         unsigned long lstrp; /* when we got last response from this server */
 343         struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */
 344         /* extended security flavors that server supports */
 345         bool    sec_ntlmssp;            /* supports NTLMSSP */
 346         bool    sec_kerberosu2u;        /* supports U2U Kerberos */
 347         bool    sec_kerberos;           /* supports plain Kerberos */
 348         bool    sec_mskerberos;         /* supports legacy MS Kerberos */
 349         bool    large_buf;              /* is current buffer large? */
 350         struct delayed_work     echo; /* echo ping workqueue job */
 351         struct kvec *iov;       /* reusable kvec array for receives */
 352         unsigned int nr_iov;    /* number of kvecs in array */
 353         char    *smallbuf;      /* pointer to current "small" buffer */
 354         char    *bigbuf;        /* pointer to current "big" buffer */
 355         unsigned int total_read; /* total amount of data read in this pass */
 356 #ifdef CONFIG_CIFS_FSCACHE
 357         struct fscache_cookie   *fscache; /* client index cache cookie */
 358 #endif
 359 #ifdef CONFIG_CIFS_STATS2
 360         atomic_t in_send; /* requests trying to send */
 361         atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
 362 #endif
 363 };
 364
 365 static inline unsigned int
 366 in_flight(struct TCP_Server_Info *server)
 367 {
 368         unsigned int num;
 369         spin_lock(&server->req_lock);
 370         num = server->in_flight;
 371         spin_unlock(&server->req_lock);
 372         return num;
 373 }
 374
 375 static inline int*
 376 get_credits_field(struct TCP_Server_Info *server)
 377 {
 378         /*
 379          * This will change to switch statement when we reserve slots for echos
 380          * and oplock breaks.
 381          */
 382         return &server->credits;
 383 }
 384
 385 static inline bool
 386 has_credits(struct TCP_Server_Info *server, int *credits)
 387 {
 388         int num;
 389         spin_lock(&server->req_lock);
 390         num = *credits;
 391         spin_unlock(&server->req_lock);
 392         return num > 0;
 393 }
 394
 395 /*
 396  * Macros to allow the TCP_Server_Info->net field and related code to drop out
 397  * when CONFIG_NET_NS isn't set.
 398  */
 399
 400 #ifdef CONFIG_NET_NS
 401
 402 static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
 403 {
 404         return srv->net;
 405 }
 406
 407 static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
 408 {
 409         srv->net = net;
 410 }
 411
 412 #else
 413
 414 static inline struct net *cifs_net_ns(struct TCP_Server_Info *srv)
 415 {
 416         return &init_net;
 417 }
 418
 419 static inline void cifs_set_net_ns(struct TCP_Server_Info *srv, struct net *net)
 420 {
 421 }
 422
 423 #endif
 424
 425 /*
 426  * Session structure.  One of these for each uid session with a particular host
 427  */
 428 struct cifs_ses {
 429         struct list_head smb_ses_list;
 430         struct list_head tcon_list;
 431         struct mutex session_mutex;
 432         struct TCP_Server_Info *server; /* pointer to server info */
 433         int ses_count;          /* reference counter */
 434         enum statusEnum status;
 435         unsigned overrideSecFlg;  /* if non-zero override global sec flags */
 436         __u16 ipc_tid;          /* special tid for connection to IPC share */
 437         __u16 flags;
 438         __u16 vcnum;
 439         char *serverOS;         /* name of operating system underlying server */
 440         char *serverNOS;        /* name of network operating system of server */
 441         char *serverDomain;     /* security realm of server */
 442         int Suid;               /* remote smb uid  */
 443         uid_t linux_uid;        /* overriding owner of files on the mount */
 444         uid_t cred_uid;         /* owner of credentials */
 445         int capabilities;
 446         char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
 447                                 TCP names - will ipv6 and sctp addresses fit? */
 448         char *user_name;        /* must not be null except during init of sess
 449                                    and after mount option parsing we fill it */
 450         char *domainName;
 451         char *password;
 452         struct session_key auth_key;
 453         struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */
 454         bool need_reconnect:1; /* connection reset, uid now invalid */
 455 };
 456 /* no more than one of the following three session flags may be set */
 457 #define CIFS_SES_NT4 1
 458 #define CIFS_SES_OS2 2
 459 #define CIFS_SES_W9X 4
 460 /* following flag is set for old servers such as OS2 (and Win95?)
 461    which do not negotiate NTLM or POSIX dialects, but instead
 462    negotiate one of the older LANMAN dialects */
 463 #define CIFS_SES_LANMAN 8
 464 /*
 465  * there is one of these for each connection to a resource on a particular
 466  * session
 467  */
 468 struct cifs_tcon {
 469         struct list_head tcon_list;
 470         int tc_count;
 471         struct list_head openFileList;
 472         struct cifs_ses *ses;   /* pointer to session associated with */
 473         char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */
 474         char *nativeFileSystem;
 475         char *password;         /* for share-level security */
 476         __u16 tid;              /* The 2 byte tree id */
 477         __u16 Flags;            /* optional support bits */
 478         enum statusEnum tidStatus;
 479 #ifdef CONFIG_CIFS_STATS
 480         atomic_t num_smbs_sent;
 481         atomic_t num_writes;
 482         atomic_t num_reads;
 483         atomic_t num_flushes;
 484         atomic_t num_oplock_brks;
 485         atomic_t num_opens;
 486         atomic_t num_closes;
 487         atomic_t num_deletes;
 488         atomic_t num_mkdirs;
 489         atomic_t num_posixopens;
 490         atomic_t num_posixmkdirs;
 491         atomic_t num_rmdirs;
 492         atomic_t num_renames;
 493         atomic_t num_t2renames;
 494         atomic_t num_ffirst;
 495         atomic_t num_fnext;
 496         atomic_t num_fclose;
 497         atomic_t num_hardlinks;
 498         atomic_t num_symlinks;
 499         atomic_t num_locks;
 500         atomic_t num_acl_get;
 501         atomic_t num_acl_set;
 502 #ifdef CONFIG_CIFS_STATS2
 503         unsigned long long time_writes;
 504         unsigned long long time_reads;
 505         unsigned long long time_opens;
 506         unsigned long long time_deletes;
 507         unsigned long long time_closes;
 508         unsigned long long time_mkdirs;
 509         unsigned long long time_rmdirs;
 510         unsigned long long time_renames;
 511         unsigned long long time_t2renames;
 512         unsigned long long time_ffirst;
 513         unsigned long long time_fnext;
 514         unsigned long long time_fclose;
 515 #endif /* CONFIG_CIFS_STATS2 */
 516         __u64    bytes_read;
 517         __u64    bytes_written;
 518         spinlock_t stat_lock;
 519 #endif /* CONFIG_CIFS_STATS */
 520         FILE_SYSTEM_DEVICE_INFO fsDevInfo;
 521         FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */
 522         FILE_SYSTEM_UNIX_INFO fsUnixInfo;
 523         bool ipc:1;             /* set if connection to IPC$ eg for RPC/PIPES */
 524         bool retry:1;
 525         bool nocase:1;
 526         bool seal:1;      /* transport encryption for this mounted share */
 527         bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
 528                                 for this mount even if server would support */
 529         bool local_lease:1; /* check leases (only) on local system not remote */
 530         bool broken_posix_open; /* e.g. Samba server versions < 3.3.2, 3.2.9 */
 531         bool need_reconnect:1; /* connection reset, tid now invalid */
 532 #ifdef CONFIG_CIFS_FSCACHE
 533         u64 resource_id;                /* server resource id */
 534         struct fscache_cookie *fscache; /* cookie for share */
 535 #endif
 536         /* BB add field for back pointer to sb struct(s)? */
 537 };
 538
 539 /*
 540  * This is a refcounted and timestamped container for a tcon pointer. The
 541  * container holds a tcon reference. It is considered safe to free one of
 542  * these when the tl_count goes to 0. The tl_time is the time of the last
 543  * "get" on the container.
 544  */
 545 struct tcon_link {
 546         struct rb_node          tl_rbnode;
 547         uid_t                   tl_uid;
 548         unsigned long           tl_flags;
 549 #define TCON_LINK_MASTER        0
 550 #define TCON_LINK_PENDING       1
 551 #define TCON_LINK_IN_TREE       2
 552         unsigned long           tl_time;
 553         atomic_t                tl_count;
 554         struct cifs_tcon        *tl_tcon;
 555 };
 556
 557 extern struct tcon_link *cifs_sb_tlink(struct cifs_sb_info *cifs_sb);
 558
 559 static inline struct cifs_tcon *
 560 tlink_tcon(struct tcon_link *tlink)
 561 {
 562         return tlink->tl_tcon;
 563 }
 564
 565 extern void cifs_put_tlink(struct tcon_link *tlink);
 566
 567 static inline struct tcon_link *
 568 cifs_get_tlink(struct tcon_link *tlink)
 569 {
 570         if (tlink && !IS_ERR(tlink))
 571                 atomic_inc(&tlink->tl_count);
 572         return tlink;
 573 }
 574
 575 /* This function is always expected to succeed */
 576 extern struct cifs_tcon *cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb);
 577
 578 /*
 579  * This info hangs off the cifsFileInfo structure, pointed to by llist.
 580  * This is used to track byte stream locks on the file
 581  */
 582 struct cifsLockInfo {
 583         struct list_head llist; /* pointer to next cifsLockInfo */
 584         struct list_head blist; /* pointer to locks blocked on this */
 585         wait_queue_head_t block_q;
 586         __u64 offset;
 587         __u64 length;
 588         __u32 pid;
 589         __u32 type;
 590 };
 591
 592 /*
 593  * One of these for each open instance of a file
 594  */
 595 struct cifs_search_info {
 596         loff_t index_of_last_entry;
 597         __u16 entries_in_buffer;
 598         __u16 info_level;
 599         __u32 resume_key;
 600         char *ntwrk_buf_start;
 601         char *srch_entries_start;
 602         char *last_entry;
 603         const char *presume_name;
 604         unsigned int resume_name_len;
 605         bool endOfSearch:1;
 606         bool emptyDir:1;
 607         bool unicode:1;
 608         bool smallBuf:1; /* so we know which buf_release function to call */
 609 };
 610
 611 struct cifsFileInfo {
 612         struct list_head tlist; /* pointer to next fid owned by tcon */
 613         struct list_head flist; /* next fid (file instance) for this inode */
 614         struct list_head llist; /*
 615                                  * brlocks held by this fid, protected by
 616                                  * lock_mutex from cifsInodeInfo structure
 617                                  */
 618         unsigned int uid;       /* allows finding which FileInfo structure */
 619         __u32 pid;              /* process id who opened file */
 620         __u16 netfid;           /* file id from remote */
 621         /* BB add lock scope info here if needed */ ;
 622         /* lock scope id (0 if none) */
 623         struct dentry *dentry;
 624         unsigned int f_flags;
 625         struct tcon_link *tlink;
 626         bool invalidHandle:1;   /* file closed via session abend */
 627         bool oplock_break_cancelled:1;
 628         int count;              /* refcount protected by cifs_file_list_lock */
 629         struct mutex fh_mutex; /* prevents reopen race after dead ses*/
 630         struct cifs_search_info srch_inf;
 631         struct work_struct oplock_break; /* work for oplock breaks */
 632 };
 633
 634 struct cifs_io_parms {
 635         __u16 netfid;
 636         __u32 pid;
 637         __u64 offset;
 638         unsigned int length;
 639         struct cifs_tcon *tcon;
 640 };
 641
 642 /*
 643  * Take a reference on the file private data. Must be called with
 644  * cifs_file_list_lock held.
 645  */
 646 static inline
 647 struct cifsFileInfo *cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 648 {
 649         ++cifs_file->count;
 650         return cifs_file;
 651 }
 652
 653 void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
 654
 655 /*
 656  * One of these for each file inode
 657  */
 658
 659 struct cifsInodeInfo {
 660         bool can_cache_brlcks;
 661         struct mutex lock_mutex;        /*
 662                                          * protect the field above and llist
 663                                          * from every cifsFileInfo structure
 664                                          * from openFileList
 665                                          */
 666         /* BB add in lists for dirty pages i.e. write caching info for oplock */
 667         struct list_head openFileList;
 668         __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
 669         bool clientCanCacheRead;        /* read oplock */
 670         bool clientCanCacheAll;         /* read and writebehind oplock */
 671         bool delete_pending;            /* DELETE_ON_CLOSE is set */
 672         bool invalid_mapping;           /* pagecache is invalid */
 673         unsigned long time;             /* jiffies of last update of inode */
 674         u64  server_eof;                /* current file size on server -- protected by i_lock */
 675         u64  uniqueid;                  /* server inode number */
 676         u64  createtime;                /* creation time on server */
 677 #ifdef CONFIG_CIFS_FSCACHE
 678         struct fscache_cookie *fscache;
 679 #endif
 680         struct inode vfs_inode;
 681 };
 682
 683 static inline struct cifsInodeInfo *
 684 CIFS_I(struct inode *inode)
 685 {
 686         return container_of(inode, struct cifsInodeInfo, vfs_inode);
 687 }
 688
 689 static inline struct cifs_sb_info *
 690 CIFS_SB(struct super_block *sb)
 691 {
 692         return sb->s_fs_info;
 693 }
 694
 695 static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
 696 {
 697         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 698                 return '/';
 699         else
 700                 return '\\';
 701 }
 702
 703 static inline void
 704 convert_delimiter(char *path, char delim)
 705 {
 706         int i;
 707         char old_delim;
 708
 709         if (path == NULL)
 710                 return;
 711
 712         if (delim == '/')
 713                 old_delim = '\\';
 714         else
 715                 old_delim = '/';
 716
 717         for (i = 0; path[i] != '\0'; i++) {
 718                 if (path[i] == old_delim)
 719                         path[i] = delim;
 720         }
 721 }
 722
 723 #ifdef CONFIG_CIFS_STATS
 724 #define cifs_stats_inc atomic_inc
 725
 726 static inline void cifs_stats_bytes_written(struct cifs_tcon *tcon,
 727                                             unsigned int bytes)
 728 {
 729         if (bytes) {
 730                 spin_lock(&tcon->stat_lock);
 731                 tcon->bytes_written += bytes;
 732                 spin_unlock(&tcon->stat_lock);
 733         }
 734 }
 735
 736 static inline void cifs_stats_bytes_read(struct cifs_tcon *tcon,
 737                                          unsigned int bytes)
 738 {
 739         spin_lock(&tcon->stat_lock);
 740         tcon->bytes_read += bytes;
 741         spin_unlock(&tcon->stat_lock);
 742 }
 743 #else
 744
 745 #define  cifs_stats_inc(field) do {} while (0)
 746 #define  cifs_stats_bytes_written(tcon, bytes) do {} while (0)
 747 #define  cifs_stats_bytes_read(tcon, bytes) do {} while (0)
 748
 749 #endif
 750
 751
 752 /*
 753  * This is the prototype for the mid receive function. This function is for
 754  * receiving the rest of the SMB frame, starting with the WordCount (which is
 755  * just after the MID in struct smb_hdr). Note:
 756  *
 757  * - This will be called by cifsd, with no locks held.
 758  * - The mid will still be on the pending_mid_q.
 759  * - mid->resp_buf will point to the current buffer.
 760  *
 761  * Returns zero on a successful receive, or an error. The receive state in
 762  * the TCP_Server_Info will also be updated.
 763  */
 764 typedef int (mid_receive_t)(struct TCP_Server_Info *server,
 765                             struct mid_q_entry *mid);
 766
 767 /*
 768  * This is the prototype for the mid callback function. This is called once the
 769  * mid has been received off of the socket. When creating one, take special
 770  * care to avoid deadlocks. Things to bear in mind:
 771  *
 772  * - it will be called by cifsd, with no locks held
 773  * - the mid will be removed from any lists
 774  */
 775 typedef void (mid_callback_t)(struct mid_q_entry *mid);
 776
 777 /* one of these for every pending CIFS request to the server */
 778 struct mid_q_entry {
 779         struct list_head qhead; /* mids waiting on reply from this server */
 780         __u64 mid;              /* multiplex id */
 781         __u32 pid;              /* process id */
 782         __u32 sequence_number;  /* for CIFS signing */
 783         unsigned long when_alloc;  /* when mid was created */
 784 #ifdef CONFIG_CIFS_STATS2
 785         unsigned long when_sent; /* time when smb send finished */
 786         unsigned long when_received; /* when demux complete (taken off wire) */
 787 #endif
 788         mid_receive_t *receive; /* call receive callback */
 789         mid_callback_t *callback; /* call completion callback */
 790         void *callback_data;      /* general purpose pointer for callback */
 791         void *resp_buf;         /* pointer to received SMB header */
 792         int mid_state;  /* wish this were enum but can not pass to wait_event */
 793         __le16 command;         /* smb command code */
 794         bool large_buf:1;       /* if valid response, is pointer to large buf */
 795         bool multiRsp:1;        /* multiple trans2 responses for one request  */
 796         bool multiEnd:1;        /* both received */
 797 };
 798
 799 /*      Make code in transport.c a little cleaner by moving
 800         update of optional stats into function below */
 801 #ifdef CONFIG_CIFS_STATS2
 802
 803 static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
 804 {
 805         atomic_inc(&server->in_send);
 806 }
 807
 808 static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
 809 {
 810         atomic_dec(&server->in_send);
 811 }
 812
 813 static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
 814 {
 815         atomic_inc(&server->num_waiters);
 816 }
 817
 818 static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
 819 {
 820         atomic_dec(&server->num_waiters);
 821 }
 822
 823 static inline void cifs_save_when_sent(struct mid_q_entry *mid)
 824 {
 825         mid->when_sent = jiffies;
 826 }
 827 #else
 828 static inline void cifs_in_send_inc(struct TCP_Server_Info *server)
 829 {
 830 }
 831 static inline void cifs_in_send_dec(struct TCP_Server_Info *server)
 832 {
 833 }
 834
 835 static inline void cifs_num_waiters_inc(struct TCP_Server_Info *server)
 836 {
 837 }
 838
 839 static inline void cifs_num_waiters_dec(struct TCP_Server_Info *server)
 840 {
 841 }
 842
 843 static inline void cifs_save_when_sent(struct mid_q_entry *mid)
 844 {
 845 }
 846 #endif
 847
 848 /* for pending dnotify requests */
 849 struct dir_notify_req {
 850         struct list_head lhead;
 851         __le16 Pid;
 852         __le16 PidHigh;
 853         __u16 Mid;
 854         __u16 Tid;
 855         __u16 Uid;
 856         __u16 netfid;
 857         __u32 filter; /* CompletionFilter (for multishot) */
 858         int multishot;
 859         struct file *pfile;
 860 };
 861
 862 struct dfs_info3_param {
 863         int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
 864         int path_consumed;
 865         int server_type;
 866         int ref_flag;
 867         char *path_name;
 868         char *node_name;
 869 };
 870
 871 /*
 872  * common struct for holding inode info when searching for or updating an
 873  * inode with new info
 874  */
 875
 876 #define CIFS_FATTR_DFS_REFERRAL         0x1
 877 #define CIFS_FATTR_DELETE_PENDING       0x2
 878 #define CIFS_FATTR_NEED_REVAL           0x4
 879 #define CIFS_FATTR_INO_COLLISION        0x8
 880
 881 struct cifs_fattr {
 882         u32             cf_flags;
 883         u32             cf_cifsattrs;
 884         u64             cf_uniqueid;
 885         u64             cf_eof;
 886         u64             cf_bytes;
 887         u64             cf_createtime;
 888         uid_t           cf_uid;
 889         gid_t           cf_gid;
 890         umode_t         cf_mode;
 891         dev_t           cf_rdev;
 892         unsigned int    cf_nlink;
 893         unsigned int    cf_dtype;
 894         struct timespec cf_atime;
 895         struct timespec cf_mtime;
 896         struct timespec cf_ctime;
 897 };
 898
 899 static inline void free_dfs_info_param(struct dfs_info3_param *param)
 900 {
 901         if (param) {
 902                 kfree(param->path_name);
 903                 kfree(param->node_name);
 904                 kfree(param);
 905         }
 906 }
 907
 908 static inline void free_dfs_info_array(struct dfs_info3_param *param,
 909                                        int number_of_items)
 910 {
 911         int i;
 912         if ((number_of_items == 0) || (param == NULL))
 913                 return;
 914         for (i = 0; i < number_of_items; i++) {
 915                 kfree(param[i].path_name);
 916                 kfree(param[i].node_name);
 917         }
 918         kfree(param);
 919 }
 920
 921 #define   MID_FREE 0
 922 #define   MID_REQUEST_ALLOCATED 1
 923 #define   MID_REQUEST_SUBMITTED 2
 924 #define   MID_RESPONSE_RECEIVED 4
 925 #define   MID_RETRY_NEEDED      8 /* session closed while this request out */
 926 #define   MID_RESPONSE_MALFORMED 0x10
 927 #define   MID_SHUTDOWN           0x20
 928
 929 /* Types of response buffer returned from SendReceive2 */
 930 #define   CIFS_NO_BUFFER        0    /* Response buffer not returned */
 931 #define   CIFS_SMALL_BUFFER     1
 932 #define   CIFS_LARGE_BUFFER     2
 933 #define   CIFS_IOVEC            4    /* array of response buffers */
 934
 935 /* Type of Request to SendReceive2 */
 936 #define   CIFS_BLOCKING_OP      1    /* operation can block */
 937 #define   CIFS_ASYNC_OP         2    /* do not wait for response */
 938 #define   CIFS_TIMEOUT_MASK 0x003    /* only one of above set in req */
 939 #define   CIFS_LOG_ERROR    0x010    /* log NT STATUS if non-zero */
 940 #define   CIFS_LARGE_BUF_OP 0x020    /* large request buffer */
 941 #define   CIFS_NO_RESP      0x040    /* no response buffer required */
 942
 943 /* Security Flags: indicate type of session setup needed */
 944 #define   CIFSSEC_MAY_SIGN      0x00001
 945 #define   CIFSSEC_MAY_NTLM      0x00002
 946 #define   CIFSSEC_MAY_NTLMV2    0x00004
 947 #define   CIFSSEC_MAY_KRB5      0x00008
 948 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 949 #define   CIFSSEC_MAY_LANMAN    0x00010
 950 #define   CIFSSEC_MAY_PLNTXT    0x00020
 951 #else
 952 #define   CIFSSEC_MAY_LANMAN    0
 953 #define   CIFSSEC_MAY_PLNTXT    0
 954 #endif /* weak passwords */
 955 #define   CIFSSEC_MAY_SEAL      0x00040 /* not supported yet */
 956 #define   CIFSSEC_MAY_NTLMSSP   0x00080 /* raw ntlmssp with ntlmv2 */
 957
 958 #define   CIFSSEC_MUST_SIGN     0x01001
 959 /* note that only one of the following can be set so the
 960 result of setting MUST flags more than once will be to
 961 require use of the stronger protocol */
 962 #define   CIFSSEC_MUST_NTLM     0x02002
 963 #define   CIFSSEC_MUST_NTLMV2   0x04004
 964 #define   CIFSSEC_MUST_KRB5     0x08008
 965 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 966 #define   CIFSSEC_MUST_LANMAN   0x10010
 967 #define   CIFSSEC_MUST_PLNTXT   0x20020
 968 #ifdef CONFIG_CIFS_UPCALL
 969 #define   CIFSSEC_MASK          0xBF0BF /* allows weak security but also krb5 */
 970 #else
 971 #define   CIFSSEC_MASK          0xB70B7 /* current flags supported if weak */
 972 #endif /* UPCALL */
 973 #else /* do not allow weak pw hash */
 974 #define   CIFSSEC_MUST_LANMAN   0
 975 #define   CIFSSEC_MUST_PLNTXT   0
 976 #ifdef CONFIG_CIFS_UPCALL
 977 #define   CIFSSEC_MASK          0x8F08F /* flags supported if no weak allowed */
 978 #else
 979 #define   CIFSSEC_MASK          0x87087 /* flags supported if no weak allowed */
 980 #endif /* UPCALL */
 981 #endif /* WEAK_PW_HASH */
 982 #define   CIFSSEC_MUST_SEAL     0x40040 /* not supported yet */
 983 #define   CIFSSEC_MUST_NTLMSSP  0x80080 /* raw ntlmssp with ntlmv2 */
 984
 985 #define   CIFSSEC_DEF (CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2)
 986 #define   CIFSSEC_MAX (CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2)
 987 #define   CIFSSEC_AUTH_MASK (CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 | CIFSSEC_MAY_LANMAN | CIFSSEC_MAY_PLNTXT | CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP)
 988 /*
 989  *****************************************************************
 990  * All constants go here
 991  *****************************************************************
 992  */
 993
 994 #define UID_HASH (16)
 995
 996 /*
 997  * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
 998  * following to be declared.
 999  */
1000
1001 /****************************************************************************
1002  *  Locking notes.  All updates to global variables and lists should be
1003  *                  protected by spinlocks or semaphores.
1004  *
1005  *  Spinlocks
1006  *  ---------
1007  *  GlobalMid_Lock protects:
1008  *      list operations on pending_mid_q and oplockQ
1009  *      updates to XID counters, multiplex id  and SMB sequence numbers
1010  *  cifs_file_list_lock protects:
1011  *      list operations on tcp and SMB session lists and tCon lists
1012  *  f_owner.lock protects certain per file struct operations
1013  *  mapping->page_lock protects certain per page operations
1014  *
1015  *  Semaphores
1016  *  ----------
1017  *  sesSem     operations on smb session
1018  *  tconSem    operations on tree connection
1019  *  fh_sem      file handle reconnection operations
1020  *
1021  ****************************************************************************/
1022
1023 #ifdef DECLARE_GLOBALS_HERE
1024 #define GLOBAL_EXTERN
1025 #else
1026 #define GLOBAL_EXTERN extern
1027 #endif
1028
1029 /*
1030  * the list of TCP_Server_Info structures, ie each of the sockets
1031  * connecting our client to a distinct server (ip address), is
1032  * chained together by cifs_tcp_ses_list. The list of all our SMB
1033  * sessions (and from that the tree connections) can be found
1034  * by iterating over cifs_tcp_ses_list
1035  */
1036 GLOBAL_EXTERN struct list_head          cifs_tcp_ses_list;
1037
1038 /*
1039  * This lock protects the cifs_tcp_ses_list, the list of smb sessions per
1040  * tcp session, and the list of tcon's per smb session. It also protects
1041  * the reference counters for the server, smb session, and tcon. Finally,
1042  * changes to the tcon->tidStatus should be done while holding this lock.
1043  */
1044 GLOBAL_EXTERN spinlock_t                cifs_tcp_ses_lock;
1045
1046 /*
1047  * This lock protects the cifs_file->llist and cifs_file->flist
1048  * list operations, and updates to some flags (cifs_file->invalidHandle)
1049  * It will be moved to either use the tcon->stat_lock or equivalent later.
1050  * If cifs_tcp_ses_lock and the lock below are both needed to be held, then
1051  * the cifs_tcp_ses_lock must be grabbed first and released last.
1052  */
1053 GLOBAL_EXTERN spinlock_t        cifs_file_list_lock;
1054
1055 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1056 /* Outstanding dir notify requests */
1057 GLOBAL_EXTERN struct list_head GlobalDnotifyReqList;
1058 /* DirNotify response queue */
1059 GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q;
1060 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1061
1062 /*
1063  * Global transaction id (XID) information
1064  */
1065 GLOBAL_EXTERN unsigned int GlobalCurrentXid;    /* protected by GlobalMid_Sem */
1066 GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
1067 GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;  /* prot by GlobalMid_Sem */
1068 GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above & list operations */
1069                                           /* on midQ entries */
1070 /*
1071  *  Global counters, updated atomically
1072  */
1073 GLOBAL_EXTERN atomic_t sesInfoAllocCount;
1074 GLOBAL_EXTERN atomic_t tconInfoAllocCount;
1075 GLOBAL_EXTERN atomic_t tcpSesAllocCount;
1076 GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
1077 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
1078
1079 /* Various Debug counters */
1080 GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
1081 #ifdef CONFIG_CIFS_STATS2
1082 GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
1083 GLOBAL_EXTERN atomic_t totSmBufAllocCount;
1084 #endif
1085 GLOBAL_EXTERN atomic_t smBufAllocCount;
1086 GLOBAL_EXTERN atomic_t midCount;
1087
1088 /* Misc globals */
1089 GLOBAL_EXTERN bool enable_oplocks; /* enable or disable oplocks */
1090 GLOBAL_EXTERN unsigned int lookupCacheEnabled;
1091 GLOBAL_EXTERN unsigned int global_secflags;     /* if on, session setup sent
1092                                 with more secure ntlmssp2 challenge/resp */
1093 GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
1094 GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
1095 GLOBAL_EXTERN unsigned int CIFSMaxBufSize;  /* max size not including hdr */
1096 GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
1097 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf pool */
1098 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
1099
1100 #ifdef CONFIG_CIFS_ACL
1101 GLOBAL_EXTERN struct rb_root uidtree;
1102 GLOBAL_EXTERN struct rb_root gidtree;
1103 GLOBAL_EXTERN spinlock_t siduidlock;
1104 GLOBAL_EXTERN spinlock_t sidgidlock;
1105 GLOBAL_EXTERN struct rb_root siduidtree;
1106 GLOBAL_EXTERN struct rb_root sidgidtree;
1107 GLOBAL_EXTERN spinlock_t uidsidlock;
1108 GLOBAL_EXTERN spinlock_t gidsidlock;
1109 #endif /* CONFIG_CIFS_ACL */
1110
1111 void cifs_oplock_break(struct work_struct *work);
1112
1113 extern const struct slow_work_ops cifs_oplock_break_ops;
1114 extern struct workqueue_struct *cifsiod_wq;
1115
1116 /* Operations for different SMB versions */
1117 #define SMB1_VERSION_STRING     "1.0"
1118 extern struct smb_version_operations smb1_operations;
1119 extern struct smb_version_values smb1_values;
1120 #endif  /* _CIFS_GLOB_H */