fs/cifs/cifsglob.h

   1 /*
   2  *   fs/cifs/cifsglob.h
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2005
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  */
  18 #include <linux/in.h>
  19 #include <linux/in6.h>
  20 #include "cifs_fs_sb.h"
  21 /*
  22  * The sizes of various internal tables and strings
  23  */
  24 #define MAX_UID_INFO 16
  25 #define MAX_SES_INFO 2
  26 #define MAX_TCON_INFO 4
  27
  28 #define MAX_TREE_SIZE 2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1
  29 #define MAX_SERVER_SIZE 15
  30 #define MAX_SHARE_SIZE  64      /* used to be 20 - this should still be enough */
  31 #define MAX_USERNAME_SIZE 32    /* 32 is to allow for 15 char names + null
  32                                    termination then *2 for unicode versions */
  33 #define MAX_PASSWORD_SIZE 16
  34
  35 #define CIFS_MIN_RCV_POOL 4
  36
  37 /*
  38  * MAX_REQ is the maximum number of requests that WE will send
  39  * on one socket concurently. It also matches the most common
  40  * value of max multiplex returned by servers.  We may
  41  * eventually want to use the negotiated value (in case
  42  * future servers can handle more) when we are more confident that
  43  * we will not have problems oveloading the socket with pending
  44  * write data.
  45  */
  46 #define CIFS_MAX_REQ 50
  47
  48 #define SERVER_NAME_LENGTH 15
  49 #define SERVER_NAME_LEN_WITH_NULL     (SERVER_NAME_LENGTH + 1)
  50
  51 /* used to define string lengths for reversing unicode strings */
  52 /*         (256+1)*2 = 514                                     */
  53 /*           (max path length + 1 for null) * 2 for unicode    */
  54 #define MAX_NAME 514
  55
  56 #include "cifspdu.h"
  57
  58 #ifndef FALSE
  59 #define FALSE 0
  60 #endif
  61
  62 #ifndef TRUE
  63 #define TRUE 1
  64 #endif
  65
  66 #ifndef XATTR_DOS_ATTRIB
  67 #define XATTR_DOS_ATTRIB "user.DOSATTRIB"
  68 #endif
  69
  70 /*
  71  * This information is kept on every Server we know about.
  72  *
  73  * Some things to note:
  74  *
  75  */
  76 #define SERVER_NAME_LEN_WITH_NULL       (SERVER_NAME_LENGTH + 1)
  77
  78 /*
  79  * CIFS vfs client Status information (based on what we know.)
  80  */
  81
  82  /* associated with each tcp and smb session */
  83 enum statusEnum {
  84         CifsNew = 0,
  85         CifsGood,
  86         CifsExiting,
  87         CifsNeedReconnect
  88 };
  89
  90 enum securityEnum {
  91         NTLM = 0,               /* Legacy NTLM012 auth with NTLM hash */
  92         NTLMv2,                 /* Legacy NTLM auth with NTLMv2 hash */
  93         RawNTLMSSP,             /* NTLMSSP without SPNEGO */
  94         NTLMSSP,                /* NTLMSSP via SPNEGO */
  95         Kerberos                /* Kerberos via SPNEGO */
  96 };
  97
  98 enum protocolEnum {
  99         IPV4 = 0,
 100         IPV6,
 101         SCTP
 102         /* Netbios frames protocol not supported at this time */
 103 };
 104
 105 /*
 106  *****************************************************************
 107  * Except the CIFS PDUs themselves all the
 108  * globally interesting structs should go here
 109  *****************************************************************
 110  */
 111
 112 struct TCP_Server_Info {
 113         /* 15 character server name + 0x20 16th byte indicating type = srv */
 114         char server_RFC1001_name[SERVER_NAME_LEN_WITH_NULL];
 115         char unicode_server_Name[SERVER_NAME_LEN_WITH_NULL * 2];
 116         struct socket *ssocket;
 117         union {
 118                 struct sockaddr_in sockAddr;
 119                 struct sockaddr_in6 sockAddr6;
 120         } addr;
 121         wait_queue_head_t response_q;
 122         wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
 123         struct list_head pending_mid_q;
 124         void *Server_NlsInfo;   /* BB - placeholder for future NLS info  */
 125         unsigned short server_codepage; /* codepage for the server    */
 126         unsigned long ip_address;       /* IP addr for the server if known */
 127         enum protocolEnum protocolType;
 128         char versionMajor;
 129         char versionMinor;
 130         unsigned svlocal:1;     /* local server or remote */
 131         atomic_t socketUseCount; /* number of open cifs sessions on socket */
 132         atomic_t inFlight;  /* number of requests on the wire to server */
 133 #ifdef CONFIG_CIFS_STATS2
 134         atomic_t inSend; /* requests trying to send */
 135         atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
 136 #endif
 137         enum statusEnum tcpStatus; /* what we think the status is */
 138         struct semaphore tcpSem;
 139         struct task_struct *tsk;
 140         char server_GUID[16];
 141         char secMode;
 142         enum securityEnum secType;
 143         unsigned int maxReq;    /* Clients should submit no more */
 144         /* than maxReq distinct unanswered SMBs to the server when using  */
 145         /* multiplexed reads or writes */
 146         unsigned int maxBuf;    /* maxBuf specifies the maximum */
 147         /* message size the server can send or receive for non-raw SMBs */
 148         unsigned int maxRw;     /* maxRw specifies the maximum */
 149         /* message size the server can send or receive for */
 150         /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
 151         char sessid[4];         /* unique token id for this session */
 152         /* (returned on Negotiate */
 153         int capabilities; /* allow selective disabling of caps by smb sess */
 154         __u16 timeZone;
 155         __u16 CurrentMid;         /* multiplex id - rotating counter */
 156         char cryptKey[CIFS_CRYPTO_KEY_SIZE];
 157         /* 16th byte of RFC1001 workstation name is always null */
 158         char workstation_RFC1001_name[SERVER_NAME_LEN_WITH_NULL];
 159         __u32 sequence_number; /* needed for CIFS PDU signature */
 160         char mac_signing_key[CIFS_SESSION_KEY_SIZE + 16];
 161 };
 162
 163 /*
 164  * The following is our shortcut to user information.  We surface the uid,
 165  * and name. We always get the password on the fly in case it
 166  * has changed. We also hang a list of sessions owned by this user off here.
 167  */
 168 struct cifsUidInfo {
 169         struct list_head userList;
 170         struct list_head sessionList; /* SMB sessions for this user */
 171         uid_t linux_uid;
 172         char user[MAX_USERNAME_SIZE + 1];       /* ascii name of user */
 173         /* BB may need ptr or callback for PAM or WinBind info */
 174 };
 175
 176 /*
 177  * Session structure.  One of these for each uid session with a particular host
 178  */
 179 struct cifsSesInfo {
 180         struct list_head cifsSessionList;
 181         struct semaphore sesSem;
 182         struct cifsUidInfo *uidInfo;    /* pointer to user info */
 183         struct TCP_Server_Info *server; /* pointer to server info */
 184         atomic_t inUse; /* # of mounts (tree connections) on this ses */
 185         enum statusEnum status;
 186         __u16 ipc_tid;          /* special tid for connection to IPC share */
 187         __u16 flags;
 188         char *serverOS;         /* name of operating system underlying server */
 189         char *serverNOS;        /* name of network operating system of server */
 190         char *serverDomain;     /* security realm of server */
 191         int Suid;               /* remote smb uid  */
 192         uid_t linux_uid;        /* local Linux uid */
 193         int capabilities;
 194         char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
 195                                 TCP names - will ipv6 and sctp addresses fit? */
 196         char userName[MAX_USERNAME_SIZE + 1];
 197         char domainName[MAX_USERNAME_SIZE + 1];
 198         char * password;
 199 };
 200 /* session flags */
 201 #define CIFS_SES_NT4 1
 202
 203 /*
 204  * there is one of these for each connection to a resource on a particular
 205  * session
 206  */
 207 struct cifsTconInfo {
 208         struct list_head cifsConnectionList;
 209         struct list_head openFileList;
 210         struct semaphore tconSem;
 211         struct cifsSesInfo *ses;        /* pointer to session associated with */
 212         char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource (in ASCII not UTF) */
 213         char *nativeFileSystem;
 214         __u16 tid;              /* The 2 byte tree id */
 215         __u16 Flags;            /* optional support bits */
 216         enum statusEnum tidStatus;
 217         atomic_t useCount;      /* how many mounts (explicit or implicit) to this share */
 218 #ifdef CONFIG_CIFS_STATS
 219         atomic_t num_smbs_sent;
 220         atomic_t num_writes;
 221         atomic_t num_reads;
 222         atomic_t num_oplock_brks;
 223         atomic_t num_opens;
 224         atomic_t num_closes;
 225         atomic_t num_deletes;
 226         atomic_t num_mkdirs;
 227         atomic_t num_rmdirs;
 228         atomic_t num_renames;
 229         atomic_t num_t2renames;
 230         atomic_t num_ffirst;
 231         atomic_t num_fnext;
 232         atomic_t num_fclose;
 233         atomic_t num_hardlinks;
 234         atomic_t num_symlinks;
 235         atomic_t num_locks;
 236         atomic_t num_acl_get;
 237         atomic_t num_acl_set;
 238 #ifdef CONFIG_CIFS_STATS2
 239         unsigned long long time_writes;
 240         unsigned long long time_reads;
 241         unsigned long long time_opens;
 242         unsigned long long time_deletes;
 243         unsigned long long time_closes;
 244         unsigned long long time_mkdirs;
 245         unsigned long long time_rmdirs;
 246         unsigned long long time_renames;
 247         unsigned long long time_t2renames;
 248         unsigned long long time_ffirst;
 249         unsigned long long time_fnext;
 250         unsigned long long time_fclose;
 251 #endif /* CONFIG_CIFS_STATS2 */
 252         __u64    bytes_read;
 253         __u64    bytes_written;
 254         spinlock_t stat_lock;
 255 #endif /* CONFIG_CIFS_STATS */
 256         FILE_SYSTEM_DEVICE_INFO fsDevInfo;
 257         FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo;  /* ok if file system name truncated */
 258         FILE_SYSTEM_UNIX_INFO fsUnixInfo;
 259         unsigned retry:1;
 260         unsigned nocase:1;
 261         /* BB add field for back pointer to sb struct? */
 262 };
 263
 264 /*
 265  * This info hangs off the cifsFileInfo structure.  This is used to track
 266  * byte stream locks on the file
 267  */
 268 struct cifsLockInfo {
 269         struct cifsLockInfo *next;
 270         int start;
 271         int length;
 272         int type;
 273 };
 274
 275 /*
 276  * One of these for each open instance of a file
 277  */
 278 struct cifs_search_info {
 279         loff_t index_of_last_entry;
 280         __u16 entries_in_buffer;
 281         __u16 info_level;
 282         __u32 resume_key;
 283         char * ntwrk_buf_start;
 284         char * srch_entries_start;
 285         char * presume_name;
 286         unsigned int resume_name_len;
 287         unsigned endOfSearch:1;
 288         unsigned emptyDir:1;
 289         unsigned unicode:1;
 290         unsigned smallBuf:1; /* so we know which buf_release function to call */
 291 };
 292
 293 struct cifsFileInfo {
 294         struct list_head tlist; /* pointer to next fid owned by tcon */
 295         struct list_head flist; /* next fid (file instance) for this inode */
 296         unsigned int uid;       /* allows finding which FileInfo structure */
 297         __u32 pid;              /* process id who opened file */
 298         __u16 netfid;           /* file id from remote */
 299         /* BB add lock scope info here if needed */ ;
 300         /* lock scope id (0 if none) */
 301         struct file * pfile; /* needed for writepage */
 302         struct inode * pInode; /* needed for oplock break */
 303         unsigned closePend:1;   /* file is marked to close */
 304         unsigned invalidHandle:1;  /* file closed via session abend */
 305         atomic_t wrtPending;   /* handle in use - defer close */
 306         struct semaphore fh_sem; /* prevents reopen race after dead ses*/
 307         char * search_resume_name; /* BB removeme BB */
 308         unsigned int resume_name_length; /* BB removeme - field renamed and moved BB */
 309         struct cifs_search_info srch_inf;
 310 };
 311
 312 /*
 313  * One of these for each file inode
 314  */
 315
 316 struct cifsInodeInfo {
 317         struct list_head lockList;
 318         /* BB add in lists for dirty pages - i.e. write caching info for oplock */
 319         struct list_head openFileList;
 320         int write_behind_rc;
 321         __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
 322         atomic_t inUse;  /* num concurrent users (local openers cifs) of file*/
 323         unsigned long time;     /* jiffies of last update/check of inode */
 324         unsigned clientCanCacheRead:1; /* read oplock */
 325         unsigned clientCanCacheAll:1;  /* read and writebehind oplock */
 326         unsigned oplockPending:1;
 327         struct inode vfs_inode;
 328 };
 329
 330 static inline struct cifsInodeInfo *
 331 CIFS_I(struct inode *inode)
 332 {
 333         return container_of(inode, struct cifsInodeInfo, vfs_inode);
 334 }
 335
 336 static inline struct cifs_sb_info *
 337 CIFS_SB(struct super_block *sb)
 338 {
 339         return sb->s_fs_info;
 340 }
 341
 342 static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
 343 {
 344         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 345                 return '/';
 346         else
 347                 return '\\';
 348 }
 349
 350 #ifdef CONFIG_CIFS_STATS
 351 #define cifs_stats_inc atomic_inc
 352
 353 static inline void cifs_stats_bytes_written(struct cifsTconInfo *tcon,
 354                                             unsigned int bytes)
 355 {
 356         if (bytes) {
 357                 spin_lock(&tcon->stat_lock);
 358                 tcon->bytes_written += bytes;
 359                 spin_unlock(&tcon->stat_lock);
 360         }
 361 }
 362
 363 static inline void cifs_stats_bytes_read(struct cifsTconInfo *tcon,
 364                                          unsigned int bytes)
 365 {
 366         spin_lock(&tcon->stat_lock);
 367         tcon->bytes_read += bytes;
 368         spin_unlock(&tcon->stat_lock);
 369 }
 370 #else
 371
 372 #define  cifs_stats_inc(field) do {} while(0)
 373 #define  cifs_stats_bytes_written(tcon, bytes) do {} while(0)
 374 #define  cifs_stats_bytes_read(tcon, bytes) do {} while(0)
 375
 376 #endif
 377
 378 /* one of these for every pending CIFS request to the server */
 379 struct mid_q_entry {
 380         struct list_head qhead; /* mids waiting on reply from this server */
 381         __u16 mid;              /* multiplex id */
 382         __u16 pid;              /* process id */
 383         __u32 sequence_number;  /* for CIFS signing */
 384         unsigned long when_alloc;  /* when mid was created */
 385 #ifdef CONFIG_CIFS_STATS2
 386         unsigned long when_sent; /* time when smb send finished */
 387         unsigned long when_received; /* when demux complete (taken off wire) */
 388 #endif
 389         struct cifsSesInfo *ses;        /* smb was sent to this server */
 390         struct task_struct *tsk;        /* task waiting for response */
 391         struct smb_hdr *resp_buf;       /* response buffer */
 392         int midState;   /* wish this were enum but can not pass to wait_event */
 393         __u8 command;   /* smb command code */
 394         unsigned multiPart:1;   /* multiple responses to one SMB request */
 395         unsigned largeBuf:1;    /* if valid response, is pointer to large buf */
 396         unsigned multiResp:1;   /* multiple trans2 responses for one request  */
 397 };
 398
 399 struct oplock_q_entry {
 400         struct list_head qhead;
 401         struct inode * pinode;
 402         struct cifsTconInfo * tcon;
 403         __u16 netfid;
 404 };
 405
 406 /* for pending dnotify requests */
 407 struct dir_notify_req {
 408        struct list_head lhead;
 409        __le16 Pid;
 410        __le16 PidHigh;
 411        __u16 Mid;
 412        __u16 Tid;
 413        __u16 Uid;
 414        __u16 netfid;
 415        __u32 filter; /* CompletionFilter (for multishot) */
 416        int multishot;
 417        struct file * pfile;
 418 };
 419
 420 #define   MID_FREE 0
 421 #define   MID_REQUEST_ALLOCATED 1
 422 #define   MID_REQUEST_SUBMITTED 2
 423 #define   MID_RESPONSE_RECEIVED 4
 424 #define   MID_RETRY_NEEDED      8 /* session closed while this request out */
 425 #define   MID_NO_RESP_NEEDED 0x10
 426
 427 /* Types of response buffer returned from SendReceive2 */
 428 #define   CIFS_NO_BUFFER        0    /* Response buffer not returned */
 429 #define   CIFS_SMALL_BUFFER     1
 430 #define   CIFS_LARGE_BUFFER     2
 431 #define   CIFS_IOVEC            4    /* array of response buffers */
 432
 433 /*
 434  *****************************************************************
 435  * All constants go here
 436  *****************************************************************
 437  */
 438
 439 #define UID_HASH (16)
 440
 441 /*
 442  * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
 443  * following to be declared.
 444  */
 445
 446 /****************************************************************************
 447  *  Locking notes.  All updates to global variables and lists should be
 448  *                  protected by spinlocks or semaphores.
 449  *
 450  *  Spinlocks
 451  *  ---------
 452  *  GlobalMid_Lock protects:
 453  *      list operations on pending_mid_q and oplockQ
 454  *      updates to XID counters, multiplex id  and SMB sequence numbers
 455  *  GlobalSMBSesLock protects:
 456  *      list operations on tcp and SMB session lists and tCon lists
 457  *  f_owner.lock protects certain per file struct operations
 458  *  mapping->page_lock protects certain per page operations
 459  *
 460  *  Semaphores
 461  *  ----------
 462  *  sesSem     operations on smb session
 463  *  tconSem    operations on tree connection
 464  *  fh_sem      file handle reconnection operations
 465  *
 466  ****************************************************************************/
 467
 468 #ifdef DECLARE_GLOBALS_HERE
 469 #define GLOBAL_EXTERN
 470 #else
 471 #define GLOBAL_EXTERN extern
 472 #endif
 473
 474 /*
 475  * The list of servers that did not respond with NT LM 0.12.
 476  * This list helps improve performance and eliminate the messages indicating
 477  * that we had a communications error talking to the server in this list.
 478  */
 479 GLOBAL_EXTERN struct servers_not_supported *NotSuppList;        /*@z4a */
 480
 481 /*
 482  * The following is a hash table of all the users we know about.
 483  */
 484 GLOBAL_EXTERN struct smbUidInfo *GlobalUidList[UID_HASH];
 485
 486 GLOBAL_EXTERN struct list_head GlobalServerList; /* BB not implemented yet */
 487 GLOBAL_EXTERN struct list_head GlobalSMBSessionList;
 488 GLOBAL_EXTERN struct list_head GlobalTreeConnectionList;
 489 GLOBAL_EXTERN rwlock_t GlobalSMBSeslock;  /* protects list inserts on 3 above */
 490
 491 GLOBAL_EXTERN struct list_head GlobalOplock_Q;
 492
 493 GLOBAL_EXTERN struct list_head GlobalDnotifyReqList; /* Outstanding dir notify requests */
 494 GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q; /* Dir notify response queue */
 495
 496 /*
 497  * Global transaction id (XID) information
 498  */
 499 GLOBAL_EXTERN unsigned int GlobalCurrentXid;    /* protected by GlobalMid_Sem */
 500 GLOBAL_EXTERN unsigned int GlobalTotalActiveXid;        /* prot by GlobalMid_Sem */
 501 GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;  /* prot by GlobalMid_Sem */
 502 GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above and list operations */
 503                                         /* on midQ entries */
 504 GLOBAL_EXTERN char Local_System_Name[15];
 505
 506 /*
 507  *  Global counters, updated atomically
 508  */
 509 GLOBAL_EXTERN atomic_t sesInfoAllocCount;
 510 GLOBAL_EXTERN atomic_t tconInfoAllocCount;
 511 GLOBAL_EXTERN atomic_t tcpSesAllocCount;
 512 GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
 513 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
 514
 515 /* Various Debug counters to remove someday (BB) */
 516 GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
 517 #ifdef CONFIG_CIFS_STATS2
 518 GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
 519 GLOBAL_EXTERN atomic_t totSmBufAllocCount;
 520 #endif
 521 GLOBAL_EXTERN atomic_t smBufAllocCount;
 522 GLOBAL_EXTERN atomic_t midCount;
 523
 524 /* Misc globals */
 525 GLOBAL_EXTERN unsigned int multiuser_mount;     /* if enabled allows new sessions
 526                                 to be established on existing mount if we
 527                                 have the uid/password or Kerberos credential
 528                                 or equivalent for current user */
 529 GLOBAL_EXTERN unsigned int oplockEnabled;
 530 GLOBAL_EXTERN unsigned int experimEnabled;
 531 GLOBAL_EXTERN unsigned int lookupCacheEnabled;
 532 GLOBAL_EXTERN unsigned int extended_security;   /* if on, session setup sent
 533                                 with more secure ntlmssp2 challenge/resp */
 534 GLOBAL_EXTERN unsigned int ntlmv2_support;  /* better optional password hash */
 535 GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
 536 GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
 537 GLOBAL_EXTERN unsigned int CIFSMaxBufSize;  /* max size not including hdr */
 538 GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
 539 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf pool */
 540 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
 541