006eb33bff5ff7e6a576b5804e95ec22eb50bb52
[linux-2.6.git] / fs / cifs / cifsglob.h
1 /*
2  *   fs/cifs/cifsglob.h
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2006
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 /* Type of session setup needed */
434 #define   CIFS_PLAINTEXT        0
435 #define   CIFS_LANMAN           1
436 #define   CIFS_NTLM             2
437 #define   CIFS_NTLMSSP_NEG      3
438 #define   CIFS_NTLMSSP_AUTH     4
439 #define   CIFS_SPNEGO_INIT      5
440 #define   CIFS_SPNEGO_TARG      6
441
442 /*
443  *****************************************************************
444  * All constants go here
445  *****************************************************************
446  */
447
448 #define UID_HASH (16)
449
450 /*
451  * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
452  * following to be declared.
453  */
454
455 /****************************************************************************
456  *  Locking notes.  All updates to global variables and lists should be
457  *                  protected by spinlocks or semaphores.
458  *
459  *  Spinlocks
460  *  ---------
461  *  GlobalMid_Lock protects:
462  *      list operations on pending_mid_q and oplockQ
463  *      updates to XID counters, multiplex id  and SMB sequence numbers
464  *  GlobalSMBSesLock protects:
465  *      list operations on tcp and SMB session lists and tCon lists
466  *  f_owner.lock protects certain per file struct operations
467  *  mapping->page_lock protects certain per page operations
468  *
469  *  Semaphores
470  *  ----------
471  *  sesSem     operations on smb session
472  *  tconSem    operations on tree connection
473  *  fh_sem      file handle reconnection operations 
474  *
475  ****************************************************************************/
476
477 #ifdef DECLARE_GLOBALS_HERE
478 #define GLOBAL_EXTERN
479 #else
480 #define GLOBAL_EXTERN extern
481 #endif
482
483 /*
484  * The list of servers that did not respond with NT LM 0.12.
485  * This list helps improve performance and eliminate the messages indicating
486  * that we had a communications error talking to the server in this list. 
487  */
488 GLOBAL_EXTERN struct servers_not_supported *NotSuppList;        /*@z4a */
489
490 /*
491  * The following is a hash table of all the users we know about.
492  */
493 GLOBAL_EXTERN struct smbUidInfo *GlobalUidList[UID_HASH];
494
495 GLOBAL_EXTERN struct list_head GlobalServerList; /* BB not implemented yet */
496 GLOBAL_EXTERN struct list_head GlobalSMBSessionList;
497 GLOBAL_EXTERN struct list_head GlobalTreeConnectionList;
498 GLOBAL_EXTERN rwlock_t GlobalSMBSeslock;  /* protects list inserts on 3 above */
499
500 GLOBAL_EXTERN struct list_head GlobalOplock_Q;
501
502 GLOBAL_EXTERN struct list_head GlobalDnotifyReqList; /* Outstanding dir notify requests */
503 GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q; /* Dir notify response queue */
504
505 /*
506  * Global transaction id (XID) information
507  */
508 GLOBAL_EXTERN unsigned int GlobalCurrentXid;    /* protected by GlobalMid_Sem */
509 GLOBAL_EXTERN unsigned int GlobalTotalActiveXid;        /* prot by GlobalMid_Sem */
510 GLOBAL_EXTERN unsigned int GlobalMaxActiveXid;  /* prot by GlobalMid_Sem */
511 GLOBAL_EXTERN spinlock_t GlobalMid_Lock;  /* protects above and list operations */
512                                         /* on midQ entries */
513 GLOBAL_EXTERN char Local_System_Name[15];
514
515 /*
516  *  Global counters, updated atomically
517  */
518 GLOBAL_EXTERN atomic_t sesInfoAllocCount;
519 GLOBAL_EXTERN atomic_t tconInfoAllocCount;
520 GLOBAL_EXTERN atomic_t tcpSesAllocCount;
521 GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
522 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
523
524 /* Various Debug counters to remove someday (BB) */
525 GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
526 #ifdef CONFIG_CIFS_STATS2
527 GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
528 GLOBAL_EXTERN atomic_t totSmBufAllocCount;
529 #endif
530 GLOBAL_EXTERN atomic_t smBufAllocCount;
531 GLOBAL_EXTERN atomic_t midCount;
532
533 /* Misc globals */
534 GLOBAL_EXTERN unsigned int multiuser_mount;     /* if enabled allows new sessions
535                                 to be established on existing mount if we
536                                 have the uid/password or Kerberos credential 
537                                 or equivalent for current user */
538 GLOBAL_EXTERN unsigned int oplockEnabled;
539 GLOBAL_EXTERN unsigned int experimEnabled;
540 GLOBAL_EXTERN unsigned int lookupCacheEnabled;
541 GLOBAL_EXTERN unsigned int extended_security;   /* if on, session setup sent 
542                                 with more secure ntlmssp2 challenge/resp */
543 GLOBAL_EXTERN unsigned int ntlmv2_support;  /* better optional password hash */
544 GLOBAL_EXTERN unsigned int sign_CIFS_PDUs;  /* enable smb packet signing */
545 GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
546 GLOBAL_EXTERN unsigned int CIFSMaxBufSize;  /* max size not including hdr */
547 GLOBAL_EXTERN unsigned int cifs_min_rcv;    /* min size of big ntwrk buf pool */
548 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf pool */
549 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
550