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