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