542 строки
18 KiB
C
542 строки
18 KiB
C
/*
|
|
* fs/cifs/cifsglob.h
|
|
*
|
|
* Copyright (C) International Business Machines Corp., 2002,2005
|
|
* Author(s): Steve French (sfrench@us.ibm.com)
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published
|
|
* by the Free Software Foundation; either version 2.1 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
* the GNU Lesser General Public License for more details.
|
|
*
|
|
*/
|
|
#include <linux/in.h>
|
|
#include <linux/in6.h>
|
|
#include "cifs_fs_sb.h"
|
|
/*
|
|
* The sizes of various internal tables and strings
|
|
*/
|
|
#define MAX_UID_INFO 16
|
|
#define MAX_SES_INFO 2
|
|
#define MAX_TCON_INFO 4
|
|
|
|
#define MAX_TREE_SIZE 2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1
|
|
#define MAX_SERVER_SIZE 15
|
|
#define MAX_SHARE_SIZE 64 /* used to be 20 - this should still be enough */
|
|
#define MAX_USERNAME_SIZE 32 /* 32 is to allow for 15 char names + null
|
|
termination then *2 for unicode versions */
|
|
#define MAX_PASSWORD_SIZE 16
|
|
|
|
#define CIFS_MIN_RCV_POOL 4
|
|
|
|
/*
|
|
* MAX_REQ is the maximum number of requests that WE will send
|
|
* on one socket concurently. It also matches the most common
|
|
* value of max multiplex returned by servers. We may
|
|
* eventually want to use the negotiated value (in case
|
|
* future servers can handle more) when we are more confident that
|
|
* we will not have problems oveloading the socket with pending
|
|
* write data.
|
|
*/
|
|
#define CIFS_MAX_REQ 50
|
|
|
|
#define SERVER_NAME_LENGTH 15
|
|
#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
|
|
|
|
/* used to define string lengths for reversing unicode strings */
|
|
/* (256+1)*2 = 514 */
|
|
/* (max path length + 1 for null) * 2 for unicode */
|
|
#define MAX_NAME 514
|
|
|
|
#include "cifspdu.h"
|
|
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
|
|
#ifndef XATTR_DOS_ATTRIB
|
|
#define XATTR_DOS_ATTRIB "user.DOSATTRIB"
|
|
#endif
|
|
|
|
/*
|
|
* This information is kept on every Server we know about.
|
|
*
|
|
* Some things to note:
|
|
*
|
|
*/
|
|
#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1)
|
|
|
|
/*
|
|
* CIFS vfs client Status information (based on what we know.)
|
|
*/
|
|
|
|
/* associated with each tcp and smb session */
|
|
enum statusEnum {
|
|
CifsNew = 0,
|
|
CifsGood,
|
|
CifsExiting,
|
|
CifsNeedReconnect
|
|
};
|
|
|
|
enum securityEnum {
|
|
NTLM = 0, /* Legacy NTLM012 auth with NTLM hash */
|
|
NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */
|
|
RawNTLMSSP, /* NTLMSSP without SPNEGO */
|
|
NTLMSSP, /* NTLMSSP via SPNEGO */
|
|
Kerberos /* Kerberos via SPNEGO */
|
|
};
|
|
|
|
enum protocolEnum {
|
|
IPV4 = 0,
|
|
IPV6,
|
|
SCTP
|
|
/* Netbios frames protocol not supported at this time */
|
|
};
|
|
|
|
/*
|
|
*****************************************************************
|
|
* Except the CIFS PDUs themselves all the
|
|
* globally interesting structs should go here
|
|
*****************************************************************
|
|
*/
|
|
|
|
struct TCP_Server_Info {
|
|
/* 15 character server name + 0x20 16th byte indicating type = srv */
|
|
char server_RFC1001_name[SERVER_NAME_LEN_WITH_NULL];
|
|
char unicode_server_Name[SERVER_NAME_LEN_WITH_NULL * 2];
|
|
struct socket *ssocket;
|
|
union {
|
|
struct sockaddr_in sockAddr;
|
|
struct sockaddr_in6 sockAddr6;
|
|
} addr;
|
|
wait_queue_head_t response_q;
|
|
wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/
|
|
struct list_head pending_mid_q;
|
|
void *Server_NlsInfo; /* BB - placeholder for future NLS info */
|
|
unsigned short server_codepage; /* codepage for the server */
|
|
unsigned long ip_address; /* IP addr for the server if known */
|
|
enum protocolEnum protocolType;
|
|
char versionMajor;
|
|
char versionMinor;
|
|
unsigned svlocal:1; /* local server or remote */
|
|
atomic_t socketUseCount; /* number of open cifs sessions on socket */
|
|
atomic_t inFlight; /* number of requests on the wire to server */
|
|
#ifdef CONFIG_CIFS_STATS2
|
|
atomic_t inSend; /* requests trying to send */
|
|
atomic_t num_waiters; /* blocked waiting to get in sendrecv */
|
|
#endif
|
|
enum statusEnum tcpStatus; /* what we think the status is */
|
|
struct semaphore tcpSem;
|
|
struct task_struct *tsk;
|
|
char server_GUID[16];
|
|
char secMode;
|
|
enum securityEnum secType;
|
|
unsigned int maxReq; /* Clients should submit no more */
|
|
/* than maxReq distinct unanswered SMBs to the server when using */
|
|
/* multiplexed reads or writes */
|
|
unsigned int maxBuf; /* maxBuf specifies the maximum */
|
|
/* message size the server can send or receive for non-raw SMBs */
|
|
unsigned int maxRw; /* maxRw specifies the maximum */
|
|
/* message size the server can send or receive for */
|
|
/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
|
|
char sessid[4]; /* unique token id for this session */
|
|
/* (returned on Negotiate */
|
|
int capabilities; /* allow selective disabling of caps by smb sess */
|
|
__u16 timeZone;
|
|
__u16 CurrentMid; /* multiplex id - rotating counter */
|
|
char cryptKey[CIFS_CRYPTO_KEY_SIZE];
|
|
/* 16th byte of RFC1001 workstation name is always null */
|
|
char workstation_RFC1001_name[SERVER_NAME_LEN_WITH_NULL];
|
|
__u32 sequence_number; /* needed for CIFS PDU signature */
|
|
char mac_signing_key[CIFS_SESSION_KEY_SIZE + 16];
|
|
};
|
|
|
|
/*
|
|
* The following is our shortcut to user information. We surface the uid,
|
|
* and name. We always get the password on the fly in case it
|
|
* has changed. We also hang a list of sessions owned by this user off here.
|
|
*/
|
|
struct cifsUidInfo {
|
|
struct list_head userList;
|
|
struct list_head sessionList; /* SMB sessions for this user */
|
|
uid_t linux_uid;
|
|
char user[MAX_USERNAME_SIZE + 1]; /* ascii name of user */
|
|
/* BB may need ptr or callback for PAM or WinBind info */
|
|
};
|
|
|
|
/*
|
|
* Session structure. One of these for each uid session with a particular host
|
|
*/
|
|
struct cifsSesInfo {
|
|
struct list_head cifsSessionList;
|
|
struct semaphore sesSem;
|
|
struct cifsUidInfo *uidInfo; /* pointer to user info */
|
|
struct TCP_Server_Info *server; /* pointer to server info */
|
|
atomic_t inUse; /* # of mounts (tree connections) on this ses */
|
|
enum statusEnum status;
|
|
__u16 ipc_tid; /* special tid for connection to IPC share */
|
|
__u16 flags;
|
|
char *serverOS; /* name of operating system underlying server */
|
|
char *serverNOS; /* name of network operating system of server */
|
|
char *serverDomain; /* security realm of server */
|
|
int Suid; /* remote smb uid */
|
|
uid_t linux_uid; /* local Linux uid */
|
|
int capabilities;
|
|
char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for
|
|
TCP names - will ipv6 and sctp addresses fit? */
|
|
char userName[MAX_USERNAME_SIZE + 1];
|
|
char domainName[MAX_USERNAME_SIZE + 1];
|
|
char * password;
|
|
};
|
|
/* session flags */
|
|
#define CIFS_SES_NT4 1
|
|
|
|
/*
|
|
* there is one of these for each connection to a resource on a particular
|
|
* session
|
|
*/
|
|
struct cifsTconInfo {
|
|
struct list_head cifsConnectionList;
|
|
struct list_head openFileList;
|
|
struct semaphore tconSem;
|
|
struct cifsSesInfo *ses; /* pointer to session associated with */
|
|
char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource (in ASCII not UTF) */
|
|
char *nativeFileSystem;
|
|
__u16 tid; /* The 2 byte tree id */
|
|
__u16 Flags; /* optional support bits */
|
|
enum statusEnum tidStatus;
|
|
atomic_t useCount; /* how many mounts (explicit or implicit) to this share */
|
|
#ifdef CONFIG_CIFS_STATS
|
|
atomic_t num_smbs_sent;
|
|
atomic_t num_writes;
|
|
atomic_t num_reads;
|
|
atomic_t num_oplock_brks;
|
|
atomic_t num_opens;
|
|
atomic_t num_closes;
|
|
atomic_t num_deletes;
|
|
atomic_t num_mkdirs;
|
|
atomic_t num_rmdirs;
|
|
atomic_t num_renames;
|
|
atomic_t num_t2renames;
|
|
atomic_t num_ffirst;
|
|
atomic_t num_fnext;
|
|
atomic_t num_fclose;
|
|
atomic_t num_hardlinks;
|
|
atomic_t num_symlinks;
|
|
atomic_t num_locks;
|
|
atomic_t num_acl_get;
|
|
atomic_t num_acl_set;
|
|
#ifdef CONFIG_CIFS_STATS2
|
|
unsigned long long time_writes;
|
|
unsigned long long time_reads;
|
|
unsigned long long time_opens;
|
|
unsigned long long time_deletes;
|
|
unsigned long long time_closes;
|
|
unsigned long long time_mkdirs;
|
|
unsigned long long time_rmdirs;
|
|
unsigned long long time_renames;
|
|
unsigned long long time_t2renames;
|
|
unsigned long long time_ffirst;
|
|
unsigned long long time_fnext;
|
|
unsigned long long time_fclose;
|
|
#endif /* CONFIG_CIFS_STATS2 */
|
|
__u64 bytes_read;
|
|
__u64 bytes_written;
|
|
spinlock_t stat_lock;
|
|
#endif /* CONFIG_CIFS_STATS */
|
|
FILE_SYSTEM_DEVICE_INFO fsDevInfo;
|
|
FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if file system name truncated */
|
|
FILE_SYSTEM_UNIX_INFO fsUnixInfo;
|
|
unsigned retry:1;
|
|
unsigned nocase:1;
|
|
/* BB add field for back pointer to sb struct? */
|
|
};
|
|
|
|
/*
|
|
* This info hangs off the cifsFileInfo structure. This is used to track
|
|
* byte stream locks on the file
|
|
*/
|
|
struct cifsLockInfo {
|
|
struct cifsLockInfo *next;
|
|
int start;
|
|
int length;
|
|
int type;
|
|
};
|
|
|
|
/*
|
|
* One of these for each open instance of a file
|
|
*/
|
|
struct cifs_search_info {
|
|
loff_t index_of_last_entry;
|
|
__u16 entries_in_buffer;
|
|
__u16 info_level;
|
|
__u32 resume_key;
|
|
char * ntwrk_buf_start;
|
|
char * srch_entries_start;
|
|
char * presume_name;
|
|
unsigned int resume_name_len;
|
|
unsigned endOfSearch:1;
|
|
unsigned emptyDir:1;
|
|
unsigned unicode:1;
|
|
unsigned smallBuf:1; /* so we know which buf_release function to call */
|
|
};
|
|
|
|
struct cifsFileInfo {
|
|
struct list_head tlist; /* pointer to next fid owned by tcon */
|
|
struct list_head flist; /* next fid (file instance) for this inode */
|
|
unsigned int uid; /* allows finding which FileInfo structure */
|
|
__u32 pid; /* process id who opened file */
|
|
__u16 netfid; /* file id from remote */
|
|
/* BB add lock scope info here if needed */ ;
|
|
/* lock scope id (0 if none) */
|
|
struct file * pfile; /* needed for writepage */
|
|
struct inode * pInode; /* needed for oplock break */
|
|
unsigned closePend:1; /* file is marked to close */
|
|
unsigned invalidHandle:1; /* file closed via session abend */
|
|
atomic_t wrtPending; /* handle in use - defer close */
|
|
struct semaphore fh_sem; /* prevents reopen race after dead ses*/
|
|
char * search_resume_name; /* BB removeme BB */
|
|
unsigned int resume_name_length; /* BB removeme - field renamed and moved BB */
|
|
struct cifs_search_info srch_inf;
|
|
};
|
|
|
|
/*
|
|
* One of these for each file inode
|
|
*/
|
|
|
|
struct cifsInodeInfo {
|
|
struct list_head lockList;
|
|
/* BB add in lists for dirty pages - i.e. write caching info for oplock */
|
|
struct list_head openFileList;
|
|
int write_behind_rc;
|
|
__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */
|
|
atomic_t inUse; /* num concurrent users (local openers cifs) of file*/
|
|
unsigned long time; /* jiffies of last update/check of inode */
|
|
unsigned clientCanCacheRead:1; /* read oplock */
|
|
unsigned clientCanCacheAll:1; /* read and writebehind oplock */
|
|
unsigned oplockPending:1;
|
|
struct inode vfs_inode;
|
|
};
|
|
|
|
static inline struct cifsInodeInfo *
|
|
CIFS_I(struct inode *inode)
|
|
{
|
|
return container_of(inode, struct cifsInodeInfo, vfs_inode);
|
|
}
|
|
|
|
static inline struct cifs_sb_info *
|
|
CIFS_SB(struct super_block *sb)
|
|
{
|
|
return sb->s_fs_info;
|
|
}
|
|
|
|
static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
|
|
{
|
|
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
|
|
return '/';
|
|
else
|
|
return '\\';
|
|
}
|
|
|
|
#ifdef CONFIG_CIFS_STATS
|
|
#define cifs_stats_inc atomic_inc
|
|
|
|
static inline void cifs_stats_bytes_written(struct cifsTconInfo *tcon,
|
|
unsigned int bytes)
|
|
{
|
|
if (bytes) {
|
|
spin_lock(&tcon->stat_lock);
|
|
tcon->bytes_written += bytes;
|
|
spin_unlock(&tcon->stat_lock);
|
|
}
|
|
}
|
|
|
|
static inline void cifs_stats_bytes_read(struct cifsTconInfo *tcon,
|
|
unsigned int bytes)
|
|
{
|
|
spin_lock(&tcon->stat_lock);
|
|
tcon->bytes_read += bytes;
|
|
spin_unlock(&tcon->stat_lock);
|
|
}
|
|
#else
|
|
|
|
#define cifs_stats_inc(field) do {} while(0)
|
|
#define cifs_stats_bytes_written(tcon, bytes) do {} while(0)
|
|
#define cifs_stats_bytes_read(tcon, bytes) do {} while(0)
|
|
|
|
#endif
|
|
|
|
/* one of these for every pending CIFS request to the server */
|
|
struct mid_q_entry {
|
|
struct list_head qhead; /* mids waiting on reply from this server */
|
|
__u16 mid; /* multiplex id */
|
|
__u16 pid; /* process id */
|
|
__u32 sequence_number; /* for CIFS signing */
|
|
unsigned long when_alloc; /* when mid was created */
|
|
#ifdef CONFIG_CIFS_STATS2
|
|
unsigned long when_sent; /* time when smb send finished */
|
|
unsigned long when_received; /* when demux complete (taken off wire) */
|
|
#endif
|
|
struct cifsSesInfo *ses; /* smb was sent to this server */
|
|
struct task_struct *tsk; /* task waiting for response */
|
|
struct smb_hdr *resp_buf; /* response buffer */
|
|
int midState; /* wish this were enum but can not pass to wait_event */
|
|
__u8 command; /* smb command code */
|
|
unsigned multiPart:1; /* multiple responses to one SMB request */
|
|
unsigned largeBuf:1; /* if valid response, is pointer to large buf */
|
|
unsigned multiResp:1; /* multiple trans2 responses for one request */
|
|
};
|
|
|
|
struct oplock_q_entry {
|
|
struct list_head qhead;
|
|
struct inode * pinode;
|
|
struct cifsTconInfo * tcon;
|
|
__u16 netfid;
|
|
};
|
|
|
|
/* for pending dnotify requests */
|
|
struct dir_notify_req {
|
|
struct list_head lhead;
|
|
__le16 Pid;
|
|
__le16 PidHigh;
|
|
__u16 Mid;
|
|
__u16 Tid;
|
|
__u16 Uid;
|
|
__u16 netfid;
|
|
__u32 filter; /* CompletionFilter (for multishot) */
|
|
int multishot;
|
|
struct file * pfile;
|
|
};
|
|
|
|
#define MID_FREE 0
|
|
#define MID_REQUEST_ALLOCATED 1
|
|
#define MID_REQUEST_SUBMITTED 2
|
|
#define MID_RESPONSE_RECEIVED 4
|
|
#define MID_RETRY_NEEDED 8 /* session closed while this request out */
|
|
#define MID_NO_RESP_NEEDED 0x10
|
|
|
|
/* Types of response buffer returned from SendReceive2 */
|
|
#define CIFS_NO_BUFFER 0 /* Response buffer not returned */
|
|
#define CIFS_SMALL_BUFFER 1
|
|
#define CIFS_LARGE_BUFFER 2
|
|
#define CIFS_IOVEC 4 /* array of response buffers */
|
|
|
|
/*
|
|
*****************************************************************
|
|
* All constants go here
|
|
*****************************************************************
|
|
*/
|
|
|
|
#define UID_HASH (16)
|
|
|
|
/*
|
|
* Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the
|
|
* following to be declared.
|
|
*/
|
|
|
|
/****************************************************************************
|
|
* Locking notes. All updates to global variables and lists should be
|
|
* protected by spinlocks or semaphores.
|
|
*
|
|
* Spinlocks
|
|
* ---------
|
|
* GlobalMid_Lock protects:
|
|
* list operations on pending_mid_q and oplockQ
|
|
* updates to XID counters, multiplex id and SMB sequence numbers
|
|
* GlobalSMBSesLock protects:
|
|
* list operations on tcp and SMB session lists and tCon lists
|
|
* f_owner.lock protects certain per file struct operations
|
|
* mapping->page_lock protects certain per page operations
|
|
*
|
|
* Semaphores
|
|
* ----------
|
|
* sesSem operations on smb session
|
|
* tconSem operations on tree connection
|
|
* fh_sem file handle reconnection operations
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef DECLARE_GLOBALS_HERE
|
|
#define GLOBAL_EXTERN
|
|
#else
|
|
#define GLOBAL_EXTERN extern
|
|
#endif
|
|
|
|
/*
|
|
* The list of servers that did not respond with NT LM 0.12.
|
|
* This list helps improve performance and eliminate the messages indicating
|
|
* that we had a communications error talking to the server in this list.
|
|
*/
|
|
GLOBAL_EXTERN struct servers_not_supported *NotSuppList; /*@z4a */
|
|
|
|
/*
|
|
* The following is a hash table of all the users we know about.
|
|
*/
|
|
GLOBAL_EXTERN struct smbUidInfo *GlobalUidList[UID_HASH];
|
|
|
|
GLOBAL_EXTERN struct list_head GlobalServerList; /* BB not implemented yet */
|
|
GLOBAL_EXTERN struct list_head GlobalSMBSessionList;
|
|
GLOBAL_EXTERN struct list_head GlobalTreeConnectionList;
|
|
GLOBAL_EXTERN rwlock_t GlobalSMBSeslock; /* protects list inserts on 3 above */
|
|
|
|
GLOBAL_EXTERN struct list_head GlobalOplock_Q;
|
|
|
|
GLOBAL_EXTERN struct list_head GlobalDnotifyReqList; /* Outstanding dir notify requests */
|
|
GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q; /* Dir notify response queue */
|
|
|
|
/*
|
|
* Global transaction id (XID) information
|
|
*/
|
|
GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */
|
|
GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */
|
|
GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */
|
|
GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above and list operations */
|
|
/* on midQ entries */
|
|
GLOBAL_EXTERN char Local_System_Name[15];
|
|
|
|
/*
|
|
* Global counters, updated atomically
|
|
*/
|
|
GLOBAL_EXTERN atomic_t sesInfoAllocCount;
|
|
GLOBAL_EXTERN atomic_t tconInfoAllocCount;
|
|
GLOBAL_EXTERN atomic_t tcpSesAllocCount;
|
|
GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
|
|
GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
|
|
|
|
/* Various Debug counters to remove someday (BB) */
|
|
GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */
|
|
#ifdef CONFIG_CIFS_STATS2
|
|
GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
|
|
GLOBAL_EXTERN atomic_t totSmBufAllocCount;
|
|
#endif
|
|
GLOBAL_EXTERN atomic_t smBufAllocCount;
|
|
GLOBAL_EXTERN atomic_t midCount;
|
|
|
|
/* Misc globals */
|
|
GLOBAL_EXTERN unsigned int multiuser_mount; /* if enabled allows new sessions
|
|
to be established on existing mount if we
|
|
have the uid/password or Kerberos credential
|
|
or equivalent for current user */
|
|
GLOBAL_EXTERN unsigned int oplockEnabled;
|
|
GLOBAL_EXTERN unsigned int experimEnabled;
|
|
GLOBAL_EXTERN unsigned int lookupCacheEnabled;
|
|
GLOBAL_EXTERN unsigned int extended_security; /* if on, session setup sent
|
|
with more secure ntlmssp2 challenge/resp */
|
|
GLOBAL_EXTERN unsigned int ntlmv2_support; /* better optional password hash */
|
|
GLOBAL_EXTERN unsigned int sign_CIFS_PDUs; /* enable smb packet signing */
|
|
GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/
|
|
GLOBAL_EXTERN unsigned int CIFSMaxBufSize; /* max size not including hdr */
|
|
GLOBAL_EXTERN unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */
|
|
GLOBAL_EXTERN unsigned int cifs_min_small; /* min size of small buf pool */
|
|
GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/
|
|
|