138c8a9a5SSteve French // SPDX-License-Identifier: LGPL-2.1 238c8a9a5SSteve French /* 338c8a9a5SSteve French * 438c8a9a5SSteve French * Copyright (C) International Business Machines Corp., 2009, 2013 538c8a9a5SSteve French * Etersoft, 2012 638c8a9a5SSteve French * Author(s): Steve French (sfrench@us.ibm.com) 738c8a9a5SSteve French * Pavel Shilovsky (pshilovsky@samba.org) 2012 838c8a9a5SSteve French * 938c8a9a5SSteve French * Contains the routines for constructing the SMB2 PDUs themselves 1038c8a9a5SSteve French * 1138c8a9a5SSteve French */ 1238c8a9a5SSteve French 1338c8a9a5SSteve French /* SMB2 PDU handling routines here - except for leftovers (eg session setup) */ 1438c8a9a5SSteve French /* Note that there are handle based routines which must be */ 1538c8a9a5SSteve French /* treated slightly differently for reconnection purposes since we never */ 1638c8a9a5SSteve French /* want to reuse a stale file handle and only the caller knows the file info */ 1738c8a9a5SSteve French 1838c8a9a5SSteve French #include <linux/fs.h> 1938c8a9a5SSteve French #include <linux/kernel.h> 2038c8a9a5SSteve French #include <linux/vfs.h> 2138c8a9a5SSteve French #include <linux/task_io_accounting_ops.h> 2238c8a9a5SSteve French #include <linux/uaccess.h> 2338c8a9a5SSteve French #include <linux/uuid.h> 2438c8a9a5SSteve French #include <linux/pagemap.h> 2538c8a9a5SSteve French #include <linux/xattr.h> 2638c8a9a5SSteve French #include "cifsglob.h" 2738c8a9a5SSteve French #include "cifsacl.h" 2838c8a9a5SSteve French #include "cifsproto.h" 2938c8a9a5SSteve French #include "smb2proto.h" 3038c8a9a5SSteve French #include "cifs_unicode.h" 3138c8a9a5SSteve French #include "cifs_debug.h" 3238c8a9a5SSteve French #include "ntlmssp.h" 3338c8a9a5SSteve French #include "smb2status.h" 3438c8a9a5SSteve French #include "smb2glob.h" 3538c8a9a5SSteve French #include "cifspdu.h" 3638c8a9a5SSteve French #include "cifs_spnego.h" 3738c8a9a5SSteve French #include "smbdirect.h" 3838c8a9a5SSteve French #include "trace.h" 3938c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL 4038c8a9a5SSteve French #include "dfs_cache.h" 4138c8a9a5SSteve French #endif 4238c8a9a5SSteve French #include "cached_dir.h" 4338c8a9a5SSteve French 4438c8a9a5SSteve French /* 4538c8a9a5SSteve French * The following table defines the expected "StructureSize" of SMB2 requests 4638c8a9a5SSteve French * in order by SMB2 command. This is similar to "wct" in SMB/CIFS requests. 4738c8a9a5SSteve French * 4838c8a9a5SSteve French * Note that commands are defined in smb2pdu.h in le16 but the array below is 4938c8a9a5SSteve French * indexed by command in host byte order. 5038c8a9a5SSteve French */ 5138c8a9a5SSteve French static const int smb2_req_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = { 5238c8a9a5SSteve French /* SMB2_NEGOTIATE */ 36, 5338c8a9a5SSteve French /* SMB2_SESSION_SETUP */ 25, 5438c8a9a5SSteve French /* SMB2_LOGOFF */ 4, 5538c8a9a5SSteve French /* SMB2_TREE_CONNECT */ 9, 5638c8a9a5SSteve French /* SMB2_TREE_DISCONNECT */ 4, 5738c8a9a5SSteve French /* SMB2_CREATE */ 57, 5838c8a9a5SSteve French /* SMB2_CLOSE */ 24, 5938c8a9a5SSteve French /* SMB2_FLUSH */ 24, 6038c8a9a5SSteve French /* SMB2_READ */ 49, 6138c8a9a5SSteve French /* SMB2_WRITE */ 49, 6238c8a9a5SSteve French /* SMB2_LOCK */ 48, 6338c8a9a5SSteve French /* SMB2_IOCTL */ 57, 6438c8a9a5SSteve French /* SMB2_CANCEL */ 4, 6538c8a9a5SSteve French /* SMB2_ECHO */ 4, 6638c8a9a5SSteve French /* SMB2_QUERY_DIRECTORY */ 33, 6738c8a9a5SSteve French /* SMB2_CHANGE_NOTIFY */ 32, 6838c8a9a5SSteve French /* SMB2_QUERY_INFO */ 41, 6938c8a9a5SSteve French /* SMB2_SET_INFO */ 33, 7038c8a9a5SSteve French /* SMB2_OPLOCK_BREAK */ 24 /* BB this is 36 for LEASE_BREAK variant */ 7138c8a9a5SSteve French }; 7238c8a9a5SSteve French 7338c8a9a5SSteve French int smb3_encryption_required(const struct cifs_tcon *tcon) 7438c8a9a5SSteve French { 7538c8a9a5SSteve French if (!tcon || !tcon->ses) 7638c8a9a5SSteve French return 0; 7738c8a9a5SSteve French if ((tcon->ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) || 7838c8a9a5SSteve French (tcon->share_flags & SHI1005_FLAGS_ENCRYPT_DATA)) 7938c8a9a5SSteve French return 1; 8038c8a9a5SSteve French if (tcon->seal && 8138c8a9a5SSteve French (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)) 8238c8a9a5SSteve French return 1; 8338c8a9a5SSteve French return 0; 8438c8a9a5SSteve French } 8538c8a9a5SSteve French 8638c8a9a5SSteve French static void 8738c8a9a5SSteve French smb2_hdr_assemble(struct smb2_hdr *shdr, __le16 smb2_cmd, 8838c8a9a5SSteve French const struct cifs_tcon *tcon, 8938c8a9a5SSteve French struct TCP_Server_Info *server) 9038c8a9a5SSteve French { 9109ee7a3bSSteve French struct smb3_hdr_req *smb3_hdr; 922c75426cSSteve French 9338c8a9a5SSteve French shdr->ProtocolId = SMB2_PROTO_NUMBER; 9438c8a9a5SSteve French shdr->StructureSize = cpu_to_le16(64); 9538c8a9a5SSteve French shdr->Command = smb2_cmd; 9605d0f8f5SSteve French 9705d0f8f5SSteve French if (server) { 9809ee7a3bSSteve French /* After reconnect SMB3 must set ChannelSequence on subsequent reqs */ 9905d0f8f5SSteve French if (server->dialect >= SMB30_PROT_ID) { 10009ee7a3bSSteve French smb3_hdr = (struct smb3_hdr_req *)shdr; 10105d0f8f5SSteve French /* 10205d0f8f5SSteve French * if primary channel is not set yet, use default 10305d0f8f5SSteve French * channel for chan sequence num 10405d0f8f5SSteve French */ 105b3773b19SSteve French if (SERVER_IS_CHAN(server)) 10609ee7a3bSSteve French smb3_hdr->ChannelSequence = 10709ee7a3bSSteve French cpu_to_le16(server->primary_server->channel_sequence_num); 10809ee7a3bSSteve French else 10905d0f8f5SSteve French smb3_hdr->ChannelSequence = 11005d0f8f5SSteve French cpu_to_le16(server->channel_sequence_num); 11109ee7a3bSSteve French } 11238c8a9a5SSteve French spin_lock(&server->req_lock); 11338c8a9a5SSteve French /* Request up to 10 credits but don't go over the limit. */ 11438c8a9a5SSteve French if (server->credits >= server->max_credits) 11538c8a9a5SSteve French shdr->CreditRequest = cpu_to_le16(0); 11638c8a9a5SSteve French else 11738c8a9a5SSteve French shdr->CreditRequest = cpu_to_le16( 11838c8a9a5SSteve French min_t(int, server->max_credits - 11938c8a9a5SSteve French server->credits, 10)); 12038c8a9a5SSteve French spin_unlock(&server->req_lock); 12138c8a9a5SSteve French } else { 12238c8a9a5SSteve French shdr->CreditRequest = cpu_to_le16(2); 12338c8a9a5SSteve French } 12438c8a9a5SSteve French shdr->Id.SyncId.ProcessId = cpu_to_le32((__u16)current->tgid); 12538c8a9a5SSteve French 12638c8a9a5SSteve French if (!tcon) 12738c8a9a5SSteve French goto out; 12838c8a9a5SSteve French 12938c8a9a5SSteve French /* GLOBAL_CAP_LARGE_MTU will only be set if dialect > SMB2.02 */ 13038c8a9a5SSteve French /* See sections 2.2.4 and 3.2.4.1.5 of MS-SMB2 */ 13138c8a9a5SSteve French if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU)) 13238c8a9a5SSteve French shdr->CreditCharge = cpu_to_le16(1); 13338c8a9a5SSteve French /* else CreditCharge MBZ */ 13438c8a9a5SSteve French 13538c8a9a5SSteve French shdr->Id.SyncId.TreeId = cpu_to_le32(tcon->tid); 13638c8a9a5SSteve French /* Uid is not converted */ 13738c8a9a5SSteve French if (tcon->ses) 13838c8a9a5SSteve French shdr->SessionId = cpu_to_le64(tcon->ses->Suid); 13938c8a9a5SSteve French 14038c8a9a5SSteve French /* 14138c8a9a5SSteve French * If we would set SMB2_FLAGS_DFS_OPERATIONS on open we also would have 14238c8a9a5SSteve French * to pass the path on the Open SMB prefixed by \\server\share. 14338c8a9a5SSteve French * Not sure when we would need to do the augmented path (if ever) and 14438c8a9a5SSteve French * setting this flag breaks the SMB2 open operation since it is 14538c8a9a5SSteve French * illegal to send an empty path name (without \\server\share prefix) 14638c8a9a5SSteve French * when the DFS flag is set in the SMB open header. We could 14738c8a9a5SSteve French * consider setting the flag on all operations other than open 14838c8a9a5SSteve French * but it is safer to net set it for now. 14938c8a9a5SSteve French */ 15038c8a9a5SSteve French /* if (tcon->share_flags & SHI1005_FLAGS_DFS) 15138c8a9a5SSteve French shdr->Flags |= SMB2_FLAGS_DFS_OPERATIONS; */ 15238c8a9a5SSteve French 15338c8a9a5SSteve French if (server && server->sign && !smb3_encryption_required(tcon)) 15438c8a9a5SSteve French shdr->Flags |= SMB2_FLAGS_SIGNED; 15538c8a9a5SSteve French out: 15638c8a9a5SSteve French return; 15738c8a9a5SSteve French } 15838c8a9a5SSteve French 15950e8363eSShyam Prasad N /* helper function for code reuse */ 16050e8363eSShyam Prasad N static int 16150e8363eSShyam Prasad N cifs_chan_skip_or_disable(struct cifs_ses *ses, 16250e8363eSShyam Prasad N struct TCP_Server_Info *server, 16350e8363eSShyam Prasad N bool from_reconnect) 16450e8363eSShyam Prasad N { 16550e8363eSShyam Prasad N struct TCP_Server_Info *pserver; 16650e8363eSShyam Prasad N unsigned int chan_index; 16750e8363eSShyam Prasad N 16850e8363eSShyam Prasad N if (SERVER_IS_CHAN(server)) { 16950e8363eSShyam Prasad N cifs_dbg(VFS, 17050e8363eSShyam Prasad N "server %s does not support multichannel anymore. Skip secondary channel\n", 17150e8363eSShyam Prasad N ses->server->hostname); 17250e8363eSShyam Prasad N 17350e8363eSShyam Prasad N spin_lock(&ses->chan_lock); 17450e8363eSShyam Prasad N chan_index = cifs_ses_get_chan_index(ses, server); 17550e8363eSShyam Prasad N if (chan_index == CIFS_INVAL_CHAN_INDEX) { 17650e8363eSShyam Prasad N spin_unlock(&ses->chan_lock); 17750e8363eSShyam Prasad N goto skip_terminate; 17850e8363eSShyam Prasad N } 17950e8363eSShyam Prasad N 18050e8363eSShyam Prasad N ses->chans[chan_index].server = NULL; 1812b1f28eeSShyam Prasad N server->terminate = true; 18250e8363eSShyam Prasad N spin_unlock(&ses->chan_lock); 18350e8363eSShyam Prasad N 18450e8363eSShyam Prasad N /* 18550e8363eSShyam Prasad N * the above reference of server by channel 18650e8363eSShyam Prasad N * needs to be dropped without holding chan_lock 18750e8363eSShyam Prasad N * as cifs_put_tcp_session takes a higher lock 18850e8363eSShyam Prasad N * i.e. cifs_tcp_ses_lock 18950e8363eSShyam Prasad N */ 19050e8363eSShyam Prasad N cifs_put_tcp_session(server, from_reconnect); 19150e8363eSShyam Prasad N 19250e8363eSShyam Prasad N cifs_signal_cifsd_for_reconnect(server, false); 19350e8363eSShyam Prasad N 19450e8363eSShyam Prasad N /* mark primary server as needing reconnect */ 19550e8363eSShyam Prasad N pserver = server->primary_server; 19650e8363eSShyam Prasad N cifs_signal_cifsd_for_reconnect(pserver, false); 19750e8363eSShyam Prasad N skip_terminate: 19850e8363eSShyam Prasad N return -EHOSTDOWN; 19950e8363eSShyam Prasad N } 20050e8363eSShyam Prasad N 20150e8363eSShyam Prasad N cifs_server_dbg(VFS, 20250e8363eSShyam Prasad N "server does not support multichannel anymore. Disable all other channels\n"); 20350e8363eSShyam Prasad N cifs_disable_secondary_channels(ses); 20450e8363eSShyam Prasad N 20550e8363eSShyam Prasad N 20650e8363eSShyam Prasad N return 0; 20750e8363eSShyam Prasad N } 20850e8363eSShyam Prasad N 20938c8a9a5SSteve French static int 21038c8a9a5SSteve French smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon, 21107e86408SShyam Prasad N struct TCP_Server_Info *server, bool from_reconnect) 21238c8a9a5SSteve French { 21338c8a9a5SSteve French int rc = 0; 21438c8a9a5SSteve French struct nls_table *nls_codepage = NULL; 21538c8a9a5SSteve French struct cifs_ses *ses; 2165075e9f4SShyam Prasad N int xid; 21738c8a9a5SSteve French 21838c8a9a5SSteve French /* 21938c8a9a5SSteve French * SMB2s NegProt, SessSetup, Logoff do not have tcon yet so 22038c8a9a5SSteve French * check for tcp and smb session status done differently 22138c8a9a5SSteve French * for those three - in the calling routine. 22238c8a9a5SSteve French */ 22338c8a9a5SSteve French if (tcon == NULL) 22438c8a9a5SSteve French return 0; 22538c8a9a5SSteve French 22638c8a9a5SSteve French /* 22738c8a9a5SSteve French * Need to also skip SMB2_IOCTL because it is used for checking nested dfs links in 22838c8a9a5SSteve French * cifs_tree_connect(). 22938c8a9a5SSteve French */ 23038c8a9a5SSteve French if (smb2_command == SMB2_TREE_CONNECT || smb2_command == SMB2_IOCTL) 23138c8a9a5SSteve French return 0; 23238c8a9a5SSteve French 23338c8a9a5SSteve French spin_lock(&tcon->tc_lock); 23438c8a9a5SSteve French if (tcon->status == TID_EXITING) { 23538c8a9a5SSteve French /* 23638c8a9a5SSteve French * only tree disconnect allowed when disconnecting ... 23738c8a9a5SSteve French */ 23838c8a9a5SSteve French if (smb2_command != SMB2_TREE_DISCONNECT) { 23938c8a9a5SSteve French spin_unlock(&tcon->tc_lock); 24038c8a9a5SSteve French cifs_dbg(FYI, "can not send cmd %d while umounting\n", 24138c8a9a5SSteve French smb2_command); 24238c8a9a5SSteve French return -ENODEV; 24338c8a9a5SSteve French } 24438c8a9a5SSteve French } 24538c8a9a5SSteve French spin_unlock(&tcon->tc_lock); 24638c8a9a5SSteve French 24738c8a9a5SSteve French ses = tcon->ses; 24838c8a9a5SSteve French if (!ses) 24938c8a9a5SSteve French return -EIO; 25038c8a9a5SSteve French spin_lock(&ses->ses_lock); 25138c8a9a5SSteve French if (ses->ses_status == SES_EXITING) { 25238c8a9a5SSteve French spin_unlock(&ses->ses_lock); 25338c8a9a5SSteve French return -EIO; 25438c8a9a5SSteve French } 25538c8a9a5SSteve French spin_unlock(&ses->ses_lock); 25638c8a9a5SSteve French if (!ses->server || !server) 25738c8a9a5SSteve French return -EIO; 25838c8a9a5SSteve French 25938c8a9a5SSteve French spin_lock(&server->srv_lock); 26038c8a9a5SSteve French if (server->tcpStatus == CifsNeedReconnect) { 26138c8a9a5SSteve French /* 26238c8a9a5SSteve French * Return to caller for TREE_DISCONNECT and LOGOFF and CLOSE 26338c8a9a5SSteve French * here since they are implicitly done when session drops. 26438c8a9a5SSteve French */ 26538c8a9a5SSteve French switch (smb2_command) { 26638c8a9a5SSteve French /* 26738c8a9a5SSteve French * BB Should we keep oplock break and add flush to exceptions? 26838c8a9a5SSteve French */ 26938c8a9a5SSteve French case SMB2_TREE_DISCONNECT: 27038c8a9a5SSteve French case SMB2_CANCEL: 27138c8a9a5SSteve French case SMB2_CLOSE: 27238c8a9a5SSteve French case SMB2_OPLOCK_BREAK: 27338c8a9a5SSteve French spin_unlock(&server->srv_lock); 27438c8a9a5SSteve French return -EAGAIN; 27538c8a9a5SSteve French } 27638c8a9a5SSteve French } 2773e161536SShyam Prasad N 2783e161536SShyam Prasad N /* if server is marked for termination, cifsd will cleanup */ 2793e161536SShyam Prasad N if (server->terminate) { 2803e161536SShyam Prasad N spin_unlock(&server->srv_lock); 2813e161536SShyam Prasad N return -EHOSTDOWN; 2823e161536SShyam Prasad N } 28338c8a9a5SSteve French spin_unlock(&server->srv_lock); 28438c8a9a5SSteve French 28538c8a9a5SSteve French again: 28638c8a9a5SSteve French rc = cifs_wait_for_server_reconnect(server, tcon->retry); 28738c8a9a5SSteve French if (rc) 28838c8a9a5SSteve French return rc; 28938c8a9a5SSteve French 29038c8a9a5SSteve French spin_lock(&ses->chan_lock); 29138c8a9a5SSteve French if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) { 29238c8a9a5SSteve French spin_unlock(&ses->chan_lock); 29338c8a9a5SSteve French return 0; 29438c8a9a5SSteve French } 29538c8a9a5SSteve French spin_unlock(&ses->chan_lock); 29638c8a9a5SSteve French cifs_dbg(FYI, "sess reconnect mask: 0x%lx, tcon reconnect: %d", 29738c8a9a5SSteve French tcon->ses->chans_need_reconnect, 29838c8a9a5SSteve French tcon->need_reconnect); 29938c8a9a5SSteve French 30038c8a9a5SSteve French mutex_lock(&ses->session_mutex); 30138c8a9a5SSteve French /* 3023e161536SShyam Prasad N * if this is called by delayed work, and the channel has been disabled 3033e161536SShyam Prasad N * in parallel, the delayed work can continue to execute in parallel 3043e161536SShyam Prasad N * there's a chance that this channel may not exist anymore 3053e161536SShyam Prasad N */ 3063e161536SShyam Prasad N spin_lock(&server->srv_lock); 3073e161536SShyam Prasad N if (server->tcpStatus == CifsExiting) { 3083e161536SShyam Prasad N spin_unlock(&server->srv_lock); 3093e161536SShyam Prasad N mutex_unlock(&ses->session_mutex); 3103e161536SShyam Prasad N rc = -EHOSTDOWN; 3113e161536SShyam Prasad N goto out; 3123e161536SShyam Prasad N } 3133e161536SShyam Prasad N 3143e161536SShyam Prasad N /* 31538c8a9a5SSteve French * Recheck after acquire mutex. If another thread is negotiating 31638c8a9a5SSteve French * and the server never sends an answer the socket will be closed 31738c8a9a5SSteve French * and tcpStatus set to reconnect. 31838c8a9a5SSteve French */ 31938c8a9a5SSteve French if (server->tcpStatus == CifsNeedReconnect) { 32038c8a9a5SSteve French spin_unlock(&server->srv_lock); 32138c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 32238c8a9a5SSteve French 32338c8a9a5SSteve French if (tcon->retry) 32438c8a9a5SSteve French goto again; 32538c8a9a5SSteve French 32638c8a9a5SSteve French rc = -EHOSTDOWN; 32738c8a9a5SSteve French goto out; 32838c8a9a5SSteve French } 32938c8a9a5SSteve French spin_unlock(&server->srv_lock); 33038c8a9a5SSteve French 331a43f95fdSWinston Wen nls_codepage = ses->local_nls; 33238c8a9a5SSteve French 33338c8a9a5SSteve French /* 33438c8a9a5SSteve French * need to prevent multiple threads trying to simultaneously 33538c8a9a5SSteve French * reconnect the same SMB session 33638c8a9a5SSteve French */ 33738c8a9a5SSteve French spin_lock(&ses->ses_lock); 33838c8a9a5SSteve French spin_lock(&ses->chan_lock); 33938c8a9a5SSteve French if (!cifs_chan_needs_reconnect(ses, server) && 34038c8a9a5SSteve French ses->ses_status == SES_GOOD) { 34138c8a9a5SSteve French spin_unlock(&ses->chan_lock); 34238c8a9a5SSteve French spin_unlock(&ses->ses_lock); 34338c8a9a5SSteve French /* this means that we only need to tree connect */ 34438c8a9a5SSteve French if (tcon->need_reconnect) 34538c8a9a5SSteve French goto skip_sess_setup; 34638c8a9a5SSteve French 34738c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 34838c8a9a5SSteve French goto out; 34938c8a9a5SSteve French } 35038c8a9a5SSteve French spin_unlock(&ses->chan_lock); 35138c8a9a5SSteve French spin_unlock(&ses->ses_lock); 35238c8a9a5SSteve French 35338c8a9a5SSteve French rc = cifs_negotiate_protocol(0, ses, server); 35438c8a9a5SSteve French if (!rc) { 3553e161536SShyam Prasad N /* 3563e161536SShyam Prasad N * if server stopped supporting multichannel 3573e161536SShyam Prasad N * and the first channel reconnected, disable all the others. 3583e161536SShyam Prasad N */ 3593e161536SShyam Prasad N if (ses->chan_count > 1 && 3603e161536SShyam Prasad N !(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) { 36150e8363eSShyam Prasad N rc = cifs_chan_skip_or_disable(ses, server, 36250e8363eSShyam Prasad N from_reconnect); 36350e8363eSShyam Prasad N if (rc) { 3643e161536SShyam Prasad N mutex_unlock(&ses->session_mutex); 3653e161536SShyam Prasad N goto out; 3663e161536SShyam Prasad N } 3673e161536SShyam Prasad N } 3683e161536SShyam Prasad N 36938c8a9a5SSteve French rc = cifs_setup_session(0, ses, server, nls_codepage); 37008bedfbcSSteve French if ((rc == -EACCES) || (rc == -EKEYEXPIRED) || (rc == -EKEYREVOKED)) { 37108bedfbcSSteve French /* 37208bedfbcSSteve French * Try alternate password for next reconnect (key rotation 37308bedfbcSSteve French * could be enabled on the server e.g.) if an alternate 37408bedfbcSSteve French * password is available and the current password is expired, 37508bedfbcSSteve French * but do not swap on non pwd related errors like host down 37608bedfbcSSteve French */ 37708bedfbcSSteve French if (ses->password2) 37808bedfbcSSteve French swap(ses->password2, ses->password); 37908bedfbcSSteve French } 38008bedfbcSSteve French 38138c8a9a5SSteve French if ((rc == -EACCES) && !tcon->retry) { 38238c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 38338c8a9a5SSteve French rc = -EHOSTDOWN; 38438c8a9a5SSteve French goto failed; 38538c8a9a5SSteve French } else if (rc) { 38638c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 38738c8a9a5SSteve French goto out; 38838c8a9a5SSteve French } 38938c8a9a5SSteve French } else { 39038c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 39138c8a9a5SSteve French goto out; 39238c8a9a5SSteve French } 39338c8a9a5SSteve French 39438c8a9a5SSteve French skip_sess_setup: 39538c8a9a5SSteve French if (!tcon->need_reconnect) { 39638c8a9a5SSteve French mutex_unlock(&ses->session_mutex); 39738c8a9a5SSteve French goto out; 39838c8a9a5SSteve French } 39938c8a9a5SSteve French cifs_mark_open_files_invalid(tcon); 40038c8a9a5SSteve French if (tcon->use_persistent) 40138c8a9a5SSteve French tcon->need_reopen_files = true; 40238c8a9a5SSteve French 40338c8a9a5SSteve French rc = cifs_tree_connect(0, tcon, nls_codepage); 40438c8a9a5SSteve French 40538c8a9a5SSteve French cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc); 40638c8a9a5SSteve French if (rc) { 40738c8a9a5SSteve French /* If sess reconnected but tcon didn't, something strange ... */ 4085075e9f4SShyam Prasad N mutex_unlock(&ses->session_mutex); 40938c8a9a5SSteve French cifs_dbg(VFS, "reconnect tcon failed rc = %d\n", rc); 41038c8a9a5SSteve French goto out; 41138c8a9a5SSteve French } 41238c8a9a5SSteve French 413567f1b1dSShyam Prasad N spin_lock(&ses->ses_lock); 414567f1b1dSShyam Prasad N if (ses->flags & CIFS_SES_FLAG_SCALE_CHANNELS) { 415567f1b1dSShyam Prasad N spin_unlock(&ses->ses_lock); 416567f1b1dSShyam Prasad N mutex_unlock(&ses->session_mutex); 417567f1b1dSShyam Prasad N goto skip_add_channels; 418567f1b1dSShyam Prasad N } 419567f1b1dSShyam Prasad N ses->flags |= CIFS_SES_FLAG_SCALE_CHANNELS; 420567f1b1dSShyam Prasad N spin_unlock(&ses->ses_lock); 421567f1b1dSShyam Prasad N 4225075e9f4SShyam Prasad N if (!rc && 42366c2940cSShyam Prasad N (server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL) && 42466c2940cSShyam Prasad N server->ops->query_server_interfaces) { 4255075e9f4SShyam Prasad N mutex_unlock(&ses->session_mutex); 4265075e9f4SShyam Prasad N 4275075e9f4SShyam Prasad N /* 4285075e9f4SShyam Prasad N * query server network interfaces, in case they change 4295075e9f4SShyam Prasad N */ 4305075e9f4SShyam Prasad N xid = get_xid(); 43166c2940cSShyam Prasad N rc = server->ops->query_server_interfaces(xid, tcon, false); 4325075e9f4SShyam Prasad N free_xid(xid); 4335075e9f4SShyam Prasad N 434fb708025SShyam Prasad N if (rc == -EOPNOTSUPP && ses->chan_count > 1) { 43550e8363eSShyam Prasad N /* 43650e8363eSShyam Prasad N * some servers like Azure SMB server do not advertise 43750e8363eSShyam Prasad N * that multichannel has been disabled with server 43850e8363eSShyam Prasad N * capabilities, rather return STATUS_NOT_IMPLEMENTED. 43950e8363eSShyam Prasad N * treat this as server not supporting multichannel 44050e8363eSShyam Prasad N */ 44150e8363eSShyam Prasad N 44250e8363eSShyam Prasad N rc = cifs_chan_skip_or_disable(ses, server, 44350e8363eSShyam Prasad N from_reconnect); 44450e8363eSShyam Prasad N goto skip_add_channels; 44550e8363eSShyam Prasad N } else if (rc) 4465075e9f4SShyam Prasad N cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n", 4475075e9f4SShyam Prasad N __func__, rc); 4485075e9f4SShyam Prasad N 4495075e9f4SShyam Prasad N if (ses->chan_max > ses->chan_count && 45050e8363eSShyam Prasad N ses->iface_count && 4515075e9f4SShyam Prasad N !SERVER_IS_CHAN(server)) { 452567f1b1dSShyam Prasad N if (ses->chan_count == 1) { 4535075e9f4SShyam Prasad N cifs_server_dbg(VFS, "supports multichannel now\n"); 454567f1b1dSShyam Prasad N queue_delayed_work(cifsiod_wq, &tcon->query_interfaces, 455567f1b1dSShyam Prasad N (SMB_INTERFACE_POLL_INTERVAL * HZ)); 456567f1b1dSShyam Prasad N } 4575075e9f4SShyam Prasad N 4585075e9f4SShyam Prasad N cifs_try_adding_channels(ses); 4595075e9f4SShyam Prasad N } 4605075e9f4SShyam Prasad N } else { 4615075e9f4SShyam Prasad N mutex_unlock(&ses->session_mutex); 4625075e9f4SShyam Prasad N } 463567f1b1dSShyam Prasad N 46450e8363eSShyam Prasad N skip_add_channels: 465567f1b1dSShyam Prasad N spin_lock(&ses->ses_lock); 466567f1b1dSShyam Prasad N ses->flags &= ~CIFS_SES_FLAG_SCALE_CHANNELS; 467567f1b1dSShyam Prasad N spin_unlock(&ses->ses_lock); 4685075e9f4SShyam Prasad N 46938c8a9a5SSteve French if (smb2_command != SMB2_INTERNAL_CMD) 470fe8c187fSShyam Prasad N mod_delayed_work(cifsiod_wq, &server->reconnect, 0); 47138c8a9a5SSteve French 47238c8a9a5SSteve French atomic_inc(&tconInfoReconnectCount); 47338c8a9a5SSteve French out: 47438c8a9a5SSteve French /* 47538c8a9a5SSteve French * Check if handle based operation so we know whether we can continue 47638c8a9a5SSteve French * or not without returning to caller to reset file handle. 47738c8a9a5SSteve French */ 47838c8a9a5SSteve French /* 47938c8a9a5SSteve French * BB Is flush done by server on drop of tcp session? Should we special 48038c8a9a5SSteve French * case it and skip above? 48138c8a9a5SSteve French */ 48238c8a9a5SSteve French switch (smb2_command) { 48338c8a9a5SSteve French case SMB2_FLUSH: 48438c8a9a5SSteve French case SMB2_READ: 48538c8a9a5SSteve French case SMB2_WRITE: 48638c8a9a5SSteve French case SMB2_LOCK: 48738c8a9a5SSteve French case SMB2_QUERY_DIRECTORY: 48838c8a9a5SSteve French case SMB2_CHANGE_NOTIFY: 48938c8a9a5SSteve French case SMB2_QUERY_INFO: 49038c8a9a5SSteve French case SMB2_SET_INFO: 49138c8a9a5SSteve French rc = -EAGAIN; 49238c8a9a5SSteve French } 49338c8a9a5SSteve French failed: 49438c8a9a5SSteve French return rc; 49538c8a9a5SSteve French } 49638c8a9a5SSteve French 49738c8a9a5SSteve French static void 49838c8a9a5SSteve French fill_small_buf(__le16 smb2_command, struct cifs_tcon *tcon, 49938c8a9a5SSteve French struct TCP_Server_Info *server, 50038c8a9a5SSteve French void *buf, 50138c8a9a5SSteve French unsigned int *total_len) 50238c8a9a5SSteve French { 50338c8a9a5SSteve French struct smb2_pdu *spdu = buf; 50438c8a9a5SSteve French /* lookup word count ie StructureSize from table */ 50538c8a9a5SSteve French __u16 parmsize = smb2_req_struct_sizes[le16_to_cpu(smb2_command)]; 50638c8a9a5SSteve French 50738c8a9a5SSteve French /* 50838c8a9a5SSteve French * smaller than SMALL_BUFFER_SIZE but bigger than fixed area of 50938c8a9a5SSteve French * largest operations (Create) 51038c8a9a5SSteve French */ 51138c8a9a5SSteve French memset(buf, 0, 256); 51238c8a9a5SSteve French 51338c8a9a5SSteve French smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server); 51438c8a9a5SSteve French spdu->StructureSize2 = cpu_to_le16(parmsize); 51538c8a9a5SSteve French 51638c8a9a5SSteve French *total_len = parmsize + sizeof(struct smb2_hdr); 51738c8a9a5SSteve French } 51838c8a9a5SSteve French 51938c8a9a5SSteve French /* 52038c8a9a5SSteve French * Allocate and return pointer to an SMB request hdr, and set basic 52138c8a9a5SSteve French * SMB information in the SMB header. If the return code is zero, this 52238c8a9a5SSteve French * function must have filled in request_buf pointer. 52338c8a9a5SSteve French */ 52438c8a9a5SSteve French static int __smb2_plain_req_init(__le16 smb2_command, struct cifs_tcon *tcon, 52538c8a9a5SSteve French struct TCP_Server_Info *server, 52638c8a9a5SSteve French void **request_buf, unsigned int *total_len) 52738c8a9a5SSteve French { 52838c8a9a5SSteve French /* BB eventually switch this to SMB2 specific small buf size */ 5293b5f0d0aSPaulo Alcantara switch (smb2_command) { 5303b5f0d0aSPaulo Alcantara case SMB2_SET_INFO: 5313b5f0d0aSPaulo Alcantara case SMB2_QUERY_INFO: 53238c8a9a5SSteve French *request_buf = cifs_buf_get(); 5333b5f0d0aSPaulo Alcantara break; 5343b5f0d0aSPaulo Alcantara default: 53538c8a9a5SSteve French *request_buf = cifs_small_buf_get(); 5363b5f0d0aSPaulo Alcantara break; 5373b5f0d0aSPaulo Alcantara } 53838c8a9a5SSteve French if (*request_buf == NULL) { 53938c8a9a5SSteve French /* BB should we add a retry in here if not a writepage? */ 54038c8a9a5SSteve French return -ENOMEM; 54138c8a9a5SSteve French } 54238c8a9a5SSteve French 54338c8a9a5SSteve French fill_small_buf(smb2_command, tcon, server, 54438c8a9a5SSteve French (struct smb2_hdr *)(*request_buf), 54538c8a9a5SSteve French total_len); 54638c8a9a5SSteve French 54738c8a9a5SSteve French if (tcon != NULL) { 54838c8a9a5SSteve French uint16_t com_code = le16_to_cpu(smb2_command); 54938c8a9a5SSteve French cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_sent[com_code]); 55038c8a9a5SSteve French cifs_stats_inc(&tcon->num_smbs_sent); 55138c8a9a5SSteve French } 55238c8a9a5SSteve French 55338c8a9a5SSteve French return 0; 55438c8a9a5SSteve French } 55538c8a9a5SSteve French 55638c8a9a5SSteve French static int smb2_plain_req_init(__le16 smb2_command, struct cifs_tcon *tcon, 55738c8a9a5SSteve French struct TCP_Server_Info *server, 55838c8a9a5SSteve French void **request_buf, unsigned int *total_len) 55938c8a9a5SSteve French { 56038c8a9a5SSteve French int rc; 56138c8a9a5SSteve French 56207e86408SShyam Prasad N rc = smb2_reconnect(smb2_command, tcon, server, false); 56338c8a9a5SSteve French if (rc) 56438c8a9a5SSteve French return rc; 56538c8a9a5SSteve French 56638c8a9a5SSteve French return __smb2_plain_req_init(smb2_command, tcon, server, request_buf, 56738c8a9a5SSteve French total_len); 56838c8a9a5SSteve French } 56938c8a9a5SSteve French 57038c8a9a5SSteve French static int smb2_ioctl_req_init(u32 opcode, struct cifs_tcon *tcon, 57138c8a9a5SSteve French struct TCP_Server_Info *server, 57238c8a9a5SSteve French void **request_buf, unsigned int *total_len) 57338c8a9a5SSteve French { 57438c8a9a5SSteve French /* Skip reconnect only for FSCTL_VALIDATE_NEGOTIATE_INFO IOCTLs */ 57538c8a9a5SSteve French if (opcode == FSCTL_VALIDATE_NEGOTIATE_INFO) { 57638c8a9a5SSteve French return __smb2_plain_req_init(SMB2_IOCTL, tcon, server, 57738c8a9a5SSteve French request_buf, total_len); 57838c8a9a5SSteve French } 57938c8a9a5SSteve French return smb2_plain_req_init(SMB2_IOCTL, tcon, server, 58038c8a9a5SSteve French request_buf, total_len); 58138c8a9a5SSteve French } 58238c8a9a5SSteve French 58338c8a9a5SSteve French /* For explanation of negotiate contexts see MS-SMB2 section 2.2.3.1 */ 58438c8a9a5SSteve French 58538c8a9a5SSteve French static void 58638c8a9a5SSteve French build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt) 58738c8a9a5SSteve French { 58838c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_PREAUTH_INTEGRITY_CAPABILITIES; 58938c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(38); 59038c8a9a5SSteve French pneg_ctxt->HashAlgorithmCount = cpu_to_le16(1); 59138c8a9a5SSteve French pneg_ctxt->SaltLength = cpu_to_le16(SMB311_SALT_SIZE); 59238c8a9a5SSteve French get_random_bytes(pneg_ctxt->Salt, SMB311_SALT_SIZE); 59338c8a9a5SSteve French pneg_ctxt->HashAlgorithms = SMB2_PREAUTH_INTEGRITY_SHA512; 59438c8a9a5SSteve French } 59538c8a9a5SSteve French 59638c8a9a5SSteve French static void 59738c8a9a5SSteve French build_compression_ctxt(struct smb2_compression_capabilities_context *pneg_ctxt) 59838c8a9a5SSteve French { 59938c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_COMPRESSION_CAPABILITIES; 60038c8a9a5SSteve French pneg_ctxt->DataLength = 60138c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_compression_capabilities_context) 60238c8a9a5SSteve French - sizeof(struct smb2_neg_context)); 60338c8a9a5SSteve French pneg_ctxt->CompressionAlgorithmCount = cpu_to_le16(3); 60438c8a9a5SSteve French pneg_ctxt->CompressionAlgorithms[0] = SMB3_COMPRESS_LZ77; 60538c8a9a5SSteve French pneg_ctxt->CompressionAlgorithms[1] = SMB3_COMPRESS_LZ77_HUFF; 60638c8a9a5SSteve French pneg_ctxt->CompressionAlgorithms[2] = SMB3_COMPRESS_LZNT1; 60738c8a9a5SSteve French } 60838c8a9a5SSteve French 60938c8a9a5SSteve French static unsigned int 61038c8a9a5SSteve French build_signing_ctxt(struct smb2_signing_capabilities *pneg_ctxt) 61138c8a9a5SSteve French { 61238c8a9a5SSteve French unsigned int ctxt_len = sizeof(struct smb2_signing_capabilities); 61338c8a9a5SSteve French unsigned short num_algs = 1; /* number of signing algorithms sent */ 61438c8a9a5SSteve French 61538c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_SIGNING_CAPABILITIES; 61638c8a9a5SSteve French /* 61738c8a9a5SSteve French * Context Data length must be rounded to multiple of 8 for some servers 61838c8a9a5SSteve French */ 61938c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(ALIGN(sizeof(struct smb2_signing_capabilities) - 62038c8a9a5SSteve French sizeof(struct smb2_neg_context) + 62138c8a9a5SSteve French (num_algs * sizeof(u16)), 8)); 62238c8a9a5SSteve French pneg_ctxt->SigningAlgorithmCount = cpu_to_le16(num_algs); 62338c8a9a5SSteve French pneg_ctxt->SigningAlgorithms[0] = cpu_to_le16(SIGNING_ALG_AES_CMAC); 62438c8a9a5SSteve French 62538c8a9a5SSteve French ctxt_len += sizeof(__le16) * num_algs; 62638c8a9a5SSteve French ctxt_len = ALIGN(ctxt_len, 8); 62738c8a9a5SSteve French return ctxt_len; 62838c8a9a5SSteve French /* TBD add SIGNING_ALG_AES_GMAC and/or SIGNING_ALG_HMAC_SHA256 */ 62938c8a9a5SSteve French } 63038c8a9a5SSteve French 63138c8a9a5SSteve French static void 63238c8a9a5SSteve French build_encrypt_ctxt(struct smb2_encryption_neg_context *pneg_ctxt) 63338c8a9a5SSteve French { 63438c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_ENCRYPTION_CAPABILITIES; 63538c8a9a5SSteve French if (require_gcm_256) { 63638c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(4); /* Cipher Count + 1 cipher */ 63738c8a9a5SSteve French pneg_ctxt->CipherCount = cpu_to_le16(1); 63838c8a9a5SSteve French pneg_ctxt->Ciphers[0] = SMB2_ENCRYPTION_AES256_GCM; 63938c8a9a5SSteve French } else if (enable_gcm_256) { 64038c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(8); /* Cipher Count + 3 ciphers */ 64138c8a9a5SSteve French pneg_ctxt->CipherCount = cpu_to_le16(3); 64238c8a9a5SSteve French pneg_ctxt->Ciphers[0] = SMB2_ENCRYPTION_AES128_GCM; 64338c8a9a5SSteve French pneg_ctxt->Ciphers[1] = SMB2_ENCRYPTION_AES256_GCM; 64438c8a9a5SSteve French pneg_ctxt->Ciphers[2] = SMB2_ENCRYPTION_AES128_CCM; 64538c8a9a5SSteve French } else { 64638c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(6); /* Cipher Count + 2 ciphers */ 64738c8a9a5SSteve French pneg_ctxt->CipherCount = cpu_to_le16(2); 64838c8a9a5SSteve French pneg_ctxt->Ciphers[0] = SMB2_ENCRYPTION_AES128_GCM; 64938c8a9a5SSteve French pneg_ctxt->Ciphers[1] = SMB2_ENCRYPTION_AES128_CCM; 65038c8a9a5SSteve French } 65138c8a9a5SSteve French } 65238c8a9a5SSteve French 65338c8a9a5SSteve French static unsigned int 65438c8a9a5SSteve French build_netname_ctxt(struct smb2_netname_neg_context *pneg_ctxt, char *hostname) 65538c8a9a5SSteve French { 65638c8a9a5SSteve French struct nls_table *cp = load_nls_default(); 65738c8a9a5SSteve French 65838c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_NETNAME_NEGOTIATE_CONTEXT_ID; 65938c8a9a5SSteve French 66038c8a9a5SSteve French /* copy up to max of first 100 bytes of server name to NetName field */ 66138c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(2 * cifs_strtoUTF16(pneg_ctxt->NetName, hostname, 100, cp)); 66238c8a9a5SSteve French /* context size is DataLength + minimal smb2_neg_context */ 66338c8a9a5SSteve French return ALIGN(le16_to_cpu(pneg_ctxt->DataLength) + sizeof(struct smb2_neg_context), 8); 66438c8a9a5SSteve French } 66538c8a9a5SSteve French 66638c8a9a5SSteve French static void 66738c8a9a5SSteve French build_posix_ctxt(struct smb2_posix_neg_context *pneg_ctxt) 66838c8a9a5SSteve French { 66938c8a9a5SSteve French pneg_ctxt->ContextType = SMB2_POSIX_EXTENSIONS_AVAILABLE; 67038c8a9a5SSteve French pneg_ctxt->DataLength = cpu_to_le16(POSIX_CTXT_DATA_LEN); 67138c8a9a5SSteve French /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */ 67238c8a9a5SSteve French pneg_ctxt->Name[0] = 0x93; 67338c8a9a5SSteve French pneg_ctxt->Name[1] = 0xAD; 67438c8a9a5SSteve French pneg_ctxt->Name[2] = 0x25; 67538c8a9a5SSteve French pneg_ctxt->Name[3] = 0x50; 67638c8a9a5SSteve French pneg_ctxt->Name[4] = 0x9C; 67738c8a9a5SSteve French pneg_ctxt->Name[5] = 0xB4; 67838c8a9a5SSteve French pneg_ctxt->Name[6] = 0x11; 67938c8a9a5SSteve French pneg_ctxt->Name[7] = 0xE7; 68038c8a9a5SSteve French pneg_ctxt->Name[8] = 0xB4; 68138c8a9a5SSteve French pneg_ctxt->Name[9] = 0x23; 68238c8a9a5SSteve French pneg_ctxt->Name[10] = 0x83; 68338c8a9a5SSteve French pneg_ctxt->Name[11] = 0xDE; 68438c8a9a5SSteve French pneg_ctxt->Name[12] = 0x96; 68538c8a9a5SSteve French pneg_ctxt->Name[13] = 0x8B; 68638c8a9a5SSteve French pneg_ctxt->Name[14] = 0xCD; 68738c8a9a5SSteve French pneg_ctxt->Name[15] = 0x7C; 68838c8a9a5SSteve French } 68938c8a9a5SSteve French 69038c8a9a5SSteve French static void 69138c8a9a5SSteve French assemble_neg_contexts(struct smb2_negotiate_req *req, 69238c8a9a5SSteve French struct TCP_Server_Info *server, unsigned int *total_len) 69338c8a9a5SSteve French { 69438c8a9a5SSteve French unsigned int ctxt_len, neg_context_count; 69538c8a9a5SSteve French struct TCP_Server_Info *pserver; 69638c8a9a5SSteve French char *pneg_ctxt; 69738c8a9a5SSteve French char *hostname; 69838c8a9a5SSteve French 69938c8a9a5SSteve French if (*total_len > 200) { 70038c8a9a5SSteve French /* In case length corrupted don't want to overrun smb buffer */ 70138c8a9a5SSteve French cifs_server_dbg(VFS, "Bad frame length assembling neg contexts\n"); 70238c8a9a5SSteve French return; 70338c8a9a5SSteve French } 70438c8a9a5SSteve French 70538c8a9a5SSteve French /* 70638c8a9a5SSteve French * round up total_len of fixed part of SMB3 negotiate request to 8 70738c8a9a5SSteve French * byte boundary before adding negotiate contexts 70838c8a9a5SSteve French */ 70938c8a9a5SSteve French *total_len = ALIGN(*total_len, 8); 71038c8a9a5SSteve French 71138c8a9a5SSteve French pneg_ctxt = (*total_len) + (char *)req; 71238c8a9a5SSteve French req->NegotiateContextOffset = cpu_to_le32(*total_len); 71338c8a9a5SSteve French 71438c8a9a5SSteve French build_preauth_ctxt((struct smb2_preauth_neg_context *)pneg_ctxt); 71538c8a9a5SSteve French ctxt_len = ALIGN(sizeof(struct smb2_preauth_neg_context), 8); 71638c8a9a5SSteve French *total_len += ctxt_len; 71738c8a9a5SSteve French pneg_ctxt += ctxt_len; 71838c8a9a5SSteve French 71938c8a9a5SSteve French build_encrypt_ctxt((struct smb2_encryption_neg_context *)pneg_ctxt); 72038c8a9a5SSteve French ctxt_len = ALIGN(sizeof(struct smb2_encryption_neg_context), 8); 72138c8a9a5SSteve French *total_len += ctxt_len; 72238c8a9a5SSteve French pneg_ctxt += ctxt_len; 72338c8a9a5SSteve French 72438c8a9a5SSteve French /* 72538c8a9a5SSteve French * secondary channels don't have the hostname field populated 72638c8a9a5SSteve French * use the hostname field in the primary channel instead 72738c8a9a5SSteve French */ 728b3773b19SSteve French pserver = SERVER_IS_CHAN(server) ? server->primary_server : server; 72938c8a9a5SSteve French cifs_server_lock(pserver); 73038c8a9a5SSteve French hostname = pserver->hostname; 73138c8a9a5SSteve French if (hostname && (hostname[0] != 0)) { 73238c8a9a5SSteve French ctxt_len = build_netname_ctxt((struct smb2_netname_neg_context *)pneg_ctxt, 73338c8a9a5SSteve French hostname); 73438c8a9a5SSteve French *total_len += ctxt_len; 73538c8a9a5SSteve French pneg_ctxt += ctxt_len; 73638c8a9a5SSteve French neg_context_count = 3; 73738c8a9a5SSteve French } else 73838c8a9a5SSteve French neg_context_count = 2; 73938c8a9a5SSteve French cifs_server_unlock(pserver); 74038c8a9a5SSteve French 74138c8a9a5SSteve French build_posix_ctxt((struct smb2_posix_neg_context *)pneg_ctxt); 74238c8a9a5SSteve French *total_len += sizeof(struct smb2_posix_neg_context); 74338c8a9a5SSteve French pneg_ctxt += sizeof(struct smb2_posix_neg_context); 74438c8a9a5SSteve French neg_context_count++; 74538c8a9a5SSteve French 746*e8aee4f4SEnzo Matsumiya if (server->compression.requested) { 74738c8a9a5SSteve French build_compression_ctxt((struct smb2_compression_capabilities_context *) 74838c8a9a5SSteve French pneg_ctxt); 74938c8a9a5SSteve French ctxt_len = ALIGN(sizeof(struct smb2_compression_capabilities_context), 8); 75038c8a9a5SSteve French *total_len += ctxt_len; 75138c8a9a5SSteve French pneg_ctxt += ctxt_len; 75238c8a9a5SSteve French neg_context_count++; 75338c8a9a5SSteve French } 75438c8a9a5SSteve French 75538c8a9a5SSteve French if (enable_negotiate_signing) { 75638c8a9a5SSteve French ctxt_len = build_signing_ctxt((struct smb2_signing_capabilities *) 75738c8a9a5SSteve French pneg_ctxt); 75838c8a9a5SSteve French *total_len += ctxt_len; 75938c8a9a5SSteve French pneg_ctxt += ctxt_len; 76038c8a9a5SSteve French neg_context_count++; 76138c8a9a5SSteve French } 76238c8a9a5SSteve French 76338c8a9a5SSteve French /* check for and add transport_capabilities and signing capabilities */ 76438c8a9a5SSteve French req->NegotiateContextCount = cpu_to_le16(neg_context_count); 76538c8a9a5SSteve French 76638c8a9a5SSteve French } 76738c8a9a5SSteve French 76838c8a9a5SSteve French /* If invalid preauth context warn but use what we requested, SHA-512 */ 76938c8a9a5SSteve French static void decode_preauth_context(struct smb2_preauth_neg_context *ctxt) 77038c8a9a5SSteve French { 77138c8a9a5SSteve French unsigned int len = le16_to_cpu(ctxt->DataLength); 77238c8a9a5SSteve French 77338c8a9a5SSteve French /* 77438c8a9a5SSteve French * Caller checked that DataLength remains within SMB boundary. We still 77538c8a9a5SSteve French * need to confirm that one HashAlgorithms member is accounted for. 77638c8a9a5SSteve French */ 77738c8a9a5SSteve French if (len < MIN_PREAUTH_CTXT_DATA_LEN) { 77838c8a9a5SSteve French pr_warn_once("server sent bad preauth context\n"); 77938c8a9a5SSteve French return; 78038c8a9a5SSteve French } else if (len < MIN_PREAUTH_CTXT_DATA_LEN + le16_to_cpu(ctxt->SaltLength)) { 78138c8a9a5SSteve French pr_warn_once("server sent invalid SaltLength\n"); 78238c8a9a5SSteve French return; 78338c8a9a5SSteve French } 78438c8a9a5SSteve French if (le16_to_cpu(ctxt->HashAlgorithmCount) != 1) 78538c8a9a5SSteve French pr_warn_once("Invalid SMB3 hash algorithm count\n"); 78638c8a9a5SSteve French if (ctxt->HashAlgorithms != SMB2_PREAUTH_INTEGRITY_SHA512) 78738c8a9a5SSteve French pr_warn_once("unknown SMB3 hash algorithm\n"); 78838c8a9a5SSteve French } 78938c8a9a5SSteve French 79038c8a9a5SSteve French static void decode_compress_ctx(struct TCP_Server_Info *server, 79138c8a9a5SSteve French struct smb2_compression_capabilities_context *ctxt) 79238c8a9a5SSteve French { 79338c8a9a5SSteve French unsigned int len = le16_to_cpu(ctxt->DataLength); 794*e8aee4f4SEnzo Matsumiya __le16 alg; 795*e8aee4f4SEnzo Matsumiya 796*e8aee4f4SEnzo Matsumiya server->compression.enabled = false; 79738c8a9a5SSteve French 79838c8a9a5SSteve French /* 79938c8a9a5SSteve French * Caller checked that DataLength remains within SMB boundary. We still 80038c8a9a5SSteve French * need to confirm that one CompressionAlgorithms member is accounted 80138c8a9a5SSteve French * for. 80238c8a9a5SSteve French */ 80338c8a9a5SSteve French if (len < 10) { 80438c8a9a5SSteve French pr_warn_once("server sent bad compression cntxt\n"); 80538c8a9a5SSteve French return; 80638c8a9a5SSteve French } 807*e8aee4f4SEnzo Matsumiya 80838c8a9a5SSteve French if (le16_to_cpu(ctxt->CompressionAlgorithmCount) != 1) { 809*e8aee4f4SEnzo Matsumiya pr_warn_once("invalid SMB3 compress algorithm count\n"); 81038c8a9a5SSteve French return; 81138c8a9a5SSteve French } 812*e8aee4f4SEnzo Matsumiya 813*e8aee4f4SEnzo Matsumiya alg = ctxt->CompressionAlgorithms[0]; 814*e8aee4f4SEnzo Matsumiya 815*e8aee4f4SEnzo Matsumiya /* 'NONE' (0) compressor type is never negotiated */ 816*e8aee4f4SEnzo Matsumiya if (alg == 0 || le16_to_cpu(alg) > 3) { 817*e8aee4f4SEnzo Matsumiya pr_warn_once("invalid compression algorithm '%u'\n", alg); 81838c8a9a5SSteve French return; 81938c8a9a5SSteve French } 820*e8aee4f4SEnzo Matsumiya 821*e8aee4f4SEnzo Matsumiya server->compression.alg = alg; 822*e8aee4f4SEnzo Matsumiya server->compression.enabled = true; 82338c8a9a5SSteve French } 82438c8a9a5SSteve French 82538c8a9a5SSteve French static int decode_encrypt_ctx(struct TCP_Server_Info *server, 82638c8a9a5SSteve French struct smb2_encryption_neg_context *ctxt) 82738c8a9a5SSteve French { 82838c8a9a5SSteve French unsigned int len = le16_to_cpu(ctxt->DataLength); 82938c8a9a5SSteve French 83038c8a9a5SSteve French cifs_dbg(FYI, "decode SMB3.11 encryption neg context of len %d\n", len); 83138c8a9a5SSteve French /* 83238c8a9a5SSteve French * Caller checked that DataLength remains within SMB boundary. We still 83338c8a9a5SSteve French * need to confirm that one Cipher flexible array member is accounted 83438c8a9a5SSteve French * for. 83538c8a9a5SSteve French */ 83638c8a9a5SSteve French if (len < MIN_ENCRYPT_CTXT_DATA_LEN) { 83738c8a9a5SSteve French pr_warn_once("server sent bad crypto ctxt len\n"); 83838c8a9a5SSteve French return -EINVAL; 83938c8a9a5SSteve French } 84038c8a9a5SSteve French 84138c8a9a5SSteve French if (le16_to_cpu(ctxt->CipherCount) != 1) { 84238c8a9a5SSteve French pr_warn_once("Invalid SMB3.11 cipher count\n"); 84338c8a9a5SSteve French return -EINVAL; 84438c8a9a5SSteve French } 84538c8a9a5SSteve French cifs_dbg(FYI, "SMB311 cipher type:%d\n", le16_to_cpu(ctxt->Ciphers[0])); 84638c8a9a5SSteve French if (require_gcm_256) { 84738c8a9a5SSteve French if (ctxt->Ciphers[0] != SMB2_ENCRYPTION_AES256_GCM) { 84838c8a9a5SSteve French cifs_dbg(VFS, "Server does not support requested encryption type (AES256 GCM)\n"); 84938c8a9a5SSteve French return -EOPNOTSUPP; 85038c8a9a5SSteve French } 85138c8a9a5SSteve French } else if (ctxt->Ciphers[0] == 0) { 85238c8a9a5SSteve French /* 85338c8a9a5SSteve French * e.g. if server only supported AES256_CCM (very unlikely) 85438c8a9a5SSteve French * or server supported no encryption types or had all disabled. 85538c8a9a5SSteve French * Since GLOBAL_CAP_ENCRYPTION will be not set, in the case 85638c8a9a5SSteve French * in which mount requested encryption ("seal") checks later 85738c8a9a5SSteve French * on during tree connection will return proper rc, but if 85838c8a9a5SSteve French * seal not requested by client, since server is allowed to 85938c8a9a5SSteve French * return 0 to indicate no supported cipher, we can't fail here 86038c8a9a5SSteve French */ 86138c8a9a5SSteve French server->cipher_type = 0; 86238c8a9a5SSteve French server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION; 86338c8a9a5SSteve French pr_warn_once("Server does not support requested encryption types\n"); 86438c8a9a5SSteve French return 0; 86538c8a9a5SSteve French } else if ((ctxt->Ciphers[0] != SMB2_ENCRYPTION_AES128_CCM) && 86638c8a9a5SSteve French (ctxt->Ciphers[0] != SMB2_ENCRYPTION_AES128_GCM) && 86738c8a9a5SSteve French (ctxt->Ciphers[0] != SMB2_ENCRYPTION_AES256_GCM)) { 86838c8a9a5SSteve French /* server returned a cipher we didn't ask for */ 86938c8a9a5SSteve French pr_warn_once("Invalid SMB3.11 cipher returned\n"); 87038c8a9a5SSteve French return -EINVAL; 87138c8a9a5SSteve French } 87238c8a9a5SSteve French server->cipher_type = ctxt->Ciphers[0]; 87338c8a9a5SSteve French server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION; 87438c8a9a5SSteve French return 0; 87538c8a9a5SSteve French } 87638c8a9a5SSteve French 87738c8a9a5SSteve French static void decode_signing_ctx(struct TCP_Server_Info *server, 87838c8a9a5SSteve French struct smb2_signing_capabilities *pctxt) 87938c8a9a5SSteve French { 88038c8a9a5SSteve French unsigned int len = le16_to_cpu(pctxt->DataLength); 88138c8a9a5SSteve French 88238c8a9a5SSteve French /* 88338c8a9a5SSteve French * Caller checked that DataLength remains within SMB boundary. We still 88438c8a9a5SSteve French * need to confirm that one SigningAlgorithms flexible array member is 88538c8a9a5SSteve French * accounted for. 88638c8a9a5SSteve French */ 88738c8a9a5SSteve French if ((len < 4) || (len > 16)) { 88838c8a9a5SSteve French pr_warn_once("server sent bad signing negcontext\n"); 88938c8a9a5SSteve French return; 89038c8a9a5SSteve French } 89138c8a9a5SSteve French if (le16_to_cpu(pctxt->SigningAlgorithmCount) != 1) { 89238c8a9a5SSteve French pr_warn_once("Invalid signing algorithm count\n"); 89338c8a9a5SSteve French return; 89438c8a9a5SSteve French } 89538c8a9a5SSteve French if (le16_to_cpu(pctxt->SigningAlgorithms[0]) > 2) { 89638c8a9a5SSteve French pr_warn_once("unknown signing algorithm\n"); 89738c8a9a5SSteve French return; 89838c8a9a5SSteve French } 89938c8a9a5SSteve French 90038c8a9a5SSteve French server->signing_negotiated = true; 90138c8a9a5SSteve French server->signing_algorithm = le16_to_cpu(pctxt->SigningAlgorithms[0]); 90238c8a9a5SSteve French cifs_dbg(FYI, "signing algorithm %d chosen\n", 90338c8a9a5SSteve French server->signing_algorithm); 90438c8a9a5SSteve French } 90538c8a9a5SSteve French 90638c8a9a5SSteve French 90738c8a9a5SSteve French static int smb311_decode_neg_context(struct smb2_negotiate_rsp *rsp, 90838c8a9a5SSteve French struct TCP_Server_Info *server, 90938c8a9a5SSteve French unsigned int len_of_smb) 91038c8a9a5SSteve French { 91138c8a9a5SSteve French struct smb2_neg_context *pctx; 91238c8a9a5SSteve French unsigned int offset = le32_to_cpu(rsp->NegotiateContextOffset); 91338c8a9a5SSteve French unsigned int ctxt_cnt = le16_to_cpu(rsp->NegotiateContextCount); 91438c8a9a5SSteve French unsigned int len_of_ctxts, i; 91538c8a9a5SSteve French int rc = 0; 91638c8a9a5SSteve French 91738c8a9a5SSteve French cifs_dbg(FYI, "decoding %d negotiate contexts\n", ctxt_cnt); 91838c8a9a5SSteve French if (len_of_smb <= offset) { 91938c8a9a5SSteve French cifs_server_dbg(VFS, "Invalid response: negotiate context offset\n"); 92038c8a9a5SSteve French return -EINVAL; 92138c8a9a5SSteve French } 92238c8a9a5SSteve French 92338c8a9a5SSteve French len_of_ctxts = len_of_smb - offset; 92438c8a9a5SSteve French 92538c8a9a5SSteve French for (i = 0; i < ctxt_cnt; i++) { 92638c8a9a5SSteve French int clen; 92738c8a9a5SSteve French /* check that offset is not beyond end of SMB */ 92838c8a9a5SSteve French if (len_of_ctxts < sizeof(struct smb2_neg_context)) 92938c8a9a5SSteve French break; 93038c8a9a5SSteve French 93138c8a9a5SSteve French pctx = (struct smb2_neg_context *)(offset + (char *)rsp); 93238c8a9a5SSteve French clen = sizeof(struct smb2_neg_context) 93338c8a9a5SSteve French + le16_to_cpu(pctx->DataLength); 93438c8a9a5SSteve French /* 93538c8a9a5SSteve French * 2.2.4 SMB2 NEGOTIATE Response 93638c8a9a5SSteve French * Subsequent negotiate contexts MUST appear at the first 8-byte 93738c8a9a5SSteve French * aligned offset following the previous negotiate context. 93838c8a9a5SSteve French */ 93938c8a9a5SSteve French if (i + 1 != ctxt_cnt) 94038c8a9a5SSteve French clen = ALIGN(clen, 8); 94138c8a9a5SSteve French if (clen > len_of_ctxts) 94238c8a9a5SSteve French break; 94338c8a9a5SSteve French 94438c8a9a5SSteve French if (pctx->ContextType == SMB2_PREAUTH_INTEGRITY_CAPABILITIES) 94538c8a9a5SSteve French decode_preauth_context( 94638c8a9a5SSteve French (struct smb2_preauth_neg_context *)pctx); 94738c8a9a5SSteve French else if (pctx->ContextType == SMB2_ENCRYPTION_CAPABILITIES) 94838c8a9a5SSteve French rc = decode_encrypt_ctx(server, 94938c8a9a5SSteve French (struct smb2_encryption_neg_context *)pctx); 95038c8a9a5SSteve French else if (pctx->ContextType == SMB2_COMPRESSION_CAPABILITIES) 95138c8a9a5SSteve French decode_compress_ctx(server, 95238c8a9a5SSteve French (struct smb2_compression_capabilities_context *)pctx); 95338c8a9a5SSteve French else if (pctx->ContextType == SMB2_POSIX_EXTENSIONS_AVAILABLE) 95438c8a9a5SSteve French server->posix_ext_supported = true; 95538c8a9a5SSteve French else if (pctx->ContextType == SMB2_SIGNING_CAPABILITIES) 95638c8a9a5SSteve French decode_signing_ctx(server, 95738c8a9a5SSteve French (struct smb2_signing_capabilities *)pctx); 95838c8a9a5SSteve French else 95938c8a9a5SSteve French cifs_server_dbg(VFS, "unknown negcontext of type %d ignored\n", 96038c8a9a5SSteve French le16_to_cpu(pctx->ContextType)); 96138c8a9a5SSteve French if (rc) 96238c8a9a5SSteve French break; 96338c8a9a5SSteve French 96438c8a9a5SSteve French offset += clen; 96538c8a9a5SSteve French len_of_ctxts -= clen; 96638c8a9a5SSteve French } 96738c8a9a5SSteve French return rc; 96838c8a9a5SSteve French } 96938c8a9a5SSteve French 97038c8a9a5SSteve French static struct create_posix * 97138c8a9a5SSteve French create_posix_buf(umode_t mode) 97238c8a9a5SSteve French { 97338c8a9a5SSteve French struct create_posix *buf; 97438c8a9a5SSteve French 97538c8a9a5SSteve French buf = kzalloc(sizeof(struct create_posix), 97638c8a9a5SSteve French GFP_KERNEL); 97738c8a9a5SSteve French if (!buf) 97838c8a9a5SSteve French return NULL; 97938c8a9a5SSteve French 98038c8a9a5SSteve French buf->ccontext.DataOffset = 98138c8a9a5SSteve French cpu_to_le16(offsetof(struct create_posix, Mode)); 98238c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(4); 98338c8a9a5SSteve French buf->ccontext.NameOffset = 98438c8a9a5SSteve French cpu_to_le16(offsetof(struct create_posix, Name)); 98538c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(16); 98638c8a9a5SSteve French 98738c8a9a5SSteve French /* SMB2_CREATE_TAG_POSIX is "0x93AD25509CB411E7B42383DE968BCD7C" */ 98838c8a9a5SSteve French buf->Name[0] = 0x93; 98938c8a9a5SSteve French buf->Name[1] = 0xAD; 99038c8a9a5SSteve French buf->Name[2] = 0x25; 99138c8a9a5SSteve French buf->Name[3] = 0x50; 99238c8a9a5SSteve French buf->Name[4] = 0x9C; 99338c8a9a5SSteve French buf->Name[5] = 0xB4; 99438c8a9a5SSteve French buf->Name[6] = 0x11; 99538c8a9a5SSteve French buf->Name[7] = 0xE7; 99638c8a9a5SSteve French buf->Name[8] = 0xB4; 99738c8a9a5SSteve French buf->Name[9] = 0x23; 99838c8a9a5SSteve French buf->Name[10] = 0x83; 99938c8a9a5SSteve French buf->Name[11] = 0xDE; 100038c8a9a5SSteve French buf->Name[12] = 0x96; 100138c8a9a5SSteve French buf->Name[13] = 0x8B; 100238c8a9a5SSteve French buf->Name[14] = 0xCD; 100338c8a9a5SSteve French buf->Name[15] = 0x7C; 100438c8a9a5SSteve French buf->Mode = cpu_to_le32(mode); 100538c8a9a5SSteve French cifs_dbg(FYI, "mode on posix create 0%o\n", mode); 100638c8a9a5SSteve French return buf; 100738c8a9a5SSteve French } 100838c8a9a5SSteve French 100938c8a9a5SSteve French static int 101038c8a9a5SSteve French add_posix_context(struct kvec *iov, unsigned int *num_iovec, umode_t mode) 101138c8a9a5SSteve French { 101238c8a9a5SSteve French unsigned int num = *num_iovec; 101338c8a9a5SSteve French 101438c8a9a5SSteve French iov[num].iov_base = create_posix_buf(mode); 101538c8a9a5SSteve French if (mode == ACL_NO_MODE) 1016c8ebf077SSteve French cifs_dbg(FYI, "%s: no mode\n", __func__); 101738c8a9a5SSteve French if (iov[num].iov_base == NULL) 101838c8a9a5SSteve French return -ENOMEM; 101938c8a9a5SSteve French iov[num].iov_len = sizeof(struct create_posix); 102038c8a9a5SSteve French *num_iovec = num + 1; 102138c8a9a5SSteve French return 0; 102238c8a9a5SSteve French } 102338c8a9a5SSteve French 102438c8a9a5SSteve French 102538c8a9a5SSteve French /* 102638c8a9a5SSteve French * 102738c8a9a5SSteve French * SMB2 Worker functions follow: 102838c8a9a5SSteve French * 102938c8a9a5SSteve French * The general structure of the worker functions is: 103038c8a9a5SSteve French * 1) Call smb2_init (assembles SMB2 header) 103138c8a9a5SSteve French * 2) Initialize SMB2 command specific fields in fixed length area of SMB 103238c8a9a5SSteve French * 3) Call smb_sendrcv2 (sends request on socket and waits for response) 103338c8a9a5SSteve French * 4) Decode SMB2 command specific fields in the fixed length area 103438c8a9a5SSteve French * 5) Decode variable length data area (if any for this SMB2 command type) 103538c8a9a5SSteve French * 6) Call free smb buffer 103638c8a9a5SSteve French * 7) return 103738c8a9a5SSteve French * 103838c8a9a5SSteve French */ 103938c8a9a5SSteve French 104038c8a9a5SSteve French int 104138c8a9a5SSteve French SMB2_negotiate(const unsigned int xid, 104238c8a9a5SSteve French struct cifs_ses *ses, 104338c8a9a5SSteve French struct TCP_Server_Info *server) 104438c8a9a5SSteve French { 104538c8a9a5SSteve French struct smb_rqst rqst; 104638c8a9a5SSteve French struct smb2_negotiate_req *req; 104738c8a9a5SSteve French struct smb2_negotiate_rsp *rsp; 104838c8a9a5SSteve French struct kvec iov[1]; 104938c8a9a5SSteve French struct kvec rsp_iov; 105038c8a9a5SSteve French int rc; 105138c8a9a5SSteve French int resp_buftype; 105238c8a9a5SSteve French int blob_offset, blob_length; 105338c8a9a5SSteve French char *security_blob; 105438c8a9a5SSteve French int flags = CIFS_NEG_OP; 105538c8a9a5SSteve French unsigned int total_len; 105638c8a9a5SSteve French 105738c8a9a5SSteve French cifs_dbg(FYI, "Negotiate protocol\n"); 105838c8a9a5SSteve French 105938c8a9a5SSteve French if (!server) { 106038c8a9a5SSteve French WARN(1, "%s: server is NULL!\n", __func__); 106138c8a9a5SSteve French return -EIO; 106238c8a9a5SSteve French } 106338c8a9a5SSteve French 106438c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server, 106538c8a9a5SSteve French (void **) &req, &total_len); 106638c8a9a5SSteve French if (rc) 106738c8a9a5SSteve French return rc; 106838c8a9a5SSteve French 106938c8a9a5SSteve French req->hdr.SessionId = 0; 107038c8a9a5SSteve French 107138c8a9a5SSteve French memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE); 107238c8a9a5SSteve French memset(ses->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE); 107338c8a9a5SSteve French 107438c8a9a5SSteve French if (strcmp(server->vals->version_string, 107538c8a9a5SSteve French SMB3ANY_VERSION_STRING) == 0) { 107638c8a9a5SSteve French req->Dialects[0] = cpu_to_le16(SMB30_PROT_ID); 107738c8a9a5SSteve French req->Dialects[1] = cpu_to_le16(SMB302_PROT_ID); 107838c8a9a5SSteve French req->Dialects[2] = cpu_to_le16(SMB311_PROT_ID); 107938c8a9a5SSteve French req->DialectCount = cpu_to_le16(3); 108038c8a9a5SSteve French total_len += 6; 108138c8a9a5SSteve French } else if (strcmp(server->vals->version_string, 108238c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0) { 108338c8a9a5SSteve French req->Dialects[0] = cpu_to_le16(SMB21_PROT_ID); 108438c8a9a5SSteve French req->Dialects[1] = cpu_to_le16(SMB30_PROT_ID); 108538c8a9a5SSteve French req->Dialects[2] = cpu_to_le16(SMB302_PROT_ID); 108638c8a9a5SSteve French req->Dialects[3] = cpu_to_le16(SMB311_PROT_ID); 108738c8a9a5SSteve French req->DialectCount = cpu_to_le16(4); 108838c8a9a5SSteve French total_len += 8; 108938c8a9a5SSteve French } else { 109038c8a9a5SSteve French /* otherwise send specific dialect */ 109138c8a9a5SSteve French req->Dialects[0] = cpu_to_le16(server->vals->protocol_id); 109238c8a9a5SSteve French req->DialectCount = cpu_to_le16(1); 109338c8a9a5SSteve French total_len += 2; 109438c8a9a5SSteve French } 109538c8a9a5SSteve French 109638c8a9a5SSteve French /* only one of SMB2 signing flags may be set in SMB2 request */ 109738c8a9a5SSteve French if (ses->sign) 109838c8a9a5SSteve French req->SecurityMode = cpu_to_le16(SMB2_NEGOTIATE_SIGNING_REQUIRED); 109938c8a9a5SSteve French else if (global_secflags & CIFSSEC_MAY_SIGN) 110038c8a9a5SSteve French req->SecurityMode = cpu_to_le16(SMB2_NEGOTIATE_SIGNING_ENABLED); 110138c8a9a5SSteve French else 110238c8a9a5SSteve French req->SecurityMode = 0; 110338c8a9a5SSteve French 110438c8a9a5SSteve French req->Capabilities = cpu_to_le32(server->vals->req_capabilities); 110538c8a9a5SSteve French if (ses->chan_max > 1) 110638c8a9a5SSteve French req->Capabilities |= cpu_to_le32(SMB2_GLOBAL_CAP_MULTI_CHANNEL); 110738c8a9a5SSteve French 110838c8a9a5SSteve French /* ClientGUID must be zero for SMB2.02 dialect */ 110938c8a9a5SSteve French if (server->vals->protocol_id == SMB20_PROT_ID) 111038c8a9a5SSteve French memset(req->ClientGUID, 0, SMB2_CLIENT_GUID_SIZE); 111138c8a9a5SSteve French else { 111238c8a9a5SSteve French memcpy(req->ClientGUID, server->client_guid, 111338c8a9a5SSteve French SMB2_CLIENT_GUID_SIZE); 111438c8a9a5SSteve French if ((server->vals->protocol_id == SMB311_PROT_ID) || 111538c8a9a5SSteve French (strcmp(server->vals->version_string, 111638c8a9a5SSteve French SMB3ANY_VERSION_STRING) == 0) || 111738c8a9a5SSteve French (strcmp(server->vals->version_string, 111838c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0)) 111938c8a9a5SSteve French assemble_neg_contexts(req, server, &total_len); 112038c8a9a5SSteve French } 112138c8a9a5SSteve French iov[0].iov_base = (char *)req; 112238c8a9a5SSteve French iov[0].iov_len = total_len; 112338c8a9a5SSteve French 112438c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 112538c8a9a5SSteve French rqst.rq_iov = iov; 112638c8a9a5SSteve French rqst.rq_nvec = 1; 112738c8a9a5SSteve French 112838c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 112938c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 113038c8a9a5SSteve French cifs_small_buf_release(req); 113138c8a9a5SSteve French rsp = (struct smb2_negotiate_rsp *)rsp_iov.iov_base; 113238c8a9a5SSteve French /* 113338c8a9a5SSteve French * No tcon so can't do 113438c8a9a5SSteve French * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]); 113538c8a9a5SSteve French */ 113638c8a9a5SSteve French if (rc == -EOPNOTSUPP) { 113738c8a9a5SSteve French cifs_server_dbg(VFS, "Dialect not supported by server. Consider specifying vers=1.0 or vers=2.0 on mount for accessing older servers\n"); 113838c8a9a5SSteve French goto neg_exit; 113938c8a9a5SSteve French } else if (rc != 0) 114038c8a9a5SSteve French goto neg_exit; 114138c8a9a5SSteve French 114238c8a9a5SSteve French rc = -EIO; 114338c8a9a5SSteve French if (strcmp(server->vals->version_string, 114438c8a9a5SSteve French SMB3ANY_VERSION_STRING) == 0) { 114538c8a9a5SSteve French if (rsp->DialectRevision == cpu_to_le16(SMB20_PROT_ID)) { 114638c8a9a5SSteve French cifs_server_dbg(VFS, 114738c8a9a5SSteve French "SMB2 dialect returned but not requested\n"); 114838c8a9a5SSteve French goto neg_exit; 114938c8a9a5SSteve French } else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID)) { 115038c8a9a5SSteve French cifs_server_dbg(VFS, 115138c8a9a5SSteve French "SMB2.1 dialect returned but not requested\n"); 115238c8a9a5SSteve French goto neg_exit; 115338c8a9a5SSteve French } else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) { 115438c8a9a5SSteve French /* ops set to 3.0 by default for default so update */ 115538c8a9a5SSteve French server->ops = &smb311_operations; 115638c8a9a5SSteve French server->vals = &smb311_values; 115738c8a9a5SSteve French } 115838c8a9a5SSteve French } else if (strcmp(server->vals->version_string, 115938c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0) { 116038c8a9a5SSteve French if (rsp->DialectRevision == cpu_to_le16(SMB20_PROT_ID)) { 116138c8a9a5SSteve French cifs_server_dbg(VFS, 116238c8a9a5SSteve French "SMB2 dialect returned but not requested\n"); 116338c8a9a5SSteve French goto neg_exit; 116438c8a9a5SSteve French } else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID)) { 116538c8a9a5SSteve French /* ops set to 3.0 by default for default so update */ 116638c8a9a5SSteve French server->ops = &smb21_operations; 116738c8a9a5SSteve French server->vals = &smb21_values; 116838c8a9a5SSteve French } else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) { 116938c8a9a5SSteve French server->ops = &smb311_operations; 117038c8a9a5SSteve French server->vals = &smb311_values; 117138c8a9a5SSteve French } 117238c8a9a5SSteve French } else if (le16_to_cpu(rsp->DialectRevision) != 117338c8a9a5SSteve French server->vals->protocol_id) { 117438c8a9a5SSteve French /* if requested single dialect ensure returned dialect matched */ 117538c8a9a5SSteve French cifs_server_dbg(VFS, "Invalid 0x%x dialect returned: not requested\n", 117638c8a9a5SSteve French le16_to_cpu(rsp->DialectRevision)); 117738c8a9a5SSteve French goto neg_exit; 117838c8a9a5SSteve French } 117938c8a9a5SSteve French 118038c8a9a5SSteve French cifs_dbg(FYI, "mode 0x%x\n", rsp->SecurityMode); 118138c8a9a5SSteve French 118238c8a9a5SSteve French if (rsp->DialectRevision == cpu_to_le16(SMB20_PROT_ID)) 118338c8a9a5SSteve French cifs_dbg(FYI, "negotiated smb2.0 dialect\n"); 118438c8a9a5SSteve French else if (rsp->DialectRevision == cpu_to_le16(SMB21_PROT_ID)) 118538c8a9a5SSteve French cifs_dbg(FYI, "negotiated smb2.1 dialect\n"); 118638c8a9a5SSteve French else if (rsp->DialectRevision == cpu_to_le16(SMB30_PROT_ID)) 118738c8a9a5SSteve French cifs_dbg(FYI, "negotiated smb3.0 dialect\n"); 118838c8a9a5SSteve French else if (rsp->DialectRevision == cpu_to_le16(SMB302_PROT_ID)) 118938c8a9a5SSteve French cifs_dbg(FYI, "negotiated smb3.02 dialect\n"); 119038c8a9a5SSteve French else if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) 119138c8a9a5SSteve French cifs_dbg(FYI, "negotiated smb3.1.1 dialect\n"); 119238c8a9a5SSteve French else { 119338c8a9a5SSteve French cifs_server_dbg(VFS, "Invalid dialect returned by server 0x%x\n", 119438c8a9a5SSteve French le16_to_cpu(rsp->DialectRevision)); 119538c8a9a5SSteve French goto neg_exit; 119638c8a9a5SSteve French } 119738c8a9a5SSteve French 119838c8a9a5SSteve French rc = 0; 119938c8a9a5SSteve French server->dialect = le16_to_cpu(rsp->DialectRevision); 120038c8a9a5SSteve French 120138c8a9a5SSteve French /* 120238c8a9a5SSteve French * Keep a copy of the hash after negprot. This hash will be 120338c8a9a5SSteve French * the starting hash value for all sessions made from this 120438c8a9a5SSteve French * server. 120538c8a9a5SSteve French */ 120638c8a9a5SSteve French memcpy(server->preauth_sha_hash, ses->preauth_sha_hash, 120738c8a9a5SSteve French SMB2_PREAUTH_HASH_SIZE); 120838c8a9a5SSteve French 120938c8a9a5SSteve French /* SMB2 only has an extended negflavor */ 121038c8a9a5SSteve French server->negflavor = CIFS_NEGFLAVOR_EXTENDED; 121138c8a9a5SSteve French /* set it to the maximum buffer size value we can send with 1 credit */ 121238c8a9a5SSteve French server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize), 121338c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE); 121438c8a9a5SSteve French server->max_read = le32_to_cpu(rsp->MaxReadSize); 121538c8a9a5SSteve French server->max_write = le32_to_cpu(rsp->MaxWriteSize); 121638c8a9a5SSteve French server->sec_mode = le16_to_cpu(rsp->SecurityMode); 121738c8a9a5SSteve French if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode) 121838c8a9a5SSteve French cifs_dbg(FYI, "Server returned unexpected security mode 0x%x\n", 121938c8a9a5SSteve French server->sec_mode); 122038c8a9a5SSteve French server->capabilities = le32_to_cpu(rsp->Capabilities); 122138c8a9a5SSteve French /* Internal types */ 122238c8a9a5SSteve French server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES; 122338c8a9a5SSteve French 122438c8a9a5SSteve French /* 122538c8a9a5SSteve French * SMB3.0 supports only 1 cipher and doesn't have a encryption neg context 122638c8a9a5SSteve French * Set the cipher type manually. 122738c8a9a5SSteve French */ 122838c8a9a5SSteve French if (server->dialect == SMB30_PROT_ID && (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)) 122938c8a9a5SSteve French server->cipher_type = SMB2_ENCRYPTION_AES128_CCM; 123038c8a9a5SSteve French 123138c8a9a5SSteve French security_blob = smb2_get_data_area_len(&blob_offset, &blob_length, 123238c8a9a5SSteve French (struct smb2_hdr *)rsp); 123338c8a9a5SSteve French /* 123438c8a9a5SSteve French * See MS-SMB2 section 2.2.4: if no blob, client picks default which 123538c8a9a5SSteve French * for us will be 123638c8a9a5SSteve French * ses->sectype = RawNTLMSSP; 123738c8a9a5SSteve French * but for time being this is our only auth choice so doesn't matter. 123838c8a9a5SSteve French * We just found a server which sets blob length to zero expecting raw. 123938c8a9a5SSteve French */ 124038c8a9a5SSteve French if (blob_length == 0) { 124138c8a9a5SSteve French cifs_dbg(FYI, "missing security blob on negprot\n"); 124238c8a9a5SSteve French server->sec_ntlmssp = true; 124338c8a9a5SSteve French } 124438c8a9a5SSteve French 124538c8a9a5SSteve French rc = cifs_enable_signing(server, ses->sign); 124638c8a9a5SSteve French if (rc) 124738c8a9a5SSteve French goto neg_exit; 124838c8a9a5SSteve French if (blob_length) { 124938c8a9a5SSteve French rc = decode_negTokenInit(security_blob, blob_length, server); 125038c8a9a5SSteve French if (rc == 1) 125138c8a9a5SSteve French rc = 0; 125238c8a9a5SSteve French else if (rc == 0) 125338c8a9a5SSteve French rc = -EIO; 125438c8a9a5SSteve French } 125538c8a9a5SSteve French 125638c8a9a5SSteve French if (rsp->DialectRevision == cpu_to_le16(SMB311_PROT_ID)) { 125738c8a9a5SSteve French if (rsp->NegotiateContextCount) 125838c8a9a5SSteve French rc = smb311_decode_neg_context(rsp, server, 125938c8a9a5SSteve French rsp_iov.iov_len); 126038c8a9a5SSteve French else 126138c8a9a5SSteve French cifs_server_dbg(VFS, "Missing expected negotiate contexts\n"); 126238c8a9a5SSteve French } 126338c8a9a5SSteve French neg_exit: 126438c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 126538c8a9a5SSteve French return rc; 126638c8a9a5SSteve French } 126738c8a9a5SSteve French 126838c8a9a5SSteve French int smb3_validate_negotiate(const unsigned int xid, struct cifs_tcon *tcon) 126938c8a9a5SSteve French { 127038c8a9a5SSteve French int rc; 127138c8a9a5SSteve French struct validate_negotiate_info_req *pneg_inbuf; 127238c8a9a5SSteve French struct validate_negotiate_info_rsp *pneg_rsp = NULL; 127338c8a9a5SSteve French u32 rsplen; 127438c8a9a5SSteve French u32 inbuflen; /* max of 4 dialects */ 127538c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 127638c8a9a5SSteve French 127738c8a9a5SSteve French cifs_dbg(FYI, "validate negotiate\n"); 127838c8a9a5SSteve French 127938c8a9a5SSteve French /* In SMB3.11 preauth integrity supersedes validate negotiate */ 128038c8a9a5SSteve French if (server->dialect == SMB311_PROT_ID) 128138c8a9a5SSteve French return 0; 128238c8a9a5SSteve French 128338c8a9a5SSteve French /* 128438c8a9a5SSteve French * validation ioctl must be signed, so no point sending this if we 128538c8a9a5SSteve French * can not sign it (ie are not known user). Even if signing is not 128638c8a9a5SSteve French * required (enabled but not negotiated), in those cases we selectively 128738c8a9a5SSteve French * sign just this, the first and only signed request on a connection. 128838c8a9a5SSteve French * Having validation of negotiate info helps reduce attack vectors. 128938c8a9a5SSteve French */ 129038c8a9a5SSteve French if (tcon->ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST) 129138c8a9a5SSteve French return 0; /* validation requires signing */ 129238c8a9a5SSteve French 129338c8a9a5SSteve French if (tcon->ses->user_name == NULL) { 129438c8a9a5SSteve French cifs_dbg(FYI, "Can't validate negotiate: null user mount\n"); 129538c8a9a5SSteve French return 0; /* validation requires signing */ 129638c8a9a5SSteve French } 129738c8a9a5SSteve French 129838c8a9a5SSteve French if (tcon->ses->session_flags & SMB2_SESSION_FLAG_IS_NULL) 129938c8a9a5SSteve French cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n"); 130038c8a9a5SSteve French 130138c8a9a5SSteve French pneg_inbuf = kmalloc(sizeof(*pneg_inbuf), GFP_NOFS); 130238c8a9a5SSteve French if (!pneg_inbuf) 130338c8a9a5SSteve French return -ENOMEM; 130438c8a9a5SSteve French 130538c8a9a5SSteve French pneg_inbuf->Capabilities = 130638c8a9a5SSteve French cpu_to_le32(server->vals->req_capabilities); 130738c8a9a5SSteve French if (tcon->ses->chan_max > 1) 130838c8a9a5SSteve French pneg_inbuf->Capabilities |= cpu_to_le32(SMB2_GLOBAL_CAP_MULTI_CHANNEL); 130938c8a9a5SSteve French 131038c8a9a5SSteve French memcpy(pneg_inbuf->Guid, server->client_guid, 131138c8a9a5SSteve French SMB2_CLIENT_GUID_SIZE); 131238c8a9a5SSteve French 131338c8a9a5SSteve French if (tcon->ses->sign) 131438c8a9a5SSteve French pneg_inbuf->SecurityMode = 131538c8a9a5SSteve French cpu_to_le16(SMB2_NEGOTIATE_SIGNING_REQUIRED); 131638c8a9a5SSteve French else if (global_secflags & CIFSSEC_MAY_SIGN) 131738c8a9a5SSteve French pneg_inbuf->SecurityMode = 131838c8a9a5SSteve French cpu_to_le16(SMB2_NEGOTIATE_SIGNING_ENABLED); 131938c8a9a5SSteve French else 132038c8a9a5SSteve French pneg_inbuf->SecurityMode = 0; 132138c8a9a5SSteve French 132238c8a9a5SSteve French 132338c8a9a5SSteve French if (strcmp(server->vals->version_string, 132438c8a9a5SSteve French SMB3ANY_VERSION_STRING) == 0) { 132538c8a9a5SSteve French pneg_inbuf->Dialects[0] = cpu_to_le16(SMB30_PROT_ID); 132638c8a9a5SSteve French pneg_inbuf->Dialects[1] = cpu_to_le16(SMB302_PROT_ID); 132738c8a9a5SSteve French pneg_inbuf->Dialects[2] = cpu_to_le16(SMB311_PROT_ID); 132838c8a9a5SSteve French pneg_inbuf->DialectCount = cpu_to_le16(3); 132938c8a9a5SSteve French /* SMB 2.1 not included so subtract one dialect from len */ 133038c8a9a5SSteve French inbuflen = sizeof(*pneg_inbuf) - 133138c8a9a5SSteve French (sizeof(pneg_inbuf->Dialects[0])); 133238c8a9a5SSteve French } else if (strcmp(server->vals->version_string, 133338c8a9a5SSteve French SMBDEFAULT_VERSION_STRING) == 0) { 133438c8a9a5SSteve French pneg_inbuf->Dialects[0] = cpu_to_le16(SMB21_PROT_ID); 133538c8a9a5SSteve French pneg_inbuf->Dialects[1] = cpu_to_le16(SMB30_PROT_ID); 133638c8a9a5SSteve French pneg_inbuf->Dialects[2] = cpu_to_le16(SMB302_PROT_ID); 133738c8a9a5SSteve French pneg_inbuf->Dialects[3] = cpu_to_le16(SMB311_PROT_ID); 133838c8a9a5SSteve French pneg_inbuf->DialectCount = cpu_to_le16(4); 133938c8a9a5SSteve French /* structure is big enough for 4 dialects */ 134038c8a9a5SSteve French inbuflen = sizeof(*pneg_inbuf); 134138c8a9a5SSteve French } else { 134238c8a9a5SSteve French /* otherwise specific dialect was requested */ 134338c8a9a5SSteve French pneg_inbuf->Dialects[0] = 134438c8a9a5SSteve French cpu_to_le16(server->vals->protocol_id); 134538c8a9a5SSteve French pneg_inbuf->DialectCount = cpu_to_le16(1); 134638c8a9a5SSteve French /* structure is big enough for 4 dialects, sending only 1 */ 134738c8a9a5SSteve French inbuflen = sizeof(*pneg_inbuf) - 134838c8a9a5SSteve French sizeof(pneg_inbuf->Dialects[0]) * 3; 134938c8a9a5SSteve French } 135038c8a9a5SSteve French 135138c8a9a5SSteve French rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, 135238c8a9a5SSteve French FSCTL_VALIDATE_NEGOTIATE_INFO, 135338c8a9a5SSteve French (char *)pneg_inbuf, inbuflen, CIFSMaxBufSize, 135438c8a9a5SSteve French (char **)&pneg_rsp, &rsplen); 135538c8a9a5SSteve French if (rc == -EOPNOTSUPP) { 135638c8a9a5SSteve French /* 135738c8a9a5SSteve French * Old Windows versions or Netapp SMB server can return 135838c8a9a5SSteve French * not supported error. Client should accept it. 135938c8a9a5SSteve French */ 136038c8a9a5SSteve French cifs_tcon_dbg(VFS, "Server does not support validate negotiate\n"); 136138c8a9a5SSteve French rc = 0; 136238c8a9a5SSteve French goto out_free_inbuf; 136338c8a9a5SSteve French } else if (rc != 0) { 136438c8a9a5SSteve French cifs_tcon_dbg(VFS, "validate protocol negotiate failed: %d\n", 136538c8a9a5SSteve French rc); 136638c8a9a5SSteve French rc = -EIO; 136738c8a9a5SSteve French goto out_free_inbuf; 136838c8a9a5SSteve French } 136938c8a9a5SSteve French 137038c8a9a5SSteve French rc = -EIO; 137138c8a9a5SSteve French if (rsplen != sizeof(*pneg_rsp)) { 137238c8a9a5SSteve French cifs_tcon_dbg(VFS, "Invalid protocol negotiate response size: %d\n", 137338c8a9a5SSteve French rsplen); 137438c8a9a5SSteve French 137538c8a9a5SSteve French /* relax check since Mac returns max bufsize allowed on ioctl */ 137638c8a9a5SSteve French if (rsplen > CIFSMaxBufSize || rsplen < sizeof(*pneg_rsp)) 137738c8a9a5SSteve French goto out_free_rsp; 137838c8a9a5SSteve French } 137938c8a9a5SSteve French 138038c8a9a5SSteve French /* check validate negotiate info response matches what we got earlier */ 138138c8a9a5SSteve French if (pneg_rsp->Dialect != cpu_to_le16(server->dialect)) 138238c8a9a5SSteve French goto vneg_out; 138338c8a9a5SSteve French 138438c8a9a5SSteve French if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode)) 138538c8a9a5SSteve French goto vneg_out; 138638c8a9a5SSteve French 138738c8a9a5SSteve French /* do not validate server guid because not saved at negprot time yet */ 138838c8a9a5SSteve French 138938c8a9a5SSteve French if ((le32_to_cpu(pneg_rsp->Capabilities) | SMB2_NT_FIND | 139038c8a9a5SSteve French SMB2_LARGE_FILES) != server->capabilities) 139138c8a9a5SSteve French goto vneg_out; 139238c8a9a5SSteve French 139338c8a9a5SSteve French /* validate negotiate successful */ 139438c8a9a5SSteve French rc = 0; 139538c8a9a5SSteve French cifs_dbg(FYI, "validate negotiate info successful\n"); 139638c8a9a5SSteve French goto out_free_rsp; 139738c8a9a5SSteve French 139838c8a9a5SSteve French vneg_out: 139938c8a9a5SSteve French cifs_tcon_dbg(VFS, "protocol revalidation - security settings mismatch\n"); 140038c8a9a5SSteve French out_free_rsp: 140138c8a9a5SSteve French kfree(pneg_rsp); 140238c8a9a5SSteve French out_free_inbuf: 140338c8a9a5SSteve French kfree(pneg_inbuf); 140438c8a9a5SSteve French return rc; 140538c8a9a5SSteve French } 140638c8a9a5SSteve French 140738c8a9a5SSteve French enum securityEnum 140838c8a9a5SSteve French smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested) 140938c8a9a5SSteve French { 141038c8a9a5SSteve French switch (requested) { 141138c8a9a5SSteve French case Kerberos: 141238c8a9a5SSteve French case RawNTLMSSP: 141338c8a9a5SSteve French return requested; 141438c8a9a5SSteve French case NTLMv2: 141538c8a9a5SSteve French return RawNTLMSSP; 141638c8a9a5SSteve French case Unspecified: 141738c8a9a5SSteve French if (server->sec_ntlmssp && 141838c8a9a5SSteve French (global_secflags & CIFSSEC_MAY_NTLMSSP)) 141938c8a9a5SSteve French return RawNTLMSSP; 142038c8a9a5SSteve French if ((server->sec_kerberos || server->sec_mskerberos) && 142138c8a9a5SSteve French (global_secflags & CIFSSEC_MAY_KRB5)) 142238c8a9a5SSteve French return Kerberos; 142338c8a9a5SSteve French fallthrough; 142438c8a9a5SSteve French default: 142538c8a9a5SSteve French return Unspecified; 142638c8a9a5SSteve French } 142738c8a9a5SSteve French } 142838c8a9a5SSteve French 142938c8a9a5SSteve French struct SMB2_sess_data { 143038c8a9a5SSteve French unsigned int xid; 143138c8a9a5SSteve French struct cifs_ses *ses; 143238c8a9a5SSteve French struct TCP_Server_Info *server; 143338c8a9a5SSteve French struct nls_table *nls_cp; 143438c8a9a5SSteve French void (*func)(struct SMB2_sess_data *); 143538c8a9a5SSteve French int result; 143638c8a9a5SSteve French u64 previous_session; 143738c8a9a5SSteve French 143838c8a9a5SSteve French /* we will send the SMB in three pieces: 143938c8a9a5SSteve French * a fixed length beginning part, an optional 144038c8a9a5SSteve French * SPNEGO blob (which can be zero length), and a 144138c8a9a5SSteve French * last part which will include the strings 144238c8a9a5SSteve French * and rest of bcc area. This allows us to avoid 144338c8a9a5SSteve French * a large buffer 17K allocation 144438c8a9a5SSteve French */ 144538c8a9a5SSteve French int buf0_type; 144638c8a9a5SSteve French struct kvec iov[2]; 144738c8a9a5SSteve French }; 144838c8a9a5SSteve French 144938c8a9a5SSteve French static int 145038c8a9a5SSteve French SMB2_sess_alloc_buffer(struct SMB2_sess_data *sess_data) 145138c8a9a5SSteve French { 145238c8a9a5SSteve French int rc; 145338c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 145438c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 145538c8a9a5SSteve French struct smb2_sess_setup_req *req; 145638c8a9a5SSteve French unsigned int total_len; 145738c8a9a5SSteve French bool is_binding = false; 145838c8a9a5SSteve French 145938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server, 146038c8a9a5SSteve French (void **) &req, 146138c8a9a5SSteve French &total_len); 146238c8a9a5SSteve French if (rc) 146338c8a9a5SSteve French return rc; 146438c8a9a5SSteve French 146538c8a9a5SSteve French spin_lock(&ses->ses_lock); 146638c8a9a5SSteve French is_binding = (ses->ses_status == SES_GOOD); 146738c8a9a5SSteve French spin_unlock(&ses->ses_lock); 146838c8a9a5SSteve French 146938c8a9a5SSteve French if (is_binding) { 147038c8a9a5SSteve French req->hdr.SessionId = cpu_to_le64(ses->Suid); 147138c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_SIGNED; 147238c8a9a5SSteve French req->PreviousSessionId = 0; 147338c8a9a5SSteve French req->Flags = SMB2_SESSION_REQ_FLAG_BINDING; 147438c8a9a5SSteve French cifs_dbg(FYI, "Binding to sess id: %llx\n", ses->Suid); 147538c8a9a5SSteve French } else { 147638c8a9a5SSteve French /* First session, not a reauthenticate */ 147738c8a9a5SSteve French req->hdr.SessionId = 0; 147838c8a9a5SSteve French /* 147938c8a9a5SSteve French * if reconnect, we need to send previous sess id 148038c8a9a5SSteve French * otherwise it is 0 148138c8a9a5SSteve French */ 148238c8a9a5SSteve French req->PreviousSessionId = cpu_to_le64(sess_data->previous_session); 148338c8a9a5SSteve French req->Flags = 0; /* MBZ */ 148438c8a9a5SSteve French cifs_dbg(FYI, "Fresh session. Previous: %llx\n", 148538c8a9a5SSteve French sess_data->previous_session); 148638c8a9a5SSteve French } 148738c8a9a5SSteve French 148838c8a9a5SSteve French /* enough to enable echos and oplocks and one max size write */ 14895e90aa21SShyam Prasad N if (server->credits >= server->max_credits) 14905e90aa21SShyam Prasad N req->hdr.CreditRequest = cpu_to_le16(0); 14915e90aa21SShyam Prasad N else 14925e90aa21SShyam Prasad N req->hdr.CreditRequest = cpu_to_le16( 14935e90aa21SShyam Prasad N min_t(int, server->max_credits - 14945e90aa21SShyam Prasad N server->credits, 130)); 149538c8a9a5SSteve French 149638c8a9a5SSteve French /* only one of SMB2 signing flags may be set in SMB2 request */ 149738c8a9a5SSteve French if (server->sign) 149838c8a9a5SSteve French req->SecurityMode = SMB2_NEGOTIATE_SIGNING_REQUIRED; 149938c8a9a5SSteve French else if (global_secflags & CIFSSEC_MAY_SIGN) /* one flag unlike MUST_ */ 150038c8a9a5SSteve French req->SecurityMode = SMB2_NEGOTIATE_SIGNING_ENABLED; 150138c8a9a5SSteve French else 150238c8a9a5SSteve French req->SecurityMode = 0; 150338c8a9a5SSteve French 150438c8a9a5SSteve French #ifdef CONFIG_CIFS_DFS_UPCALL 150538c8a9a5SSteve French req->Capabilities = cpu_to_le32(SMB2_GLOBAL_CAP_DFS); 150638c8a9a5SSteve French #else 150738c8a9a5SSteve French req->Capabilities = 0; 150838c8a9a5SSteve French #endif /* DFS_UPCALL */ 150938c8a9a5SSteve French 151038c8a9a5SSteve French req->Channel = 0; /* MBZ */ 151138c8a9a5SSteve French 151238c8a9a5SSteve French sess_data->iov[0].iov_base = (char *)req; 151338c8a9a5SSteve French /* 1 for pad */ 151438c8a9a5SSteve French sess_data->iov[0].iov_len = total_len - 1; 151538c8a9a5SSteve French /* 151638c8a9a5SSteve French * This variable will be used to clear the buffer 151738c8a9a5SSteve French * allocated above in case of any error in the calling function. 151838c8a9a5SSteve French */ 151938c8a9a5SSteve French sess_data->buf0_type = CIFS_SMALL_BUFFER; 152038c8a9a5SSteve French 152138c8a9a5SSteve French return 0; 152238c8a9a5SSteve French } 152338c8a9a5SSteve French 152438c8a9a5SSteve French static void 152538c8a9a5SSteve French SMB2_sess_free_buffer(struct SMB2_sess_data *sess_data) 152638c8a9a5SSteve French { 152738c8a9a5SSteve French struct kvec *iov = sess_data->iov; 152838c8a9a5SSteve French 152938c8a9a5SSteve French /* iov[1] is already freed by caller */ 153038c8a9a5SSteve French if (sess_data->buf0_type != CIFS_NO_BUFFER && iov[0].iov_base) 153138c8a9a5SSteve French memzero_explicit(iov[0].iov_base, iov[0].iov_len); 153238c8a9a5SSteve French 153338c8a9a5SSteve French free_rsp_buf(sess_data->buf0_type, iov[0].iov_base); 153438c8a9a5SSteve French sess_data->buf0_type = CIFS_NO_BUFFER; 153538c8a9a5SSteve French } 153638c8a9a5SSteve French 153738c8a9a5SSteve French static int 153838c8a9a5SSteve French SMB2_sess_sendreceive(struct SMB2_sess_data *sess_data) 153938c8a9a5SSteve French { 154038c8a9a5SSteve French int rc; 154138c8a9a5SSteve French struct smb_rqst rqst; 154238c8a9a5SSteve French struct smb2_sess_setup_req *req = sess_data->iov[0].iov_base; 154338c8a9a5SSteve French struct kvec rsp_iov = { NULL, 0 }; 154438c8a9a5SSteve French 154538c8a9a5SSteve French /* Testing shows that buffer offset must be at location of Buffer[0] */ 154638c8a9a5SSteve French req->SecurityBufferOffset = 154738c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_sess_setup_req)); 154838c8a9a5SSteve French req->SecurityBufferLength = cpu_to_le16(sess_data->iov[1].iov_len); 154938c8a9a5SSteve French 155038c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 155138c8a9a5SSteve French rqst.rq_iov = sess_data->iov; 155238c8a9a5SSteve French rqst.rq_nvec = 2; 155338c8a9a5SSteve French 155438c8a9a5SSteve French /* BB add code to build os and lm fields */ 155538c8a9a5SSteve French rc = cifs_send_recv(sess_data->xid, sess_data->ses, 155638c8a9a5SSteve French sess_data->server, 155738c8a9a5SSteve French &rqst, 155838c8a9a5SSteve French &sess_data->buf0_type, 155938c8a9a5SSteve French CIFS_LOG_ERROR | CIFS_SESS_OP, &rsp_iov); 156038c8a9a5SSteve French cifs_small_buf_release(sess_data->iov[0].iov_base); 15617e8cffa4SSteve French if (rc == 0) 15627e8cffa4SSteve French sess_data->ses->expired_pwd = false; 15637e8cffa4SSteve French else if ((rc == -EACCES) || (rc == -EKEYEXPIRED) || (rc == -EKEYREVOKED)) 15647e8cffa4SSteve French sess_data->ses->expired_pwd = true; 15657e8cffa4SSteve French 156638c8a9a5SSteve French memcpy(&sess_data->iov[0], &rsp_iov, sizeof(struct kvec)); 156738c8a9a5SSteve French 156838c8a9a5SSteve French return rc; 156938c8a9a5SSteve French } 157038c8a9a5SSteve French 157138c8a9a5SSteve French static int 157238c8a9a5SSteve French SMB2_sess_establish_session(struct SMB2_sess_data *sess_data) 157338c8a9a5SSteve French { 157438c8a9a5SSteve French int rc = 0; 157538c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 157638c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 157738c8a9a5SSteve French 157838c8a9a5SSteve French cifs_server_lock(server); 157938c8a9a5SSteve French if (server->ops->generate_signingkey) { 158038c8a9a5SSteve French rc = server->ops->generate_signingkey(ses, server); 158138c8a9a5SSteve French if (rc) { 158238c8a9a5SSteve French cifs_dbg(FYI, 158338c8a9a5SSteve French "SMB3 session key generation failed\n"); 158438c8a9a5SSteve French cifs_server_unlock(server); 158538c8a9a5SSteve French return rc; 158638c8a9a5SSteve French } 158738c8a9a5SSteve French } 158838c8a9a5SSteve French if (!server->session_estab) { 158938c8a9a5SSteve French server->sequence_number = 0x2; 159038c8a9a5SSteve French server->session_estab = true; 159138c8a9a5SSteve French } 159238c8a9a5SSteve French cifs_server_unlock(server); 159338c8a9a5SSteve French 159438c8a9a5SSteve French cifs_dbg(FYI, "SMB2/3 session established successfully\n"); 159538c8a9a5SSteve French return rc; 159638c8a9a5SSteve French } 159738c8a9a5SSteve French 159838c8a9a5SSteve French #ifdef CONFIG_CIFS_UPCALL 159938c8a9a5SSteve French static void 160038c8a9a5SSteve French SMB2_auth_kerberos(struct SMB2_sess_data *sess_data) 160138c8a9a5SSteve French { 160238c8a9a5SSteve French int rc; 160338c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 160438c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 160538c8a9a5SSteve French struct cifs_spnego_msg *msg; 160638c8a9a5SSteve French struct key *spnego_key = NULL; 160738c8a9a5SSteve French struct smb2_sess_setup_rsp *rsp = NULL; 160838c8a9a5SSteve French bool is_binding = false; 160938c8a9a5SSteve French 161038c8a9a5SSteve French rc = SMB2_sess_alloc_buffer(sess_data); 161138c8a9a5SSteve French if (rc) 161238c8a9a5SSteve French goto out; 161338c8a9a5SSteve French 161438c8a9a5SSteve French spnego_key = cifs_get_spnego_key(ses, server); 161538c8a9a5SSteve French if (IS_ERR(spnego_key)) { 161638c8a9a5SSteve French rc = PTR_ERR(spnego_key); 161738c8a9a5SSteve French if (rc == -ENOKEY) 161838c8a9a5SSteve French cifs_dbg(VFS, "Verify user has a krb5 ticket and keyutils is installed\n"); 161938c8a9a5SSteve French spnego_key = NULL; 162038c8a9a5SSteve French goto out; 162138c8a9a5SSteve French } 162238c8a9a5SSteve French 162338c8a9a5SSteve French msg = spnego_key->payload.data[0]; 162438c8a9a5SSteve French /* 162538c8a9a5SSteve French * check version field to make sure that cifs.upcall is 162638c8a9a5SSteve French * sending us a response in an expected form 162738c8a9a5SSteve French */ 162838c8a9a5SSteve French if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) { 162938c8a9a5SSteve French cifs_dbg(VFS, "bad cifs.upcall version. Expected %d got %d\n", 163038c8a9a5SSteve French CIFS_SPNEGO_UPCALL_VERSION, msg->version); 163138c8a9a5SSteve French rc = -EKEYREJECTED; 163238c8a9a5SSteve French goto out_put_spnego_key; 163338c8a9a5SSteve French } 163438c8a9a5SSteve French 163538c8a9a5SSteve French spin_lock(&ses->ses_lock); 163638c8a9a5SSteve French is_binding = (ses->ses_status == SES_GOOD); 163738c8a9a5SSteve French spin_unlock(&ses->ses_lock); 163838c8a9a5SSteve French 163938c8a9a5SSteve French /* keep session key if binding */ 164038c8a9a5SSteve French if (!is_binding) { 164138c8a9a5SSteve French kfree_sensitive(ses->auth_key.response); 164238c8a9a5SSteve French ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len, 164338c8a9a5SSteve French GFP_KERNEL); 164438c8a9a5SSteve French if (!ses->auth_key.response) { 164538c8a9a5SSteve French cifs_dbg(VFS, "Kerberos can't allocate (%u bytes) memory\n", 164638c8a9a5SSteve French msg->sesskey_len); 164738c8a9a5SSteve French rc = -ENOMEM; 164838c8a9a5SSteve French goto out_put_spnego_key; 164938c8a9a5SSteve French } 165038c8a9a5SSteve French ses->auth_key.len = msg->sesskey_len; 165138c8a9a5SSteve French } 165238c8a9a5SSteve French 165338c8a9a5SSteve French sess_data->iov[1].iov_base = msg->data + msg->sesskey_len; 165438c8a9a5SSteve French sess_data->iov[1].iov_len = msg->secblob_len; 165538c8a9a5SSteve French 165638c8a9a5SSteve French rc = SMB2_sess_sendreceive(sess_data); 165738c8a9a5SSteve French if (rc) 165838c8a9a5SSteve French goto out_put_spnego_key; 165938c8a9a5SSteve French 166038c8a9a5SSteve French rsp = (struct smb2_sess_setup_rsp *)sess_data->iov[0].iov_base; 166138c8a9a5SSteve French /* keep session id and flags if binding */ 166238c8a9a5SSteve French if (!is_binding) { 166338c8a9a5SSteve French ses->Suid = le64_to_cpu(rsp->hdr.SessionId); 166438c8a9a5SSteve French ses->session_flags = le16_to_cpu(rsp->SessionFlags); 166538c8a9a5SSteve French } 166638c8a9a5SSteve French 166738c8a9a5SSteve French rc = SMB2_sess_establish_session(sess_data); 166838c8a9a5SSteve French out_put_spnego_key: 166938c8a9a5SSteve French key_invalidate(spnego_key); 167038c8a9a5SSteve French key_put(spnego_key); 167138c8a9a5SSteve French if (rc) { 167238c8a9a5SSteve French kfree_sensitive(ses->auth_key.response); 167338c8a9a5SSteve French ses->auth_key.response = NULL; 167438c8a9a5SSteve French ses->auth_key.len = 0; 167538c8a9a5SSteve French } 167638c8a9a5SSteve French out: 167738c8a9a5SSteve French sess_data->result = rc; 167838c8a9a5SSteve French sess_data->func = NULL; 167938c8a9a5SSteve French SMB2_sess_free_buffer(sess_data); 168038c8a9a5SSteve French } 168138c8a9a5SSteve French #else 168238c8a9a5SSteve French static void 168338c8a9a5SSteve French SMB2_auth_kerberos(struct SMB2_sess_data *sess_data) 168438c8a9a5SSteve French { 168538c8a9a5SSteve French cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n"); 168638c8a9a5SSteve French sess_data->result = -EOPNOTSUPP; 168738c8a9a5SSteve French sess_data->func = NULL; 168838c8a9a5SSteve French } 168938c8a9a5SSteve French #endif 169038c8a9a5SSteve French 169138c8a9a5SSteve French static void 169238c8a9a5SSteve French SMB2_sess_auth_rawntlmssp_authenticate(struct SMB2_sess_data *sess_data); 169338c8a9a5SSteve French 169438c8a9a5SSteve French static void 169538c8a9a5SSteve French SMB2_sess_auth_rawntlmssp_negotiate(struct SMB2_sess_data *sess_data) 169638c8a9a5SSteve French { 169738c8a9a5SSteve French int rc; 169838c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 169938c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 170038c8a9a5SSteve French struct smb2_sess_setup_rsp *rsp = NULL; 170138c8a9a5SSteve French unsigned char *ntlmssp_blob = NULL; 170238c8a9a5SSteve French bool use_spnego = false; /* else use raw ntlmssp */ 170338c8a9a5SSteve French u16 blob_length = 0; 170438c8a9a5SSteve French bool is_binding = false; 170538c8a9a5SSteve French 170638c8a9a5SSteve French /* 170738c8a9a5SSteve French * If memory allocation is successful, caller of this function 170838c8a9a5SSteve French * frees it. 170938c8a9a5SSteve French */ 171038c8a9a5SSteve French ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL); 171138c8a9a5SSteve French if (!ses->ntlmssp) { 171238c8a9a5SSteve French rc = -ENOMEM; 171338c8a9a5SSteve French goto out_err; 171438c8a9a5SSteve French } 171538c8a9a5SSteve French ses->ntlmssp->sesskey_per_smbsess = true; 171638c8a9a5SSteve French 171738c8a9a5SSteve French rc = SMB2_sess_alloc_buffer(sess_data); 171838c8a9a5SSteve French if (rc) 171938c8a9a5SSteve French goto out_err; 172038c8a9a5SSteve French 172138c8a9a5SSteve French rc = build_ntlmssp_smb3_negotiate_blob(&ntlmssp_blob, 172238c8a9a5SSteve French &blob_length, ses, server, 172338c8a9a5SSteve French sess_data->nls_cp); 172438c8a9a5SSteve French if (rc) 172538c8a9a5SSteve French goto out; 172638c8a9a5SSteve French 172738c8a9a5SSteve French if (use_spnego) { 172838c8a9a5SSteve French /* BB eventually need to add this */ 172938c8a9a5SSteve French cifs_dbg(VFS, "spnego not supported for SMB2 yet\n"); 173038c8a9a5SSteve French rc = -EOPNOTSUPP; 173138c8a9a5SSteve French goto out; 173238c8a9a5SSteve French } 173338c8a9a5SSteve French sess_data->iov[1].iov_base = ntlmssp_blob; 173438c8a9a5SSteve French sess_data->iov[1].iov_len = blob_length; 173538c8a9a5SSteve French 173638c8a9a5SSteve French rc = SMB2_sess_sendreceive(sess_data); 173738c8a9a5SSteve French rsp = (struct smb2_sess_setup_rsp *)sess_data->iov[0].iov_base; 173838c8a9a5SSteve French 173938c8a9a5SSteve French /* If true, rc here is expected and not an error */ 174038c8a9a5SSteve French if (sess_data->buf0_type != CIFS_NO_BUFFER && 174138c8a9a5SSteve French rsp->hdr.Status == STATUS_MORE_PROCESSING_REQUIRED) 174238c8a9a5SSteve French rc = 0; 174338c8a9a5SSteve French 174438c8a9a5SSteve French if (rc) 174538c8a9a5SSteve French goto out; 174638c8a9a5SSteve French 174738c8a9a5SSteve French if (offsetof(struct smb2_sess_setup_rsp, Buffer) != 174838c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferOffset)) { 174938c8a9a5SSteve French cifs_dbg(VFS, "Invalid security buffer offset %d\n", 175038c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferOffset)); 175138c8a9a5SSteve French rc = -EIO; 175238c8a9a5SSteve French goto out; 175338c8a9a5SSteve French } 175438c8a9a5SSteve French rc = decode_ntlmssp_challenge(rsp->Buffer, 175538c8a9a5SSteve French le16_to_cpu(rsp->SecurityBufferLength), ses); 175638c8a9a5SSteve French if (rc) 175738c8a9a5SSteve French goto out; 175838c8a9a5SSteve French 175938c8a9a5SSteve French cifs_dbg(FYI, "rawntlmssp session setup challenge phase\n"); 176038c8a9a5SSteve French 176138c8a9a5SSteve French spin_lock(&ses->ses_lock); 176238c8a9a5SSteve French is_binding = (ses->ses_status == SES_GOOD); 176338c8a9a5SSteve French spin_unlock(&ses->ses_lock); 176438c8a9a5SSteve French 176538c8a9a5SSteve French /* keep existing ses id and flags if binding */ 176638c8a9a5SSteve French if (!is_binding) { 176738c8a9a5SSteve French ses->Suid = le64_to_cpu(rsp->hdr.SessionId); 176838c8a9a5SSteve French ses->session_flags = le16_to_cpu(rsp->SessionFlags); 176938c8a9a5SSteve French } 177038c8a9a5SSteve French 177138c8a9a5SSteve French out: 177238c8a9a5SSteve French kfree_sensitive(ntlmssp_blob); 177338c8a9a5SSteve French SMB2_sess_free_buffer(sess_data); 177438c8a9a5SSteve French if (!rc) { 177538c8a9a5SSteve French sess_data->result = 0; 177638c8a9a5SSteve French sess_data->func = SMB2_sess_auth_rawntlmssp_authenticate; 177738c8a9a5SSteve French return; 177838c8a9a5SSteve French } 177938c8a9a5SSteve French out_err: 178038c8a9a5SSteve French kfree_sensitive(ses->ntlmssp); 178138c8a9a5SSteve French ses->ntlmssp = NULL; 178238c8a9a5SSteve French sess_data->result = rc; 178338c8a9a5SSteve French sess_data->func = NULL; 178438c8a9a5SSteve French } 178538c8a9a5SSteve French 178638c8a9a5SSteve French static void 178738c8a9a5SSteve French SMB2_sess_auth_rawntlmssp_authenticate(struct SMB2_sess_data *sess_data) 178838c8a9a5SSteve French { 178938c8a9a5SSteve French int rc; 179038c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 179138c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 179238c8a9a5SSteve French struct smb2_sess_setup_req *req; 179338c8a9a5SSteve French struct smb2_sess_setup_rsp *rsp = NULL; 179438c8a9a5SSteve French unsigned char *ntlmssp_blob = NULL; 179538c8a9a5SSteve French bool use_spnego = false; /* else use raw ntlmssp */ 179638c8a9a5SSteve French u16 blob_length = 0; 179738c8a9a5SSteve French bool is_binding = false; 179838c8a9a5SSteve French 179938c8a9a5SSteve French rc = SMB2_sess_alloc_buffer(sess_data); 180038c8a9a5SSteve French if (rc) 180138c8a9a5SSteve French goto out; 180238c8a9a5SSteve French 180338c8a9a5SSteve French req = (struct smb2_sess_setup_req *) sess_data->iov[0].iov_base; 180438c8a9a5SSteve French req->hdr.SessionId = cpu_to_le64(ses->Suid); 180538c8a9a5SSteve French 180638c8a9a5SSteve French rc = build_ntlmssp_auth_blob(&ntlmssp_blob, &blob_length, 180738c8a9a5SSteve French ses, server, 180838c8a9a5SSteve French sess_data->nls_cp); 180938c8a9a5SSteve French if (rc) { 181038c8a9a5SSteve French cifs_dbg(FYI, "build_ntlmssp_auth_blob failed %d\n", rc); 181138c8a9a5SSteve French goto out; 181238c8a9a5SSteve French } 181338c8a9a5SSteve French 181438c8a9a5SSteve French if (use_spnego) { 181538c8a9a5SSteve French /* BB eventually need to add this */ 181638c8a9a5SSteve French cifs_dbg(VFS, "spnego not supported for SMB2 yet\n"); 181738c8a9a5SSteve French rc = -EOPNOTSUPP; 181838c8a9a5SSteve French goto out; 181938c8a9a5SSteve French } 182038c8a9a5SSteve French sess_data->iov[1].iov_base = ntlmssp_blob; 182138c8a9a5SSteve French sess_data->iov[1].iov_len = blob_length; 182238c8a9a5SSteve French 182338c8a9a5SSteve French rc = SMB2_sess_sendreceive(sess_data); 182438c8a9a5SSteve French if (rc) 182538c8a9a5SSteve French goto out; 182638c8a9a5SSteve French 182738c8a9a5SSteve French rsp = (struct smb2_sess_setup_rsp *)sess_data->iov[0].iov_base; 182838c8a9a5SSteve French 182938c8a9a5SSteve French spin_lock(&ses->ses_lock); 183038c8a9a5SSteve French is_binding = (ses->ses_status == SES_GOOD); 183138c8a9a5SSteve French spin_unlock(&ses->ses_lock); 183238c8a9a5SSteve French 183338c8a9a5SSteve French /* keep existing ses id and flags if binding */ 183438c8a9a5SSteve French if (!is_binding) { 183538c8a9a5SSteve French ses->Suid = le64_to_cpu(rsp->hdr.SessionId); 183638c8a9a5SSteve French ses->session_flags = le16_to_cpu(rsp->SessionFlags); 183738c8a9a5SSteve French } 183838c8a9a5SSteve French 183938c8a9a5SSteve French rc = SMB2_sess_establish_session(sess_data); 184038c8a9a5SSteve French #ifdef CONFIG_CIFS_DEBUG_DUMP_KEYS 184138c8a9a5SSteve French if (ses->server->dialect < SMB30_PROT_ID) { 184238c8a9a5SSteve French cifs_dbg(VFS, "%s: dumping generated SMB2 session keys\n", __func__); 184338c8a9a5SSteve French /* 184438c8a9a5SSteve French * The session id is opaque in terms of endianness, so we can't 184538c8a9a5SSteve French * print it as a long long. we dump it as we got it on the wire 184638c8a9a5SSteve French */ 184738c8a9a5SSteve French cifs_dbg(VFS, "Session Id %*ph\n", (int)sizeof(ses->Suid), 184838c8a9a5SSteve French &ses->Suid); 184938c8a9a5SSteve French cifs_dbg(VFS, "Session Key %*ph\n", 185038c8a9a5SSteve French SMB2_NTLMV2_SESSKEY_SIZE, ses->auth_key.response); 185138c8a9a5SSteve French cifs_dbg(VFS, "Signing Key %*ph\n", 185238c8a9a5SSteve French SMB3_SIGN_KEY_SIZE, ses->auth_key.response); 185338c8a9a5SSteve French } 185438c8a9a5SSteve French #endif 185538c8a9a5SSteve French out: 185638c8a9a5SSteve French kfree_sensitive(ntlmssp_blob); 185738c8a9a5SSteve French SMB2_sess_free_buffer(sess_data); 185838c8a9a5SSteve French kfree_sensitive(ses->ntlmssp); 185938c8a9a5SSteve French ses->ntlmssp = NULL; 186038c8a9a5SSteve French sess_data->result = rc; 186138c8a9a5SSteve French sess_data->func = NULL; 186238c8a9a5SSteve French } 186338c8a9a5SSteve French 186438c8a9a5SSteve French static int 186538c8a9a5SSteve French SMB2_select_sec(struct SMB2_sess_data *sess_data) 186638c8a9a5SSteve French { 186738c8a9a5SSteve French int type; 186838c8a9a5SSteve French struct cifs_ses *ses = sess_data->ses; 186938c8a9a5SSteve French struct TCP_Server_Info *server = sess_data->server; 187038c8a9a5SSteve French 187138c8a9a5SSteve French type = smb2_select_sectype(server, ses->sectype); 187238c8a9a5SSteve French cifs_dbg(FYI, "sess setup type %d\n", type); 187338c8a9a5SSteve French if (type == Unspecified) { 187438c8a9a5SSteve French cifs_dbg(VFS, "Unable to select appropriate authentication method!\n"); 187538c8a9a5SSteve French return -EINVAL; 187638c8a9a5SSteve French } 187738c8a9a5SSteve French 187838c8a9a5SSteve French switch (type) { 187938c8a9a5SSteve French case Kerberos: 188038c8a9a5SSteve French sess_data->func = SMB2_auth_kerberos; 188138c8a9a5SSteve French break; 188238c8a9a5SSteve French case RawNTLMSSP: 188338c8a9a5SSteve French sess_data->func = SMB2_sess_auth_rawntlmssp_negotiate; 188438c8a9a5SSteve French break; 188538c8a9a5SSteve French default: 188638c8a9a5SSteve French cifs_dbg(VFS, "secType %d not supported!\n", type); 188738c8a9a5SSteve French return -EOPNOTSUPP; 188838c8a9a5SSteve French } 188938c8a9a5SSteve French 189038c8a9a5SSteve French return 0; 189138c8a9a5SSteve French } 189238c8a9a5SSteve French 189338c8a9a5SSteve French int 189438c8a9a5SSteve French SMB2_sess_setup(const unsigned int xid, struct cifs_ses *ses, 189538c8a9a5SSteve French struct TCP_Server_Info *server, 189638c8a9a5SSteve French const struct nls_table *nls_cp) 189738c8a9a5SSteve French { 189838c8a9a5SSteve French int rc = 0; 189938c8a9a5SSteve French struct SMB2_sess_data *sess_data; 190038c8a9a5SSteve French 190138c8a9a5SSteve French cifs_dbg(FYI, "Session Setup\n"); 190238c8a9a5SSteve French 190338c8a9a5SSteve French if (!server) { 190438c8a9a5SSteve French WARN(1, "%s: server is NULL!\n", __func__); 190538c8a9a5SSteve French return -EIO; 190638c8a9a5SSteve French } 190738c8a9a5SSteve French 190838c8a9a5SSteve French sess_data = kzalloc(sizeof(struct SMB2_sess_data), GFP_KERNEL); 190938c8a9a5SSteve French if (!sess_data) 191038c8a9a5SSteve French return -ENOMEM; 191138c8a9a5SSteve French 191238c8a9a5SSteve French sess_data->xid = xid; 191338c8a9a5SSteve French sess_data->ses = ses; 191438c8a9a5SSteve French sess_data->server = server; 191538c8a9a5SSteve French sess_data->buf0_type = CIFS_NO_BUFFER; 191638c8a9a5SSteve French sess_data->nls_cp = (struct nls_table *) nls_cp; 191738c8a9a5SSteve French sess_data->previous_session = ses->Suid; 191838c8a9a5SSteve French 191938c8a9a5SSteve French rc = SMB2_select_sec(sess_data); 192038c8a9a5SSteve French if (rc) 192138c8a9a5SSteve French goto out; 192238c8a9a5SSteve French 192338c8a9a5SSteve French /* 192438c8a9a5SSteve French * Initialize the session hash with the server one. 192538c8a9a5SSteve French */ 192638c8a9a5SSteve French memcpy(ses->preauth_sha_hash, server->preauth_sha_hash, 192738c8a9a5SSteve French SMB2_PREAUTH_HASH_SIZE); 192838c8a9a5SSteve French 192938c8a9a5SSteve French while (sess_data->func) 193038c8a9a5SSteve French sess_data->func(sess_data); 193138c8a9a5SSteve French 193238c8a9a5SSteve French if ((ses->session_flags & SMB2_SESSION_FLAG_IS_GUEST) && (ses->sign)) 193338c8a9a5SSteve French cifs_server_dbg(VFS, "signing requested but authenticated as guest\n"); 193438c8a9a5SSteve French rc = sess_data->result; 193538c8a9a5SSteve French out: 193638c8a9a5SSteve French kfree_sensitive(sess_data); 193738c8a9a5SSteve French return rc; 193838c8a9a5SSteve French } 193938c8a9a5SSteve French 194038c8a9a5SSteve French int 194138c8a9a5SSteve French SMB2_logoff(const unsigned int xid, struct cifs_ses *ses) 194238c8a9a5SSteve French { 194338c8a9a5SSteve French struct smb_rqst rqst; 194438c8a9a5SSteve French struct smb2_logoff_req *req; /* response is also trivial struct */ 194538c8a9a5SSteve French int rc = 0; 194638c8a9a5SSteve French struct TCP_Server_Info *server; 194738c8a9a5SSteve French int flags = 0; 194838c8a9a5SSteve French unsigned int total_len; 194938c8a9a5SSteve French struct kvec iov[1]; 195038c8a9a5SSteve French struct kvec rsp_iov; 195138c8a9a5SSteve French int resp_buf_type; 195238c8a9a5SSteve French 195338c8a9a5SSteve French cifs_dbg(FYI, "disconnect session %p\n", ses); 195438c8a9a5SSteve French 195538c8a9a5SSteve French if (ses && (ses->server)) 195638c8a9a5SSteve French server = ses->server; 195738c8a9a5SSteve French else 195838c8a9a5SSteve French return -EIO; 195938c8a9a5SSteve French 196038c8a9a5SSteve French /* no need to send SMB logoff if uid already closed due to reconnect */ 196138c8a9a5SSteve French spin_lock(&ses->chan_lock); 196238c8a9a5SSteve French if (CIFS_ALL_CHANS_NEED_RECONNECT(ses)) { 196338c8a9a5SSteve French spin_unlock(&ses->chan_lock); 196438c8a9a5SSteve French goto smb2_session_already_dead; 196538c8a9a5SSteve French } 196638c8a9a5SSteve French spin_unlock(&ses->chan_lock); 196738c8a9a5SSteve French 196838c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server, 196938c8a9a5SSteve French (void **) &req, &total_len); 197038c8a9a5SSteve French if (rc) 197138c8a9a5SSteve French return rc; 197238c8a9a5SSteve French 197338c8a9a5SSteve French /* since no tcon, smb2_init can not do this, so do here */ 197438c8a9a5SSteve French req->hdr.SessionId = cpu_to_le64(ses->Suid); 197538c8a9a5SSteve French 197638c8a9a5SSteve French if (ses->session_flags & SMB2_SESSION_FLAG_ENCRYPT_DATA) 197738c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 197838c8a9a5SSteve French else if (server->sign) 197938c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_SIGNED; 198038c8a9a5SSteve French 198138c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF; 198238c8a9a5SSteve French 198338c8a9a5SSteve French iov[0].iov_base = (char *)req; 198438c8a9a5SSteve French iov[0].iov_len = total_len; 198538c8a9a5SSteve French 198638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 198738c8a9a5SSteve French rqst.rq_iov = iov; 198838c8a9a5SSteve French rqst.rq_nvec = 1; 198938c8a9a5SSteve French 199038c8a9a5SSteve French rc = cifs_send_recv(xid, ses, ses->server, 199138c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov); 199238c8a9a5SSteve French cifs_small_buf_release(req); 199338c8a9a5SSteve French /* 199438c8a9a5SSteve French * No tcon so can't do 199538c8a9a5SSteve French * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]); 199638c8a9a5SSteve French */ 199738c8a9a5SSteve French 199838c8a9a5SSteve French smb2_session_already_dead: 199938c8a9a5SSteve French return rc; 200038c8a9a5SSteve French } 200138c8a9a5SSteve French 200238c8a9a5SSteve French static inline void cifs_stats_fail_inc(struct cifs_tcon *tcon, uint16_t code) 200338c8a9a5SSteve French { 200438c8a9a5SSteve French cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_failed[code]); 200538c8a9a5SSteve French } 200638c8a9a5SSteve French 200738c8a9a5SSteve French #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */) 200838c8a9a5SSteve French 200938c8a9a5SSteve French /* These are similar values to what Windows uses */ 201038c8a9a5SSteve French static inline void init_copy_chunk_defaults(struct cifs_tcon *tcon) 201138c8a9a5SSteve French { 201238c8a9a5SSteve French tcon->max_chunks = 256; 201338c8a9a5SSteve French tcon->max_bytes_chunk = 1048576; 201438c8a9a5SSteve French tcon->max_bytes_copy = 16777216; 201538c8a9a5SSteve French } 201638c8a9a5SSteve French 201738c8a9a5SSteve French int 201838c8a9a5SSteve French SMB2_tcon(const unsigned int xid, struct cifs_ses *ses, const char *tree, 201938c8a9a5SSteve French struct cifs_tcon *tcon, const struct nls_table *cp) 202038c8a9a5SSteve French { 202138c8a9a5SSteve French struct smb_rqst rqst; 202238c8a9a5SSteve French struct smb2_tree_connect_req *req; 202338c8a9a5SSteve French struct smb2_tree_connect_rsp *rsp = NULL; 202438c8a9a5SSteve French struct kvec iov[2]; 202538c8a9a5SSteve French struct kvec rsp_iov = { NULL, 0 }; 202638c8a9a5SSteve French int rc = 0; 202738c8a9a5SSteve French int resp_buftype; 202838c8a9a5SSteve French int unc_path_len; 202938c8a9a5SSteve French __le16 *unc_path = NULL; 203038c8a9a5SSteve French int flags = 0; 203138c8a9a5SSteve French unsigned int total_len; 2032b96ea433SShyam Prasad N struct TCP_Server_Info *server = cifs_pick_channel(ses); 203338c8a9a5SSteve French 203438c8a9a5SSteve French cifs_dbg(FYI, "TCON\n"); 203538c8a9a5SSteve French 203638c8a9a5SSteve French if (!server || !tree) 203738c8a9a5SSteve French return -EIO; 203838c8a9a5SSteve French 203938c8a9a5SSteve French unc_path = kmalloc(MAX_SHARENAME_LENGTH * 2, GFP_KERNEL); 204038c8a9a5SSteve French if (unc_path == NULL) 204138c8a9a5SSteve French return -ENOMEM; 204238c8a9a5SSteve French 204338c8a9a5SSteve French unc_path_len = cifs_strtoUTF16(unc_path, tree, strlen(tree), cp); 204438c8a9a5SSteve French if (unc_path_len <= 0) { 204538c8a9a5SSteve French kfree(unc_path); 204638c8a9a5SSteve French return -EINVAL; 204738c8a9a5SSteve French } 204838c8a9a5SSteve French unc_path_len *= 2; 204938c8a9a5SSteve French 205038c8a9a5SSteve French /* SMB2 TREE_CONNECT request must be called with TreeId == 0 */ 205138c8a9a5SSteve French tcon->tid = 0; 205238c8a9a5SSteve French atomic_set(&tcon->num_remote_opens, 0); 205338c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server, 205438c8a9a5SSteve French (void **) &req, &total_len); 205538c8a9a5SSteve French if (rc) { 205638c8a9a5SSteve French kfree(unc_path); 205738c8a9a5SSteve French return rc; 205838c8a9a5SSteve French } 205938c8a9a5SSteve French 206038c8a9a5SSteve French if (smb3_encryption_required(tcon)) 206138c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 206238c8a9a5SSteve French 206338c8a9a5SSteve French iov[0].iov_base = (char *)req; 206438c8a9a5SSteve French /* 1 for pad */ 206538c8a9a5SSteve French iov[0].iov_len = total_len - 1; 206638c8a9a5SSteve French 206738c8a9a5SSteve French /* Testing shows that buffer offset must be at location of Buffer[0] */ 206838c8a9a5SSteve French req->PathOffset = cpu_to_le16(sizeof(struct smb2_tree_connect_req)); 206938c8a9a5SSteve French req->PathLength = cpu_to_le16(unc_path_len); 207038c8a9a5SSteve French iov[1].iov_base = unc_path; 207138c8a9a5SSteve French iov[1].iov_len = unc_path_len; 207238c8a9a5SSteve French 207338c8a9a5SSteve French /* 207438c8a9a5SSteve French * 3.11 tcon req must be signed if not encrypted. See MS-SMB2 3.2.4.1.1 207538c8a9a5SSteve French * unless it is guest or anonymous user. See MS-SMB2 3.2.5.3.1 207638c8a9a5SSteve French * (Samba servers don't always set the flag so also check if null user) 207738c8a9a5SSteve French */ 207838c8a9a5SSteve French if ((server->dialect == SMB311_PROT_ID) && 207938c8a9a5SSteve French !smb3_encryption_required(tcon) && 208038c8a9a5SSteve French !(ses->session_flags & 208138c8a9a5SSteve French (SMB2_SESSION_FLAG_IS_GUEST|SMB2_SESSION_FLAG_IS_NULL)) && 208238c8a9a5SSteve French ((ses->user_name != NULL) || (ses->sectype == Kerberos))) 208338c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_SIGNED; 208438c8a9a5SSteve French 208538c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 208638c8a9a5SSteve French rqst.rq_iov = iov; 208738c8a9a5SSteve French rqst.rq_nvec = 2; 208838c8a9a5SSteve French 208938c8a9a5SSteve French /* Need 64 for max size write so ask for more in case not there yet */ 20905e90aa21SShyam Prasad N if (server->credits >= server->max_credits) 20915e90aa21SShyam Prasad N req->hdr.CreditRequest = cpu_to_le16(0); 20925e90aa21SShyam Prasad N else 20935e90aa21SShyam Prasad N req->hdr.CreditRequest = cpu_to_le16( 20945e90aa21SShyam Prasad N min_t(int, server->max_credits - 20955e90aa21SShyam Prasad N server->credits, 64)); 209638c8a9a5SSteve French 209738c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 209838c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 209938c8a9a5SSteve French cifs_small_buf_release(req); 210038c8a9a5SSteve French rsp = (struct smb2_tree_connect_rsp *)rsp_iov.iov_base; 210138c8a9a5SSteve French trace_smb3_tcon(xid, tcon->tid, ses->Suid, tree, rc); 210238c8a9a5SSteve French if ((rc != 0) || (rsp == NULL)) { 210338c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_TREE_CONNECT_HE); 210438c8a9a5SSteve French tcon->need_reconnect = true; 210538c8a9a5SSteve French goto tcon_error_exit; 210638c8a9a5SSteve French } 210738c8a9a5SSteve French 210838c8a9a5SSteve French switch (rsp->ShareType) { 210938c8a9a5SSteve French case SMB2_SHARE_TYPE_DISK: 211038c8a9a5SSteve French cifs_dbg(FYI, "connection to disk share\n"); 211138c8a9a5SSteve French break; 211238c8a9a5SSteve French case SMB2_SHARE_TYPE_PIPE: 211338c8a9a5SSteve French tcon->pipe = true; 211438c8a9a5SSteve French cifs_dbg(FYI, "connection to pipe share\n"); 211538c8a9a5SSteve French break; 211638c8a9a5SSteve French case SMB2_SHARE_TYPE_PRINT: 211738c8a9a5SSteve French tcon->print = true; 211838c8a9a5SSteve French cifs_dbg(FYI, "connection to printer\n"); 211938c8a9a5SSteve French break; 212038c8a9a5SSteve French default: 212138c8a9a5SSteve French cifs_server_dbg(VFS, "unknown share type %d\n", rsp->ShareType); 212238c8a9a5SSteve French rc = -EOPNOTSUPP; 212338c8a9a5SSteve French goto tcon_error_exit; 212438c8a9a5SSteve French } 212538c8a9a5SSteve French 212638c8a9a5SSteve French tcon->share_flags = le32_to_cpu(rsp->ShareFlags); 212738c8a9a5SSteve French tcon->capabilities = rsp->Capabilities; /* we keep caps little endian */ 212838c8a9a5SSteve French tcon->maximal_access = le32_to_cpu(rsp->MaximalAccess); 212938c8a9a5SSteve French tcon->tid = le32_to_cpu(rsp->hdr.Id.SyncId.TreeId); 213038c8a9a5SSteve French strscpy(tcon->tree_name, tree, sizeof(tcon->tree_name)); 213138c8a9a5SSteve French 213238c8a9a5SSteve French if ((rsp->Capabilities & SMB2_SHARE_CAP_DFS) && 213338c8a9a5SSteve French ((tcon->share_flags & SHI1005_FLAGS_DFS) == 0)) 213438c8a9a5SSteve French cifs_tcon_dbg(VFS, "DFS capability contradicts DFS flag\n"); 213538c8a9a5SSteve French 213638c8a9a5SSteve French if (tcon->seal && 213738c8a9a5SSteve French !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)) 213838c8a9a5SSteve French cifs_tcon_dbg(VFS, "Encryption is requested but not supported\n"); 213938c8a9a5SSteve French 214038c8a9a5SSteve French init_copy_chunk_defaults(tcon); 214138c8a9a5SSteve French if (server->ops->validate_negotiate) 214238c8a9a5SSteve French rc = server->ops->validate_negotiate(xid, tcon); 214338c8a9a5SSteve French if (rc == 0) /* See MS-SMB2 2.2.10 and 3.2.5.5 */ 214438c8a9a5SSteve French if (tcon->share_flags & SMB2_SHAREFLAG_ISOLATED_TRANSPORT) 214538c8a9a5SSteve French server->nosharesock = true; 214638c8a9a5SSteve French tcon_exit: 214738c8a9a5SSteve French 214838c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 214938c8a9a5SSteve French kfree(unc_path); 215038c8a9a5SSteve French return rc; 215138c8a9a5SSteve French 215238c8a9a5SSteve French tcon_error_exit: 215338c8a9a5SSteve French if (rsp && rsp->hdr.Status == STATUS_BAD_NETWORK_NAME) 215438c8a9a5SSteve French cifs_tcon_dbg(VFS, "BAD_NETWORK_NAME: %s\n", tree); 215538c8a9a5SSteve French goto tcon_exit; 215638c8a9a5SSteve French } 215738c8a9a5SSteve French 215838c8a9a5SSteve French int 215938c8a9a5SSteve French SMB2_tdis(const unsigned int xid, struct cifs_tcon *tcon) 216038c8a9a5SSteve French { 216138c8a9a5SSteve French struct smb_rqst rqst; 216238c8a9a5SSteve French struct smb2_tree_disconnect_req *req; /* response is trivial */ 216338c8a9a5SSteve French int rc = 0; 216438c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 2165b96ea433SShyam Prasad N struct TCP_Server_Info *server = cifs_pick_channel(ses); 216638c8a9a5SSteve French int flags = 0; 216738c8a9a5SSteve French unsigned int total_len; 216838c8a9a5SSteve French struct kvec iov[1]; 216938c8a9a5SSteve French struct kvec rsp_iov; 217038c8a9a5SSteve French int resp_buf_type; 217138c8a9a5SSteve French 217238c8a9a5SSteve French cifs_dbg(FYI, "Tree Disconnect\n"); 217338c8a9a5SSteve French 217438c8a9a5SSteve French if (!ses || !(ses->server)) 217538c8a9a5SSteve French return -EIO; 217638c8a9a5SSteve French 217738c8a9a5SSteve French trace_smb3_tdis_enter(xid, tcon->tid, ses->Suid, tcon->tree_name); 217838c8a9a5SSteve French spin_lock(&ses->chan_lock); 217938c8a9a5SSteve French if ((tcon->need_reconnect) || 218038c8a9a5SSteve French (CIFS_ALL_CHANS_NEED_RECONNECT(tcon->ses))) { 218138c8a9a5SSteve French spin_unlock(&ses->chan_lock); 218238c8a9a5SSteve French return 0; 218338c8a9a5SSteve French } 218438c8a9a5SSteve French spin_unlock(&ses->chan_lock); 218538c8a9a5SSteve French 218638c8a9a5SSteve French invalidate_all_cached_dirs(tcon); 218738c8a9a5SSteve French 2188b96ea433SShyam Prasad N rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, server, 218938c8a9a5SSteve French (void **) &req, 219038c8a9a5SSteve French &total_len); 219138c8a9a5SSteve French if (rc) 219238c8a9a5SSteve French return rc; 219338c8a9a5SSteve French 219438c8a9a5SSteve French if (smb3_encryption_required(tcon)) 219538c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 219638c8a9a5SSteve French 219738c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF; 219838c8a9a5SSteve French 219938c8a9a5SSteve French iov[0].iov_base = (char *)req; 220038c8a9a5SSteve French iov[0].iov_len = total_len; 220138c8a9a5SSteve French 220238c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 220338c8a9a5SSteve French rqst.rq_iov = iov; 220438c8a9a5SSteve French rqst.rq_nvec = 1; 220538c8a9a5SSteve French 2206b96ea433SShyam Prasad N rc = cifs_send_recv(xid, ses, server, 220738c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov); 220838c8a9a5SSteve French cifs_small_buf_release(req); 220938c8a9a5SSteve French if (rc) { 221038c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_TREE_DISCONNECT_HE); 221138c8a9a5SSteve French trace_smb3_tdis_err(xid, tcon->tid, ses->Suid, rc); 221238c8a9a5SSteve French } 221338c8a9a5SSteve French trace_smb3_tdis_done(xid, tcon->tid, ses->Suid); 221438c8a9a5SSteve French 221538c8a9a5SSteve French return rc; 221638c8a9a5SSteve French } 221738c8a9a5SSteve French 221838c8a9a5SSteve French 221938c8a9a5SSteve French static struct create_durable * 222038c8a9a5SSteve French create_durable_buf(void) 222138c8a9a5SSteve French { 222238c8a9a5SSteve French struct create_durable *buf; 222338c8a9a5SSteve French 222438c8a9a5SSteve French buf = kzalloc(sizeof(struct create_durable), GFP_KERNEL); 222538c8a9a5SSteve French if (!buf) 222638c8a9a5SSteve French return NULL; 222738c8a9a5SSteve French 222838c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(offsetof 222938c8a9a5SSteve French (struct create_durable, Data)); 223038c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(16); 223138c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof 223238c8a9a5SSteve French (struct create_durable, Name)); 223338c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 223438c8a9a5SSteve French /* SMB2_CREATE_DURABLE_HANDLE_REQUEST is "DHnQ" */ 223538c8a9a5SSteve French buf->Name[0] = 'D'; 223638c8a9a5SSteve French buf->Name[1] = 'H'; 223738c8a9a5SSteve French buf->Name[2] = 'n'; 223838c8a9a5SSteve French buf->Name[3] = 'Q'; 223938c8a9a5SSteve French return buf; 224038c8a9a5SSteve French } 224138c8a9a5SSteve French 224238c8a9a5SSteve French static struct create_durable * 224338c8a9a5SSteve French create_reconnect_durable_buf(struct cifs_fid *fid) 224438c8a9a5SSteve French { 224538c8a9a5SSteve French struct create_durable *buf; 224638c8a9a5SSteve French 224738c8a9a5SSteve French buf = kzalloc(sizeof(struct create_durable), GFP_KERNEL); 224838c8a9a5SSteve French if (!buf) 224938c8a9a5SSteve French return NULL; 225038c8a9a5SSteve French 225138c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(offsetof 225238c8a9a5SSteve French (struct create_durable, Data)); 225338c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(16); 225438c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof 225538c8a9a5SSteve French (struct create_durable, Name)); 225638c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 225738c8a9a5SSteve French buf->Data.Fid.PersistentFileId = fid->persistent_fid; 225838c8a9a5SSteve French buf->Data.Fid.VolatileFileId = fid->volatile_fid; 225938c8a9a5SSteve French /* SMB2_CREATE_DURABLE_HANDLE_RECONNECT is "DHnC" */ 226038c8a9a5SSteve French buf->Name[0] = 'D'; 226138c8a9a5SSteve French buf->Name[1] = 'H'; 226238c8a9a5SSteve French buf->Name[2] = 'n'; 226338c8a9a5SSteve French buf->Name[3] = 'C'; 226438c8a9a5SSteve French return buf; 226538c8a9a5SSteve French } 226638c8a9a5SSteve French 226738c8a9a5SSteve French static void 226838c8a9a5SSteve French parse_query_id_ctxt(struct create_context *cc, struct smb2_file_all_info *buf) 226938c8a9a5SSteve French { 227038c8a9a5SSteve French struct create_disk_id_rsp *pdisk_id = (struct create_disk_id_rsp *)cc; 227138c8a9a5SSteve French 227238c8a9a5SSteve French cifs_dbg(FYI, "parse query id context 0x%llx 0x%llx\n", 227338c8a9a5SSteve French pdisk_id->DiskFileId, pdisk_id->VolumeId); 227438c8a9a5SSteve French buf->IndexNumber = pdisk_id->DiskFileId; 227538c8a9a5SSteve French } 227638c8a9a5SSteve French 227738c8a9a5SSteve French static void 227838c8a9a5SSteve French parse_posix_ctxt(struct create_context *cc, struct smb2_file_all_info *info, 227938c8a9a5SSteve French struct create_posix_rsp *posix) 228038c8a9a5SSteve French { 228138c8a9a5SSteve French int sid_len; 228238c8a9a5SSteve French u8 *beg = (u8 *)cc + le16_to_cpu(cc->DataOffset); 228338c8a9a5SSteve French u8 *end = beg + le32_to_cpu(cc->DataLength); 228438c8a9a5SSteve French u8 *sid; 228538c8a9a5SSteve French 228638c8a9a5SSteve French memset(posix, 0, sizeof(*posix)); 228738c8a9a5SSteve French 228838c8a9a5SSteve French posix->nlink = le32_to_cpu(*(__le32 *)(beg + 0)); 228938c8a9a5SSteve French posix->reparse_tag = le32_to_cpu(*(__le32 *)(beg + 4)); 229038c8a9a5SSteve French posix->mode = le32_to_cpu(*(__le32 *)(beg + 8)); 229138c8a9a5SSteve French 229238c8a9a5SSteve French sid = beg + 12; 229338c8a9a5SSteve French sid_len = posix_info_sid_size(sid, end); 229438c8a9a5SSteve French if (sid_len < 0) { 229538c8a9a5SSteve French cifs_dbg(VFS, "bad owner sid in posix create response\n"); 229638c8a9a5SSteve French return; 229738c8a9a5SSteve French } 229838c8a9a5SSteve French memcpy(&posix->owner, sid, sid_len); 229938c8a9a5SSteve French 230038c8a9a5SSteve French sid = sid + sid_len; 230138c8a9a5SSteve French sid_len = posix_info_sid_size(sid, end); 230238c8a9a5SSteve French if (sid_len < 0) { 230338c8a9a5SSteve French cifs_dbg(VFS, "bad group sid in posix create response\n"); 230438c8a9a5SSteve French return; 230538c8a9a5SSteve French } 230638c8a9a5SSteve French memcpy(&posix->group, sid, sid_len); 230738c8a9a5SSteve French 230838c8a9a5SSteve French cifs_dbg(FYI, "nlink=%d mode=%o reparse_tag=%x\n", 230938c8a9a5SSteve French posix->nlink, posix->mode, posix->reparse_tag); 231038c8a9a5SSteve French } 231138c8a9a5SSteve French 231217a0f64cSPaulo Alcantara int smb2_parse_contexts(struct TCP_Server_Info *server, 231317a0f64cSPaulo Alcantara struct kvec *rsp_iov, 231417a0f64cSPaulo Alcantara unsigned int *epoch, 231517a0f64cSPaulo Alcantara char *lease_key, __u8 *oplock, 231638c8a9a5SSteve French struct smb2_file_all_info *buf, 231738c8a9a5SSteve French struct create_posix_rsp *posix) 231838c8a9a5SSteve French { 231917a0f64cSPaulo Alcantara struct smb2_create_rsp *rsp = rsp_iov->iov_base; 232038c8a9a5SSteve French struct create_context *cc; 232117a0f64cSPaulo Alcantara size_t rem, off, len; 232217a0f64cSPaulo Alcantara size_t doff, dlen; 232317a0f64cSPaulo Alcantara size_t noff, nlen; 232438c8a9a5SSteve French char *name; 232538c8a9a5SSteve French static const char smb3_create_tag_posix[] = { 232638c8a9a5SSteve French 0x93, 0xAD, 0x25, 0x50, 0x9C, 232738c8a9a5SSteve French 0xB4, 0x11, 0xE7, 0xB4, 0x23, 0x83, 232838c8a9a5SSteve French 0xDE, 0x96, 0x8B, 0xCD, 0x7C 232938c8a9a5SSteve French }; 233038c8a9a5SSteve French 233138c8a9a5SSteve French *oplock = 0; 233217a0f64cSPaulo Alcantara 233317a0f64cSPaulo Alcantara off = le32_to_cpu(rsp->CreateContextsOffset); 233417a0f64cSPaulo Alcantara rem = le32_to_cpu(rsp->CreateContextsLength); 233517a0f64cSPaulo Alcantara if (check_add_overflow(off, rem, &len) || len > rsp_iov->iov_len) 233617a0f64cSPaulo Alcantara return -EINVAL; 233717a0f64cSPaulo Alcantara cc = (struct create_context *)((u8 *)rsp + off); 233838c8a9a5SSteve French 233938c8a9a5SSteve French /* Initialize inode number to 0 in case no valid data in qfid context */ 234038c8a9a5SSteve French if (buf) 234138c8a9a5SSteve French buf->IndexNumber = 0; 234238c8a9a5SSteve French 234317a0f64cSPaulo Alcantara while (rem >= sizeof(*cc)) { 234417a0f64cSPaulo Alcantara doff = le16_to_cpu(cc->DataOffset); 234517a0f64cSPaulo Alcantara dlen = le32_to_cpu(cc->DataLength); 234617a0f64cSPaulo Alcantara if (check_add_overflow(doff, dlen, &len) || len > rem) 234717a0f64cSPaulo Alcantara return -EINVAL; 234817a0f64cSPaulo Alcantara 234917a0f64cSPaulo Alcantara noff = le16_to_cpu(cc->NameOffset); 235017a0f64cSPaulo Alcantara nlen = le16_to_cpu(cc->NameLength); 235138298acbSPaulo Alcantara if (noff + nlen > doff) 235217a0f64cSPaulo Alcantara return -EINVAL; 235317a0f64cSPaulo Alcantara 235417a0f64cSPaulo Alcantara name = (char *)cc + noff; 235517a0f64cSPaulo Alcantara switch (nlen) { 235617a0f64cSPaulo Alcantara case 4: 235717a0f64cSPaulo Alcantara if (!strncmp(name, SMB2_CREATE_REQUEST_LEASE, 4)) { 235838c8a9a5SSteve French *oplock = server->ops->parse_lease_buf(cc, epoch, 235938c8a9a5SSteve French lease_key); 236017a0f64cSPaulo Alcantara } else if (buf && 236117a0f64cSPaulo Alcantara !strncmp(name, SMB2_CREATE_QUERY_ON_DISK_ID, 4)) { 236238c8a9a5SSteve French parse_query_id_ctxt(cc, buf); 236338c8a9a5SSteve French } 236438c8a9a5SSteve French break; 236517a0f64cSPaulo Alcantara case 16: 236617a0f64cSPaulo Alcantara if (posix && !memcmp(name, smb3_create_tag_posix, 16)) 236717a0f64cSPaulo Alcantara parse_posix_ctxt(cc, buf, posix); 236817a0f64cSPaulo Alcantara break; 236917a0f64cSPaulo Alcantara default: 237017a0f64cSPaulo Alcantara cifs_dbg(FYI, "%s: unhandled context (nlen=%zu dlen=%zu)\n", 237117a0f64cSPaulo Alcantara __func__, nlen, dlen); 237217a0f64cSPaulo Alcantara if (IS_ENABLED(CONFIG_CIFS_DEBUG2)) 237317a0f64cSPaulo Alcantara cifs_dump_mem("context data: ", cc, dlen); 237417a0f64cSPaulo Alcantara break; 237517a0f64cSPaulo Alcantara } 237617a0f64cSPaulo Alcantara 237717a0f64cSPaulo Alcantara off = le32_to_cpu(cc->Next); 237817a0f64cSPaulo Alcantara if (!off) 237917a0f64cSPaulo Alcantara break; 238017a0f64cSPaulo Alcantara if (check_sub_overflow(rem, off, &rem)) 238117a0f64cSPaulo Alcantara return -EINVAL; 238217a0f64cSPaulo Alcantara cc = (struct create_context *)((u8 *)cc + off); 238338c8a9a5SSteve French } 238438c8a9a5SSteve French 238538c8a9a5SSteve French if (rsp->OplockLevel != SMB2_OPLOCK_LEVEL_LEASE) 238638c8a9a5SSteve French *oplock = rsp->OplockLevel; 238738c8a9a5SSteve French 238817a0f64cSPaulo Alcantara return 0; 238938c8a9a5SSteve French } 239038c8a9a5SSteve French 239138c8a9a5SSteve French static int 239238c8a9a5SSteve French add_lease_context(struct TCP_Server_Info *server, 239338c8a9a5SSteve French struct smb2_create_req *req, 239438c8a9a5SSteve French struct kvec *iov, 239538c8a9a5SSteve French unsigned int *num_iovec, u8 *lease_key, __u8 *oplock) 239638c8a9a5SSteve French { 239738c8a9a5SSteve French unsigned int num = *num_iovec; 239838c8a9a5SSteve French 239938c8a9a5SSteve French iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock); 240038c8a9a5SSteve French if (iov[num].iov_base == NULL) 240138c8a9a5SSteve French return -ENOMEM; 240238c8a9a5SSteve French iov[num].iov_len = server->vals->create_lease_size; 240338c8a9a5SSteve French req->RequestedOplockLevel = SMB2_OPLOCK_LEVEL_LEASE; 240438c8a9a5SSteve French *num_iovec = num + 1; 240538c8a9a5SSteve French return 0; 240638c8a9a5SSteve French } 240738c8a9a5SSteve French 240838c8a9a5SSteve French static struct create_durable_v2 * 240938c8a9a5SSteve French create_durable_v2_buf(struct cifs_open_parms *oparms) 241038c8a9a5SSteve French { 241138c8a9a5SSteve French struct cifs_fid *pfid = oparms->fid; 241238c8a9a5SSteve French struct create_durable_v2 *buf; 241338c8a9a5SSteve French 241438c8a9a5SSteve French buf = kzalloc(sizeof(struct create_durable_v2), GFP_KERNEL); 241538c8a9a5SSteve French if (!buf) 241638c8a9a5SSteve French return NULL; 241738c8a9a5SSteve French 241838c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(offsetof 241938c8a9a5SSteve French (struct create_durable_v2, dcontext)); 242038c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(sizeof(struct durable_context_v2)); 242138c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof 242238c8a9a5SSteve French (struct create_durable_v2, Name)); 242338c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 242438c8a9a5SSteve French 242538c8a9a5SSteve French /* 242638c8a9a5SSteve French * NB: Handle timeout defaults to 0, which allows server to choose 242738c8a9a5SSteve French * (most servers default to 120 seconds) and most clients default to 0. 242838c8a9a5SSteve French * This can be overridden at mount ("handletimeout=") if the user wants 242938c8a9a5SSteve French * a different persistent (or resilient) handle timeout for all opens 24302c75426cSSteve French * on a particular SMB3 mount. 243138c8a9a5SSteve French */ 243238c8a9a5SSteve French buf->dcontext.Timeout = cpu_to_le32(oparms->tcon->handle_timeout); 243338c8a9a5SSteve French buf->dcontext.Flags = cpu_to_le32(SMB2_DHANDLE_FLAG_PERSISTENT); 24341b5f2928SSteve French 24351b5f2928SSteve French /* for replay, we should not overwrite the existing create guid */ 24361b5f2928SSteve French if (!oparms->replay) { 243738c8a9a5SSteve French generate_random_uuid(buf->dcontext.CreateGuid); 243838c8a9a5SSteve French memcpy(pfid->create_guid, buf->dcontext.CreateGuid, 16); 24391b5f2928SSteve French } else 24401b5f2928SSteve French memcpy(buf->dcontext.CreateGuid, pfid->create_guid, 16); 244138c8a9a5SSteve French 244238c8a9a5SSteve French /* SMB2_CREATE_DURABLE_HANDLE_REQUEST is "DH2Q" */ 244338c8a9a5SSteve French buf->Name[0] = 'D'; 244438c8a9a5SSteve French buf->Name[1] = 'H'; 244538c8a9a5SSteve French buf->Name[2] = '2'; 244638c8a9a5SSteve French buf->Name[3] = 'Q'; 244738c8a9a5SSteve French return buf; 244838c8a9a5SSteve French } 244938c8a9a5SSteve French 245038c8a9a5SSteve French static struct create_durable_handle_reconnect_v2 * 245138c8a9a5SSteve French create_reconnect_durable_v2_buf(struct cifs_fid *fid) 245238c8a9a5SSteve French { 245338c8a9a5SSteve French struct create_durable_handle_reconnect_v2 *buf; 245438c8a9a5SSteve French 245538c8a9a5SSteve French buf = kzalloc(sizeof(struct create_durable_handle_reconnect_v2), 245638c8a9a5SSteve French GFP_KERNEL); 245738c8a9a5SSteve French if (!buf) 245838c8a9a5SSteve French return NULL; 245938c8a9a5SSteve French 246038c8a9a5SSteve French buf->ccontext.DataOffset = 246138c8a9a5SSteve French cpu_to_le16(offsetof(struct create_durable_handle_reconnect_v2, 246238c8a9a5SSteve French dcontext)); 246338c8a9a5SSteve French buf->ccontext.DataLength = 246438c8a9a5SSteve French cpu_to_le32(sizeof(struct durable_reconnect_context_v2)); 246538c8a9a5SSteve French buf->ccontext.NameOffset = 246638c8a9a5SSteve French cpu_to_le16(offsetof(struct create_durable_handle_reconnect_v2, 246738c8a9a5SSteve French Name)); 246838c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 246938c8a9a5SSteve French 247038c8a9a5SSteve French buf->dcontext.Fid.PersistentFileId = fid->persistent_fid; 247138c8a9a5SSteve French buf->dcontext.Fid.VolatileFileId = fid->volatile_fid; 247238c8a9a5SSteve French buf->dcontext.Flags = cpu_to_le32(SMB2_DHANDLE_FLAG_PERSISTENT); 247338c8a9a5SSteve French memcpy(buf->dcontext.CreateGuid, fid->create_guid, 16); 247438c8a9a5SSteve French 247538c8a9a5SSteve French /* SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 is "DH2C" */ 247638c8a9a5SSteve French buf->Name[0] = 'D'; 247738c8a9a5SSteve French buf->Name[1] = 'H'; 247838c8a9a5SSteve French buf->Name[2] = '2'; 247938c8a9a5SSteve French buf->Name[3] = 'C'; 248038c8a9a5SSteve French return buf; 248138c8a9a5SSteve French } 248238c8a9a5SSteve French 248338c8a9a5SSteve French static int 248438c8a9a5SSteve French add_durable_v2_context(struct kvec *iov, unsigned int *num_iovec, 248538c8a9a5SSteve French struct cifs_open_parms *oparms) 248638c8a9a5SSteve French { 248738c8a9a5SSteve French unsigned int num = *num_iovec; 248838c8a9a5SSteve French 248938c8a9a5SSteve French iov[num].iov_base = create_durable_v2_buf(oparms); 249038c8a9a5SSteve French if (iov[num].iov_base == NULL) 249138c8a9a5SSteve French return -ENOMEM; 249238c8a9a5SSteve French iov[num].iov_len = sizeof(struct create_durable_v2); 249338c8a9a5SSteve French *num_iovec = num + 1; 249438c8a9a5SSteve French return 0; 249538c8a9a5SSteve French } 249638c8a9a5SSteve French 249738c8a9a5SSteve French static int 249838c8a9a5SSteve French add_durable_reconnect_v2_context(struct kvec *iov, unsigned int *num_iovec, 249938c8a9a5SSteve French struct cifs_open_parms *oparms) 250038c8a9a5SSteve French { 250138c8a9a5SSteve French unsigned int num = *num_iovec; 250238c8a9a5SSteve French 250338c8a9a5SSteve French /* indicate that we don't need to relock the file */ 250438c8a9a5SSteve French oparms->reconnect = false; 250538c8a9a5SSteve French 250638c8a9a5SSteve French iov[num].iov_base = create_reconnect_durable_v2_buf(oparms->fid); 250738c8a9a5SSteve French if (iov[num].iov_base == NULL) 250838c8a9a5SSteve French return -ENOMEM; 250938c8a9a5SSteve French iov[num].iov_len = sizeof(struct create_durable_handle_reconnect_v2); 251038c8a9a5SSteve French *num_iovec = num + 1; 251138c8a9a5SSteve French return 0; 251238c8a9a5SSteve French } 251338c8a9a5SSteve French 251438c8a9a5SSteve French static int 251538c8a9a5SSteve French add_durable_context(struct kvec *iov, unsigned int *num_iovec, 251638c8a9a5SSteve French struct cifs_open_parms *oparms, bool use_persistent) 251738c8a9a5SSteve French { 251838c8a9a5SSteve French unsigned int num = *num_iovec; 251938c8a9a5SSteve French 252038c8a9a5SSteve French if (use_persistent) { 252138c8a9a5SSteve French if (oparms->reconnect) 252238c8a9a5SSteve French return add_durable_reconnect_v2_context(iov, num_iovec, 252338c8a9a5SSteve French oparms); 252438c8a9a5SSteve French else 252538c8a9a5SSteve French return add_durable_v2_context(iov, num_iovec, oparms); 252638c8a9a5SSteve French } 252738c8a9a5SSteve French 252838c8a9a5SSteve French if (oparms->reconnect) { 252938c8a9a5SSteve French iov[num].iov_base = create_reconnect_durable_buf(oparms->fid); 253038c8a9a5SSteve French /* indicate that we don't need to relock the file */ 253138c8a9a5SSteve French oparms->reconnect = false; 253238c8a9a5SSteve French } else 253338c8a9a5SSteve French iov[num].iov_base = create_durable_buf(); 253438c8a9a5SSteve French if (iov[num].iov_base == NULL) 253538c8a9a5SSteve French return -ENOMEM; 253638c8a9a5SSteve French iov[num].iov_len = sizeof(struct create_durable); 253738c8a9a5SSteve French *num_iovec = num + 1; 253838c8a9a5SSteve French return 0; 253938c8a9a5SSteve French } 254038c8a9a5SSteve French 254138c8a9a5SSteve French /* See MS-SMB2 2.2.13.2.7 */ 254238c8a9a5SSteve French static struct crt_twarp_ctxt * 254338c8a9a5SSteve French create_twarp_buf(__u64 timewarp) 254438c8a9a5SSteve French { 254538c8a9a5SSteve French struct crt_twarp_ctxt *buf; 254638c8a9a5SSteve French 254738c8a9a5SSteve French buf = kzalloc(sizeof(struct crt_twarp_ctxt), GFP_KERNEL); 254838c8a9a5SSteve French if (!buf) 254938c8a9a5SSteve French return NULL; 255038c8a9a5SSteve French 255138c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(offsetof 255238c8a9a5SSteve French (struct crt_twarp_ctxt, Timestamp)); 255338c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(8); 255438c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof 255538c8a9a5SSteve French (struct crt_twarp_ctxt, Name)); 255638c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 255738c8a9a5SSteve French /* SMB2_CREATE_TIMEWARP_TOKEN is "TWrp" */ 255838c8a9a5SSteve French buf->Name[0] = 'T'; 255938c8a9a5SSteve French buf->Name[1] = 'W'; 256038c8a9a5SSteve French buf->Name[2] = 'r'; 256138c8a9a5SSteve French buf->Name[3] = 'p'; 256238c8a9a5SSteve French buf->Timestamp = cpu_to_le64(timewarp); 256338c8a9a5SSteve French return buf; 256438c8a9a5SSteve French } 256538c8a9a5SSteve French 256638c8a9a5SSteve French /* See MS-SMB2 2.2.13.2.7 */ 256738c8a9a5SSteve French static int 256838c8a9a5SSteve French add_twarp_context(struct kvec *iov, unsigned int *num_iovec, __u64 timewarp) 256938c8a9a5SSteve French { 257038c8a9a5SSteve French unsigned int num = *num_iovec; 257138c8a9a5SSteve French 257238c8a9a5SSteve French iov[num].iov_base = create_twarp_buf(timewarp); 257338c8a9a5SSteve French if (iov[num].iov_base == NULL) 257438c8a9a5SSteve French return -ENOMEM; 257538c8a9a5SSteve French iov[num].iov_len = sizeof(struct crt_twarp_ctxt); 257638c8a9a5SSteve French *num_iovec = num + 1; 257738c8a9a5SSteve French return 0; 257838c8a9a5SSteve French } 257938c8a9a5SSteve French 25802c75426cSSteve French /* See http://technet.microsoft.com/en-us/library/hh509017(v=ws.10).aspx */ 258138c8a9a5SSteve French static void setup_owner_group_sids(char *buf) 258238c8a9a5SSteve French { 258338c8a9a5SSteve French struct owner_group_sids *sids = (struct owner_group_sids *)buf; 258438c8a9a5SSteve French 258538c8a9a5SSteve French /* Populate the user ownership fields S-1-5-88-1 */ 258638c8a9a5SSteve French sids->owner.Revision = 1; 258738c8a9a5SSteve French sids->owner.NumAuth = 3; 258838c8a9a5SSteve French sids->owner.Authority[5] = 5; 258938c8a9a5SSteve French sids->owner.SubAuthorities[0] = cpu_to_le32(88); 259038c8a9a5SSteve French sids->owner.SubAuthorities[1] = cpu_to_le32(1); 259138c8a9a5SSteve French sids->owner.SubAuthorities[2] = cpu_to_le32(current_fsuid().val); 259238c8a9a5SSteve French 259338c8a9a5SSteve French /* Populate the group ownership fields S-1-5-88-2 */ 259438c8a9a5SSteve French sids->group.Revision = 1; 259538c8a9a5SSteve French sids->group.NumAuth = 3; 259638c8a9a5SSteve French sids->group.Authority[5] = 5; 259738c8a9a5SSteve French sids->group.SubAuthorities[0] = cpu_to_le32(88); 259838c8a9a5SSteve French sids->group.SubAuthorities[1] = cpu_to_le32(2); 259938c8a9a5SSteve French sids->group.SubAuthorities[2] = cpu_to_le32(current_fsgid().val); 260038c8a9a5SSteve French 260138c8a9a5SSteve French cifs_dbg(FYI, "owner S-1-5-88-1-%d, group S-1-5-88-2-%d\n", current_fsuid().val, current_fsgid().val); 260238c8a9a5SSteve French } 260338c8a9a5SSteve French 260438c8a9a5SSteve French /* See MS-SMB2 2.2.13.2.2 and MS-DTYP 2.4.6 */ 260538c8a9a5SSteve French static struct crt_sd_ctxt * 260638c8a9a5SSteve French create_sd_buf(umode_t mode, bool set_owner, unsigned int *len) 260738c8a9a5SSteve French { 260838c8a9a5SSteve French struct crt_sd_ctxt *buf; 260938c8a9a5SSteve French __u8 *ptr, *aclptr; 261038c8a9a5SSteve French unsigned int acelen, acl_size, ace_count; 261138c8a9a5SSteve French unsigned int owner_offset = 0; 261238c8a9a5SSteve French unsigned int group_offset = 0; 261338c8a9a5SSteve French struct smb3_acl acl = {}; 261438c8a9a5SSteve French 261538c8a9a5SSteve French *len = round_up(sizeof(struct crt_sd_ctxt) + (sizeof(struct cifs_ace) * 4), 8); 261638c8a9a5SSteve French 261738c8a9a5SSteve French if (set_owner) { 261838c8a9a5SSteve French /* sizeof(struct owner_group_sids) is already multiple of 8 so no need to round */ 261938c8a9a5SSteve French *len += sizeof(struct owner_group_sids); 262038c8a9a5SSteve French } 262138c8a9a5SSteve French 262238c8a9a5SSteve French buf = kzalloc(*len, GFP_KERNEL); 262338c8a9a5SSteve French if (buf == NULL) 262438c8a9a5SSteve French return buf; 262538c8a9a5SSteve French 262638c8a9a5SSteve French ptr = (__u8 *)&buf[1]; 262738c8a9a5SSteve French if (set_owner) { 262838c8a9a5SSteve French /* offset fields are from beginning of security descriptor not of create context */ 262938c8a9a5SSteve French owner_offset = ptr - (__u8 *)&buf->sd; 263038c8a9a5SSteve French buf->sd.OffsetOwner = cpu_to_le32(owner_offset); 263138c8a9a5SSteve French group_offset = owner_offset + offsetof(struct owner_group_sids, group); 263238c8a9a5SSteve French buf->sd.OffsetGroup = cpu_to_le32(group_offset); 263338c8a9a5SSteve French 263438c8a9a5SSteve French setup_owner_group_sids(ptr); 263538c8a9a5SSteve French ptr += sizeof(struct owner_group_sids); 263638c8a9a5SSteve French } else { 263738c8a9a5SSteve French buf->sd.OffsetOwner = 0; 263838c8a9a5SSteve French buf->sd.OffsetGroup = 0; 263938c8a9a5SSteve French } 264038c8a9a5SSteve French 264138c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(offsetof(struct crt_sd_ctxt, sd)); 264238c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof(struct crt_sd_ctxt, Name)); 264338c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 264438c8a9a5SSteve French /* SMB2_CREATE_SD_BUFFER_TOKEN is "SecD" */ 264538c8a9a5SSteve French buf->Name[0] = 'S'; 264638c8a9a5SSteve French buf->Name[1] = 'e'; 264738c8a9a5SSteve French buf->Name[2] = 'c'; 264838c8a9a5SSteve French buf->Name[3] = 'D'; 264938c8a9a5SSteve French buf->sd.Revision = 1; /* Must be one see MS-DTYP 2.4.6 */ 265038c8a9a5SSteve French 265138c8a9a5SSteve French /* 265238c8a9a5SSteve French * ACL is "self relative" ie ACL is stored in contiguous block of memory 265338c8a9a5SSteve French * and "DP" ie the DACL is present 265438c8a9a5SSteve French */ 265538c8a9a5SSteve French buf->sd.Control = cpu_to_le16(ACL_CONTROL_SR | ACL_CONTROL_DP); 265638c8a9a5SSteve French 265738c8a9a5SSteve French /* offset owner, group and Sbz1 and SACL are all zero */ 265838c8a9a5SSteve French buf->sd.OffsetDacl = cpu_to_le32(ptr - (__u8 *)&buf->sd); 265938c8a9a5SSteve French /* Ship the ACL for now. we will copy it into buf later. */ 266038c8a9a5SSteve French aclptr = ptr; 266138c8a9a5SSteve French ptr += sizeof(struct smb3_acl); 266238c8a9a5SSteve French 266338c8a9a5SSteve French /* create one ACE to hold the mode embedded in reserved special SID */ 266438c8a9a5SSteve French acelen = setup_special_mode_ACE((struct cifs_ace *)ptr, (__u64)mode); 266538c8a9a5SSteve French ptr += acelen; 266638c8a9a5SSteve French acl_size = acelen + sizeof(struct smb3_acl); 266738c8a9a5SSteve French ace_count = 1; 266838c8a9a5SSteve French 266938c8a9a5SSteve French if (set_owner) { 267038c8a9a5SSteve French /* we do not need to reallocate buffer to add the two more ACEs. plenty of space */ 267138c8a9a5SSteve French acelen = setup_special_user_owner_ACE((struct cifs_ace *)ptr); 267238c8a9a5SSteve French ptr += acelen; 267338c8a9a5SSteve French acl_size += acelen; 267438c8a9a5SSteve French ace_count += 1; 267538c8a9a5SSteve French } 267638c8a9a5SSteve French 267738c8a9a5SSteve French /* and one more ACE to allow access for authenticated users */ 267838c8a9a5SSteve French acelen = setup_authusers_ACE((struct cifs_ace *)ptr); 267938c8a9a5SSteve French ptr += acelen; 268038c8a9a5SSteve French acl_size += acelen; 268138c8a9a5SSteve French ace_count += 1; 268238c8a9a5SSteve French 268338c8a9a5SSteve French acl.AclRevision = ACL_REVISION; /* See 2.4.4.1 of MS-DTYP */ 268438c8a9a5SSteve French acl.AclSize = cpu_to_le16(acl_size); 268538c8a9a5SSteve French acl.AceCount = cpu_to_le16(ace_count); 268638c8a9a5SSteve French /* acl.Sbz1 and Sbz2 MBZ so are not set here, but initialized above */ 268738c8a9a5SSteve French memcpy(aclptr, &acl, sizeof(struct smb3_acl)); 268838c8a9a5SSteve French 268938c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(ptr - (__u8 *)&buf->sd); 269038c8a9a5SSteve French *len = round_up((unsigned int)(ptr - (__u8 *)buf), 8); 269138c8a9a5SSteve French 269238c8a9a5SSteve French return buf; 269338c8a9a5SSteve French } 269438c8a9a5SSteve French 269538c8a9a5SSteve French static int 269638c8a9a5SSteve French add_sd_context(struct kvec *iov, unsigned int *num_iovec, umode_t mode, bool set_owner) 269738c8a9a5SSteve French { 269838c8a9a5SSteve French unsigned int num = *num_iovec; 269938c8a9a5SSteve French unsigned int len = 0; 270038c8a9a5SSteve French 270138c8a9a5SSteve French iov[num].iov_base = create_sd_buf(mode, set_owner, &len); 270238c8a9a5SSteve French if (iov[num].iov_base == NULL) 270338c8a9a5SSteve French return -ENOMEM; 270438c8a9a5SSteve French iov[num].iov_len = len; 270538c8a9a5SSteve French *num_iovec = num + 1; 270638c8a9a5SSteve French return 0; 270738c8a9a5SSteve French } 270838c8a9a5SSteve French 270938c8a9a5SSteve French static struct crt_query_id_ctxt * 271038c8a9a5SSteve French create_query_id_buf(void) 271138c8a9a5SSteve French { 271238c8a9a5SSteve French struct crt_query_id_ctxt *buf; 271338c8a9a5SSteve French 271438c8a9a5SSteve French buf = kzalloc(sizeof(struct crt_query_id_ctxt), GFP_KERNEL); 271538c8a9a5SSteve French if (!buf) 271638c8a9a5SSteve French return NULL; 271738c8a9a5SSteve French 271838c8a9a5SSteve French buf->ccontext.DataOffset = cpu_to_le16(0); 271938c8a9a5SSteve French buf->ccontext.DataLength = cpu_to_le32(0); 272038c8a9a5SSteve French buf->ccontext.NameOffset = cpu_to_le16(offsetof 272138c8a9a5SSteve French (struct crt_query_id_ctxt, Name)); 272238c8a9a5SSteve French buf->ccontext.NameLength = cpu_to_le16(4); 272338c8a9a5SSteve French /* SMB2_CREATE_QUERY_ON_DISK_ID is "QFid" */ 272438c8a9a5SSteve French buf->Name[0] = 'Q'; 272538c8a9a5SSteve French buf->Name[1] = 'F'; 272638c8a9a5SSteve French buf->Name[2] = 'i'; 272738c8a9a5SSteve French buf->Name[3] = 'd'; 272838c8a9a5SSteve French return buf; 272938c8a9a5SSteve French } 273038c8a9a5SSteve French 273138c8a9a5SSteve French /* See MS-SMB2 2.2.13.2.9 */ 273238c8a9a5SSteve French static int 273338c8a9a5SSteve French add_query_id_context(struct kvec *iov, unsigned int *num_iovec) 273438c8a9a5SSteve French { 273538c8a9a5SSteve French unsigned int num = *num_iovec; 273638c8a9a5SSteve French 273738c8a9a5SSteve French iov[num].iov_base = create_query_id_buf(); 273838c8a9a5SSteve French if (iov[num].iov_base == NULL) 273938c8a9a5SSteve French return -ENOMEM; 274038c8a9a5SSteve French iov[num].iov_len = sizeof(struct crt_query_id_ctxt); 274138c8a9a5SSteve French *num_iovec = num + 1; 274238c8a9a5SSteve French return 0; 274338c8a9a5SSteve French } 274438c8a9a5SSteve French 2745df0a8a19SPaulo Alcantara static void add_ea_context(struct cifs_open_parms *oparms, 2746df0a8a19SPaulo Alcantara struct kvec *rq_iov, unsigned int *num_iovs) 2747df0a8a19SPaulo Alcantara { 2748df0a8a19SPaulo Alcantara struct kvec *iov = oparms->ea_cctx; 2749df0a8a19SPaulo Alcantara 2750df0a8a19SPaulo Alcantara if (iov && iov->iov_base && iov->iov_len) { 2751df0a8a19SPaulo Alcantara rq_iov[(*num_iovs)++] = *iov; 2752df0a8a19SPaulo Alcantara memset(iov, 0, sizeof(*iov)); 2753df0a8a19SPaulo Alcantara } 2754df0a8a19SPaulo Alcantara } 2755df0a8a19SPaulo Alcantara 275638c8a9a5SSteve French static int 275738c8a9a5SSteve French alloc_path_with_tree_prefix(__le16 **out_path, int *out_size, int *out_len, 275838c8a9a5SSteve French const char *treename, const __le16 *path) 275938c8a9a5SSteve French { 276038c8a9a5SSteve French int treename_len, path_len; 276138c8a9a5SSteve French struct nls_table *cp; 276238c8a9a5SSteve French const __le16 sep[] = {cpu_to_le16('\\'), cpu_to_le16(0x0000)}; 276338c8a9a5SSteve French 276438c8a9a5SSteve French /* 276538c8a9a5SSteve French * skip leading "\\" 276638c8a9a5SSteve French */ 276738c8a9a5SSteve French treename_len = strlen(treename); 276838c8a9a5SSteve French if (treename_len < 2 || !(treename[0] == '\\' && treename[1] == '\\')) 276938c8a9a5SSteve French return -EINVAL; 277038c8a9a5SSteve French 277138c8a9a5SSteve French treename += 2; 277238c8a9a5SSteve French treename_len -= 2; 277338c8a9a5SSteve French 277438c8a9a5SSteve French path_len = UniStrnlen((wchar_t *)path, PATH_MAX); 277538c8a9a5SSteve French 277638c8a9a5SSteve French /* make room for one path separator only if @path isn't empty */ 277738c8a9a5SSteve French *out_len = treename_len + (path[0] ? 1 : 0) + path_len; 277838c8a9a5SSteve French 277938c8a9a5SSteve French /* 278038c8a9a5SSteve French * final path needs to be 8-byte aligned as specified in 278138c8a9a5SSteve French * MS-SMB2 2.2.13 SMB2 CREATE Request. 278238c8a9a5SSteve French */ 278338c8a9a5SSteve French *out_size = round_up(*out_len * sizeof(__le16), 8); 278438c8a9a5SSteve French *out_path = kzalloc(*out_size + sizeof(__le16) /* null */, GFP_KERNEL); 278538c8a9a5SSteve French if (!*out_path) 278638c8a9a5SSteve French return -ENOMEM; 278738c8a9a5SSteve French 278838c8a9a5SSteve French cp = load_nls_default(); 278938c8a9a5SSteve French cifs_strtoUTF16(*out_path, treename, treename_len, cp); 279038c8a9a5SSteve French 279138c8a9a5SSteve French /* Do not append the separator if the path is empty */ 279238c8a9a5SSteve French if (path[0] != cpu_to_le16(0x0000)) { 2793de548452SDr. David Alan Gilbert UniStrcat((wchar_t *)*out_path, (wchar_t *)sep); 2794de548452SDr. David Alan Gilbert UniStrcat((wchar_t *)*out_path, (wchar_t *)path); 279538c8a9a5SSteve French } 279638c8a9a5SSteve French 279738c8a9a5SSteve French unload_nls(cp); 279838c8a9a5SSteve French 279938c8a9a5SSteve French return 0; 280038c8a9a5SSteve French } 280138c8a9a5SSteve French 280238c8a9a5SSteve French int smb311_posix_mkdir(const unsigned int xid, struct inode *inode, 280338c8a9a5SSteve French umode_t mode, struct cifs_tcon *tcon, 280438c8a9a5SSteve French const char *full_path, 280538c8a9a5SSteve French struct cifs_sb_info *cifs_sb) 280638c8a9a5SSteve French { 280738c8a9a5SSteve French struct smb_rqst rqst; 280838c8a9a5SSteve French struct smb2_create_req *req; 280938c8a9a5SSteve French struct smb2_create_rsp *rsp = NULL; 281038c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 281138c8a9a5SSteve French struct kvec iov[3]; /* make sure at least one for each open context */ 281238c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0}; 281338c8a9a5SSteve French int resp_buftype; 281438c8a9a5SSteve French int uni_path_len; 281538c8a9a5SSteve French __le16 *copy_path = NULL; 281638c8a9a5SSteve French int copy_size; 281738c8a9a5SSteve French int rc = 0; 281838c8a9a5SSteve French unsigned int n_iov = 2; 281938c8a9a5SSteve French __u32 file_attributes = 0; 282038c8a9a5SSteve French char *pc_buf = NULL; 282138c8a9a5SSteve French int flags = 0; 282238c8a9a5SSteve French unsigned int total_len; 282338c8a9a5SSteve French __le16 *utf16_path = NULL; 2824433042a9SShyam Prasad N struct TCP_Server_Info *server; 2825433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 2826433042a9SShyam Prasad N 2827433042a9SShyam Prasad N replay_again: 2828433042a9SShyam Prasad N /* reinitialize for possible replay */ 2829433042a9SShyam Prasad N flags = 0; 2830433042a9SShyam Prasad N n_iov = 2; 2831433042a9SShyam Prasad N server = cifs_pick_channel(ses); 283238c8a9a5SSteve French 283338c8a9a5SSteve French cifs_dbg(FYI, "mkdir\n"); 283438c8a9a5SSteve French 283538c8a9a5SSteve French /* resource #1: path allocation */ 283638c8a9a5SSteve French utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); 283738c8a9a5SSteve French if (!utf16_path) 283838c8a9a5SSteve French return -ENOMEM; 283938c8a9a5SSteve French 284038c8a9a5SSteve French if (!ses || !server) { 284138c8a9a5SSteve French rc = -EIO; 284238c8a9a5SSteve French goto err_free_path; 284338c8a9a5SSteve French } 284438c8a9a5SSteve French 284538c8a9a5SSteve French /* resource #2: request */ 284638c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_CREATE, tcon, server, 284738c8a9a5SSteve French (void **) &req, &total_len); 284838c8a9a5SSteve French if (rc) 284938c8a9a5SSteve French goto err_free_path; 285038c8a9a5SSteve French 285138c8a9a5SSteve French 285238c8a9a5SSteve French if (smb3_encryption_required(tcon)) 285338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 285438c8a9a5SSteve French 285538c8a9a5SSteve French req->ImpersonationLevel = IL_IMPERSONATION; 285638c8a9a5SSteve French req->DesiredAccess = cpu_to_le32(FILE_WRITE_ATTRIBUTES); 285738c8a9a5SSteve French /* File attributes ignored on open (used in create though) */ 285838c8a9a5SSteve French req->FileAttributes = cpu_to_le32(file_attributes); 285938c8a9a5SSteve French req->ShareAccess = FILE_SHARE_ALL_LE; 286038c8a9a5SSteve French req->CreateDisposition = cpu_to_le32(FILE_CREATE); 286138c8a9a5SSteve French req->CreateOptions = cpu_to_le32(CREATE_NOT_FILE); 286238c8a9a5SSteve French 286338c8a9a5SSteve French iov[0].iov_base = (char *)req; 286438c8a9a5SSteve French /* -1 since last byte is buf[0] which is sent below (path) */ 286538c8a9a5SSteve French iov[0].iov_len = total_len - 1; 286638c8a9a5SSteve French 286738c8a9a5SSteve French req->NameOffset = cpu_to_le16(sizeof(struct smb2_create_req)); 286838c8a9a5SSteve French 286938c8a9a5SSteve French /* [MS-SMB2] 2.2.13 NameOffset: 287038c8a9a5SSteve French * If SMB2_FLAGS_DFS_OPERATIONS is set in the Flags field of 287138c8a9a5SSteve French * the SMB2 header, the file name includes a prefix that will 287238c8a9a5SSteve French * be processed during DFS name normalization as specified in 287338c8a9a5SSteve French * section 3.3.5.9. Otherwise, the file name is relative to 287438c8a9a5SSteve French * the share that is identified by the TreeId in the SMB2 287538c8a9a5SSteve French * header. 287638c8a9a5SSteve French */ 287738c8a9a5SSteve French if (tcon->share_flags & SHI1005_FLAGS_DFS) { 287838c8a9a5SSteve French int name_len; 287938c8a9a5SSteve French 288038c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_DFS_OPERATIONS; 288138c8a9a5SSteve French rc = alloc_path_with_tree_prefix(©_path, ©_size, 288238c8a9a5SSteve French &name_len, 288338c8a9a5SSteve French tcon->tree_name, utf16_path); 288438c8a9a5SSteve French if (rc) 288538c8a9a5SSteve French goto err_free_req; 288638c8a9a5SSteve French 288738c8a9a5SSteve French req->NameLength = cpu_to_le16(name_len * 2); 288838c8a9a5SSteve French uni_path_len = copy_size; 288938c8a9a5SSteve French /* free before overwriting resource */ 289038c8a9a5SSteve French kfree(utf16_path); 289138c8a9a5SSteve French utf16_path = copy_path; 289238c8a9a5SSteve French } else { 289338c8a9a5SSteve French uni_path_len = (2 * UniStrnlen((wchar_t *)utf16_path, PATH_MAX)) + 2; 289438c8a9a5SSteve French /* MUST set path len (NameLength) to 0 opening root of share */ 289538c8a9a5SSteve French req->NameLength = cpu_to_le16(uni_path_len - 2); 289638c8a9a5SSteve French if (uni_path_len % 8 != 0) { 289738c8a9a5SSteve French copy_size = roundup(uni_path_len, 8); 289838c8a9a5SSteve French copy_path = kzalloc(copy_size, GFP_KERNEL); 289938c8a9a5SSteve French if (!copy_path) { 290038c8a9a5SSteve French rc = -ENOMEM; 290138c8a9a5SSteve French goto err_free_req; 290238c8a9a5SSteve French } 290338c8a9a5SSteve French memcpy((char *)copy_path, (const char *)utf16_path, 290438c8a9a5SSteve French uni_path_len); 290538c8a9a5SSteve French uni_path_len = copy_size; 290638c8a9a5SSteve French /* free before overwriting resource */ 290738c8a9a5SSteve French kfree(utf16_path); 290838c8a9a5SSteve French utf16_path = copy_path; 290938c8a9a5SSteve French } 291038c8a9a5SSteve French } 291138c8a9a5SSteve French 291238c8a9a5SSteve French iov[1].iov_len = uni_path_len; 291338c8a9a5SSteve French iov[1].iov_base = utf16_path; 291438c8a9a5SSteve French req->RequestedOplockLevel = SMB2_OPLOCK_LEVEL_NONE; 291538c8a9a5SSteve French 291638c8a9a5SSteve French if (tcon->posix_extensions) { 291738c8a9a5SSteve French /* resource #3: posix buf */ 291838c8a9a5SSteve French rc = add_posix_context(iov, &n_iov, mode); 291938c8a9a5SSteve French if (rc) 292038c8a9a5SSteve French goto err_free_req; 292138c8a9a5SSteve French req->CreateContextsOffset = cpu_to_le32( 292238c8a9a5SSteve French sizeof(struct smb2_create_req) + 292338c8a9a5SSteve French iov[1].iov_len); 292438c8a9a5SSteve French pc_buf = iov[n_iov-1].iov_base; 292538c8a9a5SSteve French } 292638c8a9a5SSteve French 292738c8a9a5SSteve French 292838c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 292938c8a9a5SSteve French rqst.rq_iov = iov; 293038c8a9a5SSteve French rqst.rq_nvec = n_iov; 293138c8a9a5SSteve French 293238c8a9a5SSteve French /* no need to inc num_remote_opens because we close it just below */ 293338c8a9a5SSteve French trace_smb3_posix_mkdir_enter(xid, tcon->tid, ses->Suid, full_path, CREATE_NOT_FILE, 293438c8a9a5SSteve French FILE_WRITE_ATTRIBUTES); 2935433042a9SShyam Prasad N 2936433042a9SShyam Prasad N if (retries) 2937433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 2938433042a9SShyam Prasad N 293938c8a9a5SSteve French /* resource #4: response buffer */ 294038c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 294138c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 294238c8a9a5SSteve French if (rc) { 294338c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_CREATE_HE); 294438c8a9a5SSteve French trace_smb3_posix_mkdir_err(xid, tcon->tid, ses->Suid, 294538c8a9a5SSteve French CREATE_NOT_FILE, 294638c8a9a5SSteve French FILE_WRITE_ATTRIBUTES, rc); 294738c8a9a5SSteve French goto err_free_rsp_buf; 294838c8a9a5SSteve French } 294938c8a9a5SSteve French 295038c8a9a5SSteve French /* 295138c8a9a5SSteve French * Although unlikely to be possible for rsp to be null and rc not set, 295238c8a9a5SSteve French * adding check below is slightly safer long term (and quiets Coverity 295338c8a9a5SSteve French * warning) 295438c8a9a5SSteve French */ 295538c8a9a5SSteve French rsp = (struct smb2_create_rsp *)rsp_iov.iov_base; 295638c8a9a5SSteve French if (rsp == NULL) { 295738c8a9a5SSteve French rc = -EIO; 295838c8a9a5SSteve French kfree(pc_buf); 295938c8a9a5SSteve French goto err_free_req; 296038c8a9a5SSteve French } 296138c8a9a5SSteve French 296238c8a9a5SSteve French trace_smb3_posix_mkdir_done(xid, rsp->PersistentFileId, tcon->tid, ses->Suid, 296338c8a9a5SSteve French CREATE_NOT_FILE, FILE_WRITE_ATTRIBUTES); 296438c8a9a5SSteve French 296538c8a9a5SSteve French SMB2_close(xid, tcon, rsp->PersistentFileId, rsp->VolatileFileId); 296638c8a9a5SSteve French 296738c8a9a5SSteve French /* Eventually save off posix specific response info and timestaps */ 296838c8a9a5SSteve French 296938c8a9a5SSteve French err_free_rsp_buf: 297038c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 297138c8a9a5SSteve French kfree(pc_buf); 297238c8a9a5SSteve French err_free_req: 297338c8a9a5SSteve French cifs_small_buf_release(req); 297438c8a9a5SSteve French err_free_path: 297538c8a9a5SSteve French kfree(utf16_path); 2976433042a9SShyam Prasad N 2977433042a9SShyam Prasad N if (is_replayable_error(rc) && 2978433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 2979433042a9SShyam Prasad N goto replay_again; 2980433042a9SShyam Prasad N 298138c8a9a5SSteve French return rc; 298238c8a9a5SSteve French } 298338c8a9a5SSteve French 298438c8a9a5SSteve French int 298538c8a9a5SSteve French SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server, 298638c8a9a5SSteve French struct smb_rqst *rqst, __u8 *oplock, 298738c8a9a5SSteve French struct cifs_open_parms *oparms, __le16 *path) 298838c8a9a5SSteve French { 298938c8a9a5SSteve French struct smb2_create_req *req; 299038c8a9a5SSteve French unsigned int n_iov = 2; 299138c8a9a5SSteve French __u32 file_attributes = 0; 299238c8a9a5SSteve French int copy_size; 299338c8a9a5SSteve French int uni_path_len; 299438c8a9a5SSteve French unsigned int total_len; 299538c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 299638c8a9a5SSteve French __le16 *copy_path; 299738c8a9a5SSteve French int rc; 299838c8a9a5SSteve French 299938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_CREATE, tcon, server, 300038c8a9a5SSteve French (void **) &req, &total_len); 300138c8a9a5SSteve French if (rc) 300238c8a9a5SSteve French return rc; 300338c8a9a5SSteve French 300438c8a9a5SSteve French iov[0].iov_base = (char *)req; 300538c8a9a5SSteve French /* -1 since last byte is buf[0] which is sent below (path) */ 300638c8a9a5SSteve French iov[0].iov_len = total_len - 1; 300738c8a9a5SSteve French 300838c8a9a5SSteve French if (oparms->create_options & CREATE_OPTION_READONLY) 300938c8a9a5SSteve French file_attributes |= ATTR_READONLY; 301038c8a9a5SSteve French if (oparms->create_options & CREATE_OPTION_SPECIAL) 301138c8a9a5SSteve French file_attributes |= ATTR_SYSTEM; 301238c8a9a5SSteve French 301338c8a9a5SSteve French req->ImpersonationLevel = IL_IMPERSONATION; 301438c8a9a5SSteve French req->DesiredAccess = cpu_to_le32(oparms->desired_access); 301538c8a9a5SSteve French /* File attributes ignored on open (used in create though) */ 301638c8a9a5SSteve French req->FileAttributes = cpu_to_le32(file_attributes); 301738c8a9a5SSteve French req->ShareAccess = FILE_SHARE_ALL_LE; 301838c8a9a5SSteve French 301938c8a9a5SSteve French req->CreateDisposition = cpu_to_le32(oparms->disposition); 302038c8a9a5SSteve French req->CreateOptions = cpu_to_le32(oparms->create_options & CREATE_OPTIONS_MASK); 302138c8a9a5SSteve French req->NameOffset = cpu_to_le16(sizeof(struct smb2_create_req)); 302238c8a9a5SSteve French 302338c8a9a5SSteve French /* [MS-SMB2] 2.2.13 NameOffset: 302438c8a9a5SSteve French * If SMB2_FLAGS_DFS_OPERATIONS is set in the Flags field of 302538c8a9a5SSteve French * the SMB2 header, the file name includes a prefix that will 302638c8a9a5SSteve French * be processed during DFS name normalization as specified in 302738c8a9a5SSteve French * section 3.3.5.9. Otherwise, the file name is relative to 302838c8a9a5SSteve French * the share that is identified by the TreeId in the SMB2 302938c8a9a5SSteve French * header. 303038c8a9a5SSteve French */ 303138c8a9a5SSteve French if (tcon->share_flags & SHI1005_FLAGS_DFS) { 303238c8a9a5SSteve French int name_len; 303338c8a9a5SSteve French 303438c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_DFS_OPERATIONS; 303538c8a9a5SSteve French rc = alloc_path_with_tree_prefix(©_path, ©_size, 303638c8a9a5SSteve French &name_len, 303738c8a9a5SSteve French tcon->tree_name, path); 303838c8a9a5SSteve French if (rc) 303938c8a9a5SSteve French return rc; 304038c8a9a5SSteve French req->NameLength = cpu_to_le16(name_len * 2); 304138c8a9a5SSteve French uni_path_len = copy_size; 304238c8a9a5SSteve French path = copy_path; 304338c8a9a5SSteve French } else { 304438c8a9a5SSteve French uni_path_len = (2 * UniStrnlen((wchar_t *)path, PATH_MAX)) + 2; 304538c8a9a5SSteve French /* MUST set path len (NameLength) to 0 opening root of share */ 304638c8a9a5SSteve French req->NameLength = cpu_to_le16(uni_path_len - 2); 304738c8a9a5SSteve French copy_size = round_up(uni_path_len, 8); 304838c8a9a5SSteve French copy_path = kzalloc(copy_size, GFP_KERNEL); 304938c8a9a5SSteve French if (!copy_path) 305038c8a9a5SSteve French return -ENOMEM; 305138c8a9a5SSteve French memcpy((char *)copy_path, (const char *)path, 305238c8a9a5SSteve French uni_path_len); 305338c8a9a5SSteve French uni_path_len = copy_size; 305438c8a9a5SSteve French path = copy_path; 305538c8a9a5SSteve French } 305638c8a9a5SSteve French 305738c8a9a5SSteve French iov[1].iov_len = uni_path_len; 305838c8a9a5SSteve French iov[1].iov_base = path; 305938c8a9a5SSteve French 306038c8a9a5SSteve French if ((!server->oplocks) || (tcon->no_lease)) 306138c8a9a5SSteve French *oplock = SMB2_OPLOCK_LEVEL_NONE; 306238c8a9a5SSteve French 306338c8a9a5SSteve French if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) || 306438c8a9a5SSteve French *oplock == SMB2_OPLOCK_LEVEL_NONE) 306538c8a9a5SSteve French req->RequestedOplockLevel = *oplock; 306638c8a9a5SSteve French else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) && 306738c8a9a5SSteve French (oparms->create_options & CREATE_NOT_FILE)) 306838c8a9a5SSteve French req->RequestedOplockLevel = *oplock; /* no srv lease support */ 306938c8a9a5SSteve French else { 307038c8a9a5SSteve French rc = add_lease_context(server, req, iov, &n_iov, 307138c8a9a5SSteve French oparms->fid->lease_key, oplock); 307238c8a9a5SSteve French if (rc) 307338c8a9a5SSteve French return rc; 307438c8a9a5SSteve French } 307538c8a9a5SSteve French 307638c8a9a5SSteve French if (*oplock == SMB2_OPLOCK_LEVEL_BATCH) { 307738c8a9a5SSteve French rc = add_durable_context(iov, &n_iov, oparms, 307838c8a9a5SSteve French tcon->use_persistent); 307938c8a9a5SSteve French if (rc) 308038c8a9a5SSteve French return rc; 308138c8a9a5SSteve French } 308238c8a9a5SSteve French 308338c8a9a5SSteve French if (tcon->posix_extensions) { 308438c8a9a5SSteve French rc = add_posix_context(iov, &n_iov, oparms->mode); 308538c8a9a5SSteve French if (rc) 308638c8a9a5SSteve French return rc; 308738c8a9a5SSteve French } 308838c8a9a5SSteve French 308938c8a9a5SSteve French if (tcon->snapshot_time) { 309038c8a9a5SSteve French cifs_dbg(FYI, "adding snapshot context\n"); 309138c8a9a5SSteve French rc = add_twarp_context(iov, &n_iov, tcon->snapshot_time); 309238c8a9a5SSteve French if (rc) 309338c8a9a5SSteve French return rc; 309438c8a9a5SSteve French } 309538c8a9a5SSteve French 309638c8a9a5SSteve French if ((oparms->disposition != FILE_OPEN) && (oparms->cifs_sb)) { 309738c8a9a5SSteve French bool set_mode; 309838c8a9a5SSteve French bool set_owner; 309938c8a9a5SSteve French 310038c8a9a5SSteve French if ((oparms->cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) && 310138c8a9a5SSteve French (oparms->mode != ACL_NO_MODE)) 310238c8a9a5SSteve French set_mode = true; 310338c8a9a5SSteve French else { 310438c8a9a5SSteve French set_mode = false; 310538c8a9a5SSteve French oparms->mode = ACL_NO_MODE; 310638c8a9a5SSteve French } 310738c8a9a5SSteve French 310838c8a9a5SSteve French if (oparms->cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UID_FROM_ACL) 310938c8a9a5SSteve French set_owner = true; 311038c8a9a5SSteve French else 311138c8a9a5SSteve French set_owner = false; 311238c8a9a5SSteve French 311338c8a9a5SSteve French if (set_owner | set_mode) { 311438c8a9a5SSteve French cifs_dbg(FYI, "add sd with mode 0x%x\n", oparms->mode); 311538c8a9a5SSteve French rc = add_sd_context(iov, &n_iov, oparms->mode, set_owner); 311638c8a9a5SSteve French if (rc) 311738c8a9a5SSteve French return rc; 311838c8a9a5SSteve French } 311938c8a9a5SSteve French } 312038c8a9a5SSteve French 312138c8a9a5SSteve French add_query_id_context(iov, &n_iov); 3122df0a8a19SPaulo Alcantara add_ea_context(oparms, iov, &n_iov); 312338c8a9a5SSteve French 312438c8a9a5SSteve French if (n_iov > 2) { 312538c8a9a5SSteve French /* 312638c8a9a5SSteve French * We have create contexts behind iov[1] (the file 312738c8a9a5SSteve French * name), point at them from the main create request 312838c8a9a5SSteve French */ 312938c8a9a5SSteve French req->CreateContextsOffset = cpu_to_le32( 313038c8a9a5SSteve French sizeof(struct smb2_create_req) + 313138c8a9a5SSteve French iov[1].iov_len); 313238c8a9a5SSteve French req->CreateContextsLength = 0; 313338c8a9a5SSteve French 313438c8a9a5SSteve French for (unsigned int i = 2; i < (n_iov-1); i++) { 313538c8a9a5SSteve French struct kvec *v = &iov[i]; 313638c8a9a5SSteve French size_t len = v->iov_len; 313738c8a9a5SSteve French struct create_context *cctx = 313838c8a9a5SSteve French (struct create_context *)v->iov_base; 313938c8a9a5SSteve French 314038c8a9a5SSteve French cctx->Next = cpu_to_le32(len); 314138c8a9a5SSteve French le32_add_cpu(&req->CreateContextsLength, len); 314238c8a9a5SSteve French } 314338c8a9a5SSteve French le32_add_cpu(&req->CreateContextsLength, 314438c8a9a5SSteve French iov[n_iov-1].iov_len); 314538c8a9a5SSteve French } 314638c8a9a5SSteve French 314738c8a9a5SSteve French rqst->rq_nvec = n_iov; 314838c8a9a5SSteve French return 0; 314938c8a9a5SSteve French } 315038c8a9a5SSteve French 315138c8a9a5SSteve French /* rq_iov[0] is the request and is released by cifs_small_buf_release(). 315238c8a9a5SSteve French * All other vectors are freed by kfree(). 315338c8a9a5SSteve French */ 315438c8a9a5SSteve French void 315538c8a9a5SSteve French SMB2_open_free(struct smb_rqst *rqst) 315638c8a9a5SSteve French { 315738c8a9a5SSteve French int i; 315838c8a9a5SSteve French 315938c8a9a5SSteve French if (rqst && rqst->rq_iov) { 316038c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); 316138c8a9a5SSteve French for (i = 1; i < rqst->rq_nvec; i++) 316238c8a9a5SSteve French if (rqst->rq_iov[i].iov_base != smb2_padding) 316338c8a9a5SSteve French kfree(rqst->rq_iov[i].iov_base); 316438c8a9a5SSteve French } 316538c8a9a5SSteve French } 316638c8a9a5SSteve French 316738c8a9a5SSteve French int 316838c8a9a5SSteve French SMB2_open(const unsigned int xid, struct cifs_open_parms *oparms, __le16 *path, 316938c8a9a5SSteve French __u8 *oplock, struct smb2_file_all_info *buf, 317038c8a9a5SSteve French struct create_posix_rsp *posix, 317138c8a9a5SSteve French struct kvec *err_iov, int *buftype) 317238c8a9a5SSteve French { 317338c8a9a5SSteve French struct smb_rqst rqst; 317438c8a9a5SSteve French struct smb2_create_rsp *rsp = NULL; 317538c8a9a5SSteve French struct cifs_tcon *tcon = oparms->tcon; 317638c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 3177433042a9SShyam Prasad N struct TCP_Server_Info *server; 317838c8a9a5SSteve French struct kvec iov[SMB2_CREATE_IOV_SIZE]; 317938c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0}; 318038c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 318138c8a9a5SSteve French int rc = 0; 318238c8a9a5SSteve French int flags = 0; 3183433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 3184433042a9SShyam Prasad N 3185433042a9SShyam Prasad N replay_again: 3186433042a9SShyam Prasad N /* reinitialize for possible replay */ 3187433042a9SShyam Prasad N flags = 0; 3188433042a9SShyam Prasad N server = cifs_pick_channel(ses); 31891b5f2928SSteve French oparms->replay = !!(retries); 319038c8a9a5SSteve French 319138c8a9a5SSteve French cifs_dbg(FYI, "create/open\n"); 319238c8a9a5SSteve French if (!ses || !server) 319338c8a9a5SSteve French return -EIO; 319438c8a9a5SSteve French 319538c8a9a5SSteve French if (smb3_encryption_required(tcon)) 319638c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 319738c8a9a5SSteve French 319838c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 319938c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 320038c8a9a5SSteve French rqst.rq_iov = iov; 320138c8a9a5SSteve French rqst.rq_nvec = SMB2_CREATE_IOV_SIZE; 320238c8a9a5SSteve French 320338c8a9a5SSteve French rc = SMB2_open_init(tcon, server, 320438c8a9a5SSteve French &rqst, oplock, oparms, path); 320538c8a9a5SSteve French if (rc) 320638c8a9a5SSteve French goto creat_exit; 320738c8a9a5SSteve French 320838c8a9a5SSteve French trace_smb3_open_enter(xid, tcon->tid, tcon->ses->Suid, oparms->path, 320938c8a9a5SSteve French oparms->create_options, oparms->desired_access); 321038c8a9a5SSteve French 3211433042a9SShyam Prasad N if (retries) 3212433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 3213433042a9SShyam Prasad N 321438c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 321538c8a9a5SSteve French &rqst, &resp_buftype, flags, 321638c8a9a5SSteve French &rsp_iov); 321738c8a9a5SSteve French rsp = (struct smb2_create_rsp *)rsp_iov.iov_base; 321838c8a9a5SSteve French 321938c8a9a5SSteve French if (rc != 0) { 322038c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_CREATE_HE); 322138c8a9a5SSteve French if (err_iov && rsp) { 322238c8a9a5SSteve French *err_iov = rsp_iov; 322338c8a9a5SSteve French *buftype = resp_buftype; 322438c8a9a5SSteve French resp_buftype = CIFS_NO_BUFFER; 322538c8a9a5SSteve French rsp = NULL; 322638c8a9a5SSteve French } 322738c8a9a5SSteve French trace_smb3_open_err(xid, tcon->tid, ses->Suid, 322838c8a9a5SSteve French oparms->create_options, oparms->desired_access, rc); 322938c8a9a5SSteve French if (rc == -EREMCHG) { 323038c8a9a5SSteve French pr_warn_once("server share %s deleted\n", 323138c8a9a5SSteve French tcon->tree_name); 323238c8a9a5SSteve French tcon->need_reconnect = true; 323338c8a9a5SSteve French } 323438c8a9a5SSteve French goto creat_exit; 323538c8a9a5SSteve French } else if (rsp == NULL) /* unlikely to happen, but safer to check */ 323638c8a9a5SSteve French goto creat_exit; 323738c8a9a5SSteve French else 323838c8a9a5SSteve French trace_smb3_open_done(xid, rsp->PersistentFileId, tcon->tid, ses->Suid, 323938c8a9a5SSteve French oparms->create_options, oparms->desired_access); 324038c8a9a5SSteve French 324138c8a9a5SSteve French atomic_inc(&tcon->num_remote_opens); 324238c8a9a5SSteve French oparms->fid->persistent_fid = rsp->PersistentFileId; 324338c8a9a5SSteve French oparms->fid->volatile_fid = rsp->VolatileFileId; 324438c8a9a5SSteve French oparms->fid->access = oparms->desired_access; 324538c8a9a5SSteve French #ifdef CONFIG_CIFS_DEBUG2 324638c8a9a5SSteve French oparms->fid->mid = le64_to_cpu(rsp->hdr.MessageId); 324738c8a9a5SSteve French #endif /* CIFS_DEBUG2 */ 324838c8a9a5SSteve French 324938c8a9a5SSteve French if (buf) { 325038c8a9a5SSteve French buf->CreationTime = rsp->CreationTime; 325138c8a9a5SSteve French buf->LastAccessTime = rsp->LastAccessTime; 325238c8a9a5SSteve French buf->LastWriteTime = rsp->LastWriteTime; 325338c8a9a5SSteve French buf->ChangeTime = rsp->ChangeTime; 325438c8a9a5SSteve French buf->AllocationSize = rsp->AllocationSize; 325538c8a9a5SSteve French buf->EndOfFile = rsp->EndofFile; 325638c8a9a5SSteve French buf->Attributes = rsp->FileAttributes; 325738c8a9a5SSteve French buf->NumberOfLinks = cpu_to_le32(1); 325838c8a9a5SSteve French buf->DeletePending = 0; 325938c8a9a5SSteve French } 326038c8a9a5SSteve French 326138c8a9a5SSteve French 326217a0f64cSPaulo Alcantara rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch, 326338c8a9a5SSteve French oparms->fid->lease_key, oplock, buf, posix); 326438c8a9a5SSteve French creat_exit: 326538c8a9a5SSteve French SMB2_open_free(&rqst); 326638c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 3267433042a9SShyam Prasad N 3268433042a9SShyam Prasad N if (is_replayable_error(rc) && 3269433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 3270433042a9SShyam Prasad N goto replay_again; 3271433042a9SShyam Prasad N 327238c8a9a5SSteve French return rc; 327338c8a9a5SSteve French } 327438c8a9a5SSteve French 327538c8a9a5SSteve French int 327638c8a9a5SSteve French SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server, 327738c8a9a5SSteve French struct smb_rqst *rqst, 327838c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u32 opcode, 327938c8a9a5SSteve French char *in_data, u32 indatalen, 328038c8a9a5SSteve French __u32 max_response_size) 328138c8a9a5SSteve French { 328238c8a9a5SSteve French struct smb2_ioctl_req *req; 328338c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 328438c8a9a5SSteve French unsigned int total_len; 328538c8a9a5SSteve French int rc; 328638c8a9a5SSteve French char *in_data_buf; 328738c8a9a5SSteve French 328838c8a9a5SSteve French rc = smb2_ioctl_req_init(opcode, tcon, server, 328938c8a9a5SSteve French (void **) &req, &total_len); 329038c8a9a5SSteve French if (rc) 329138c8a9a5SSteve French return rc; 329238c8a9a5SSteve French 329338c8a9a5SSteve French if (indatalen) { 329438c8a9a5SSteve French /* 329538c8a9a5SSteve French * indatalen is usually small at a couple of bytes max, so 329638c8a9a5SSteve French * just allocate through generic pool 329738c8a9a5SSteve French */ 329838c8a9a5SSteve French in_data_buf = kmemdup(in_data, indatalen, GFP_NOFS); 329938c8a9a5SSteve French if (!in_data_buf) { 330038c8a9a5SSteve French cifs_small_buf_release(req); 330138c8a9a5SSteve French return -ENOMEM; 330238c8a9a5SSteve French } 330338c8a9a5SSteve French } 330438c8a9a5SSteve French 330538c8a9a5SSteve French req->CtlCode = cpu_to_le32(opcode); 330638c8a9a5SSteve French req->PersistentFileId = persistent_fid; 330738c8a9a5SSteve French req->VolatileFileId = volatile_fid; 330838c8a9a5SSteve French 330938c8a9a5SSteve French iov[0].iov_base = (char *)req; 331038c8a9a5SSteve French /* 331138c8a9a5SSteve French * If no input data, the size of ioctl struct in 331238c8a9a5SSteve French * protocol spec still includes a 1 byte data buffer, 331338c8a9a5SSteve French * but if input data passed to ioctl, we do not 331438c8a9a5SSteve French * want to double count this, so we do not send 331538c8a9a5SSteve French * the dummy one byte of data in iovec[0] if sending 331638c8a9a5SSteve French * input data (in iovec[1]). 331738c8a9a5SSteve French */ 331838c8a9a5SSteve French if (indatalen) { 331938c8a9a5SSteve French req->InputCount = cpu_to_le32(indatalen); 332038c8a9a5SSteve French /* do not set InputOffset if no input data */ 332138c8a9a5SSteve French req->InputOffset = 332238c8a9a5SSteve French cpu_to_le32(offsetof(struct smb2_ioctl_req, Buffer)); 332338c8a9a5SSteve French rqst->rq_nvec = 2; 332438c8a9a5SSteve French iov[0].iov_len = total_len - 1; 332538c8a9a5SSteve French iov[1].iov_base = in_data_buf; 332638c8a9a5SSteve French iov[1].iov_len = indatalen; 332738c8a9a5SSteve French } else { 332838c8a9a5SSteve French rqst->rq_nvec = 1; 332938c8a9a5SSteve French iov[0].iov_len = total_len; 333038c8a9a5SSteve French } 333138c8a9a5SSteve French 333238c8a9a5SSteve French req->OutputOffset = 0; 333338c8a9a5SSteve French req->OutputCount = 0; /* MBZ */ 333438c8a9a5SSteve French 333538c8a9a5SSteve French /* 333638c8a9a5SSteve French * In most cases max_response_size is set to 16K (CIFSMaxBufSize) 333738c8a9a5SSteve French * We Could increase default MaxOutputResponse, but that could require 333838c8a9a5SSteve French * more credits. Windows typically sets this smaller, but for some 333938c8a9a5SSteve French * ioctls it may be useful to allow server to send more. No point 334038c8a9a5SSteve French * limiting what the server can send as long as fits in one credit 334138c8a9a5SSteve French * We can not handle more than CIFS_MAX_BUF_SIZE yet but may want 334238c8a9a5SSteve French * to increase this limit up in the future. 334338c8a9a5SSteve French * Note that for snapshot queries that servers like Azure expect that 334438c8a9a5SSteve French * the first query be minimal size (and just used to get the number/size 334538c8a9a5SSteve French * of previous versions) so response size must be specified as EXACTLY 334638c8a9a5SSteve French * sizeof(struct snapshot_array) which is 16 when rounded up to multiple 334738c8a9a5SSteve French * of eight bytes. Currently that is the only case where we set max 334838c8a9a5SSteve French * response size smaller. 334938c8a9a5SSteve French */ 335038c8a9a5SSteve French req->MaxOutputResponse = cpu_to_le32(max_response_size); 335138c8a9a5SSteve French req->hdr.CreditCharge = 335238c8a9a5SSteve French cpu_to_le16(DIV_ROUND_UP(max(indatalen, max_response_size), 335338c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE)); 335438c8a9a5SSteve French /* always an FSCTL (for now) */ 335538c8a9a5SSteve French req->Flags = cpu_to_le32(SMB2_0_IOCTL_IS_FSCTL); 335638c8a9a5SSteve French 335738c8a9a5SSteve French /* validate negotiate request must be signed - see MS-SMB2 3.2.5.5 */ 335838c8a9a5SSteve French if (opcode == FSCTL_VALIDATE_NEGOTIATE_INFO) 335938c8a9a5SSteve French req->hdr.Flags |= SMB2_FLAGS_SIGNED; 336038c8a9a5SSteve French 336138c8a9a5SSteve French return 0; 336238c8a9a5SSteve French } 336338c8a9a5SSteve French 336438c8a9a5SSteve French void 336538c8a9a5SSteve French SMB2_ioctl_free(struct smb_rqst *rqst) 336638c8a9a5SSteve French { 336738c8a9a5SSteve French int i; 33682c75426cSSteve French 336938c8a9a5SSteve French if (rqst && rqst->rq_iov) { 337038c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ 337138c8a9a5SSteve French for (i = 1; i < rqst->rq_nvec; i++) 337238c8a9a5SSteve French if (rqst->rq_iov[i].iov_base != smb2_padding) 337338c8a9a5SSteve French kfree(rqst->rq_iov[i].iov_base); 337438c8a9a5SSteve French } 337538c8a9a5SSteve French } 337638c8a9a5SSteve French 337738c8a9a5SSteve French 337838c8a9a5SSteve French /* 337938c8a9a5SSteve French * SMB2 IOCTL is used for both IOCTLs and FSCTLs 338038c8a9a5SSteve French */ 338138c8a9a5SSteve French int 338238c8a9a5SSteve French SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, 338338c8a9a5SSteve French u64 volatile_fid, u32 opcode, char *in_data, u32 indatalen, 338438c8a9a5SSteve French u32 max_out_data_len, char **out_data, 338538c8a9a5SSteve French u32 *plen /* returned data len */) 338638c8a9a5SSteve French { 338738c8a9a5SSteve French struct smb_rqst rqst; 338838c8a9a5SSteve French struct smb2_ioctl_rsp *rsp = NULL; 338938c8a9a5SSteve French struct cifs_ses *ses; 339038c8a9a5SSteve French struct TCP_Server_Info *server; 339138c8a9a5SSteve French struct kvec iov[SMB2_IOCTL_IOV_SIZE]; 339238c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0}; 339338c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 339438c8a9a5SSteve French int rc = 0; 339538c8a9a5SSteve French int flags = 0; 3396433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 3397433042a9SShyam Prasad N 3398433042a9SShyam Prasad N if (!tcon) 3399433042a9SShyam Prasad N return -EIO; 3400433042a9SShyam Prasad N 3401433042a9SShyam Prasad N ses = tcon->ses; 3402433042a9SShyam Prasad N if (!ses) 3403433042a9SShyam Prasad N return -EIO; 3404433042a9SShyam Prasad N 3405433042a9SShyam Prasad N replay_again: 3406433042a9SShyam Prasad N /* reinitialize for possible replay */ 3407433042a9SShyam Prasad N flags = 0; 3408433042a9SShyam Prasad N server = cifs_pick_channel(ses); 3409433042a9SShyam Prasad N 3410433042a9SShyam Prasad N if (!server) 3411433042a9SShyam Prasad N return -EIO; 341238c8a9a5SSteve French 341338c8a9a5SSteve French cifs_dbg(FYI, "SMB2 IOCTL\n"); 341438c8a9a5SSteve French 341538c8a9a5SSteve French if (out_data != NULL) 341638c8a9a5SSteve French *out_data = NULL; 341738c8a9a5SSteve French 341838c8a9a5SSteve French /* zero out returned data len, in case of error */ 341938c8a9a5SSteve French if (plen) 342038c8a9a5SSteve French *plen = 0; 342138c8a9a5SSteve French 342238c8a9a5SSteve French if (smb3_encryption_required(tcon)) 342338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 342438c8a9a5SSteve French 342538c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 342638c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 342738c8a9a5SSteve French rqst.rq_iov = iov; 342838c8a9a5SSteve French rqst.rq_nvec = SMB2_IOCTL_IOV_SIZE; 342938c8a9a5SSteve French 343038c8a9a5SSteve French rc = SMB2_ioctl_init(tcon, server, 343138c8a9a5SSteve French &rqst, persistent_fid, volatile_fid, opcode, 343238c8a9a5SSteve French in_data, indatalen, max_out_data_len); 343338c8a9a5SSteve French if (rc) 343438c8a9a5SSteve French goto ioctl_exit; 343538c8a9a5SSteve French 3436433042a9SShyam Prasad N if (retries) 3437433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 3438433042a9SShyam Prasad N 343938c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 344038c8a9a5SSteve French &rqst, &resp_buftype, flags, 344138c8a9a5SSteve French &rsp_iov); 344238c8a9a5SSteve French rsp = (struct smb2_ioctl_rsp *)rsp_iov.iov_base; 344338c8a9a5SSteve French 344438c8a9a5SSteve French if (rc != 0) 344538c8a9a5SSteve French trace_smb3_fsctl_err(xid, persistent_fid, tcon->tid, 344638c8a9a5SSteve French ses->Suid, 0, opcode, rc); 344738c8a9a5SSteve French 344838c8a9a5SSteve French if ((rc != 0) && (rc != -EINVAL) && (rc != -E2BIG)) { 344938c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 345038c8a9a5SSteve French goto ioctl_exit; 345138c8a9a5SSteve French } else if (rc == -EINVAL) { 345238c8a9a5SSteve French if ((opcode != FSCTL_SRV_COPYCHUNK_WRITE) && 345338c8a9a5SSteve French (opcode != FSCTL_SRV_COPYCHUNK)) { 345438c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 345538c8a9a5SSteve French goto ioctl_exit; 345638c8a9a5SSteve French } 345738c8a9a5SSteve French } else if (rc == -E2BIG) { 345838c8a9a5SSteve French if (opcode != FSCTL_QUERY_ALLOCATED_RANGES) { 345938c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 346038c8a9a5SSteve French goto ioctl_exit; 346138c8a9a5SSteve French } 346238c8a9a5SSteve French } 346338c8a9a5SSteve French 346438c8a9a5SSteve French /* check if caller wants to look at return data or just return rc */ 346538c8a9a5SSteve French if ((plen == NULL) || (out_data == NULL)) 346638c8a9a5SSteve French goto ioctl_exit; 346738c8a9a5SSteve French 346838c8a9a5SSteve French /* 346938c8a9a5SSteve French * Although unlikely to be possible for rsp to be null and rc not set, 347038c8a9a5SSteve French * adding check below is slightly safer long term (and quiets Coverity 347138c8a9a5SSteve French * warning) 347238c8a9a5SSteve French */ 347338c8a9a5SSteve French if (rsp == NULL) { 347438c8a9a5SSteve French rc = -EIO; 347538c8a9a5SSteve French goto ioctl_exit; 347638c8a9a5SSteve French } 347738c8a9a5SSteve French 347838c8a9a5SSteve French *plen = le32_to_cpu(rsp->OutputCount); 347938c8a9a5SSteve French 348038c8a9a5SSteve French /* We check for obvious errors in the output buffer length and offset */ 348138c8a9a5SSteve French if (*plen == 0) 348238c8a9a5SSteve French goto ioctl_exit; /* server returned no data */ 348338c8a9a5SSteve French else if (*plen > rsp_iov.iov_len || *plen > 0xFF00) { 348438c8a9a5SSteve French cifs_tcon_dbg(VFS, "srv returned invalid ioctl length: %d\n", *plen); 348538c8a9a5SSteve French *plen = 0; 348638c8a9a5SSteve French rc = -EIO; 348738c8a9a5SSteve French goto ioctl_exit; 348838c8a9a5SSteve French } 348938c8a9a5SSteve French 349038c8a9a5SSteve French if (rsp_iov.iov_len - *plen < le32_to_cpu(rsp->OutputOffset)) { 349138c8a9a5SSteve French cifs_tcon_dbg(VFS, "Malformed ioctl resp: len %d offset %d\n", *plen, 349238c8a9a5SSteve French le32_to_cpu(rsp->OutputOffset)); 349338c8a9a5SSteve French *plen = 0; 349438c8a9a5SSteve French rc = -EIO; 349538c8a9a5SSteve French goto ioctl_exit; 349638c8a9a5SSteve French } 349738c8a9a5SSteve French 349838c8a9a5SSteve French *out_data = kmemdup((char *)rsp + le32_to_cpu(rsp->OutputOffset), 349938c8a9a5SSteve French *plen, GFP_KERNEL); 350038c8a9a5SSteve French if (*out_data == NULL) { 350138c8a9a5SSteve French rc = -ENOMEM; 350238c8a9a5SSteve French goto ioctl_exit; 350338c8a9a5SSteve French } 350438c8a9a5SSteve French 350538c8a9a5SSteve French ioctl_exit: 350638c8a9a5SSteve French SMB2_ioctl_free(&rqst); 350738c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 3508433042a9SShyam Prasad N 3509433042a9SShyam Prasad N if (is_replayable_error(rc) && 3510433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 3511433042a9SShyam Prasad N goto replay_again; 3512433042a9SShyam Prasad N 351338c8a9a5SSteve French return rc; 351438c8a9a5SSteve French } 351538c8a9a5SSteve French 351638c8a9a5SSteve French /* 351738c8a9a5SSteve French * Individual callers to ioctl worker function follow 351838c8a9a5SSteve French */ 351938c8a9a5SSteve French 352038c8a9a5SSteve French int 352138c8a9a5SSteve French SMB2_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 352238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid) 352338c8a9a5SSteve French { 352438c8a9a5SSteve French int rc; 352538c8a9a5SSteve French struct compress_ioctl fsctl_input; 352638c8a9a5SSteve French char *ret_data = NULL; 352738c8a9a5SSteve French 352838c8a9a5SSteve French fsctl_input.CompressionState = 352938c8a9a5SSteve French cpu_to_le16(COMPRESSION_FORMAT_DEFAULT); 353038c8a9a5SSteve French 353138c8a9a5SSteve French rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid, 353238c8a9a5SSteve French FSCTL_SET_COMPRESSION, 353338c8a9a5SSteve French (char *)&fsctl_input /* data input */, 353438c8a9a5SSteve French 2 /* in data len */, CIFSMaxBufSize /* max out data */, 353538c8a9a5SSteve French &ret_data /* out data */, NULL); 353638c8a9a5SSteve French 353738c8a9a5SSteve French cifs_dbg(FYI, "set compression rc %d\n", rc); 353838c8a9a5SSteve French 353938c8a9a5SSteve French return rc; 354038c8a9a5SSteve French } 354138c8a9a5SSteve French 354238c8a9a5SSteve French int 354338c8a9a5SSteve French SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server, 354438c8a9a5SSteve French struct smb_rqst *rqst, 354538c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, bool query_attrs) 354638c8a9a5SSteve French { 354738c8a9a5SSteve French struct smb2_close_req *req; 354838c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 354938c8a9a5SSteve French unsigned int total_len; 355038c8a9a5SSteve French int rc; 355138c8a9a5SSteve French 355238c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server, 355338c8a9a5SSteve French (void **) &req, &total_len); 355438c8a9a5SSteve French if (rc) 355538c8a9a5SSteve French return rc; 355638c8a9a5SSteve French 355738c8a9a5SSteve French req->PersistentFileId = persistent_fid; 355838c8a9a5SSteve French req->VolatileFileId = volatile_fid; 355938c8a9a5SSteve French if (query_attrs) 356038c8a9a5SSteve French req->Flags = SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB; 356138c8a9a5SSteve French else 356238c8a9a5SSteve French req->Flags = 0; 356338c8a9a5SSteve French iov[0].iov_base = (char *)req; 356438c8a9a5SSteve French iov[0].iov_len = total_len; 356538c8a9a5SSteve French 356638c8a9a5SSteve French return 0; 356738c8a9a5SSteve French } 356838c8a9a5SSteve French 356938c8a9a5SSteve French void 357038c8a9a5SSteve French SMB2_close_free(struct smb_rqst *rqst) 357138c8a9a5SSteve French { 357238c8a9a5SSteve French if (rqst && rqst->rq_iov) 357338c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ 357438c8a9a5SSteve French } 357538c8a9a5SSteve French 357638c8a9a5SSteve French int 357738c8a9a5SSteve French __SMB2_close(const unsigned int xid, struct cifs_tcon *tcon, 357838c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 357938c8a9a5SSteve French struct smb2_file_network_open_info *pbuf) 358038c8a9a5SSteve French { 358138c8a9a5SSteve French struct smb_rqst rqst; 358238c8a9a5SSteve French struct smb2_close_rsp *rsp = NULL; 358338c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 3584433042a9SShyam Prasad N struct TCP_Server_Info *server; 358538c8a9a5SSteve French struct kvec iov[1]; 358638c8a9a5SSteve French struct kvec rsp_iov; 358738c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 358838c8a9a5SSteve French int rc = 0; 358938c8a9a5SSteve French int flags = 0; 359038c8a9a5SSteve French bool query_attrs = false; 3591433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 3592433042a9SShyam Prasad N 3593433042a9SShyam Prasad N replay_again: 3594433042a9SShyam Prasad N /* reinitialize for possible replay */ 3595433042a9SShyam Prasad N flags = 0; 3596433042a9SShyam Prasad N query_attrs = false; 3597433042a9SShyam Prasad N server = cifs_pick_channel(ses); 359838c8a9a5SSteve French 359938c8a9a5SSteve French cifs_dbg(FYI, "Close\n"); 360038c8a9a5SSteve French 360138c8a9a5SSteve French if (!ses || !server) 360238c8a9a5SSteve French return -EIO; 360338c8a9a5SSteve French 360438c8a9a5SSteve French if (smb3_encryption_required(tcon)) 360538c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 360638c8a9a5SSteve French 360738c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 360838c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 360938c8a9a5SSteve French rqst.rq_iov = iov; 361038c8a9a5SSteve French rqst.rq_nvec = 1; 361138c8a9a5SSteve French 361238c8a9a5SSteve French /* check if need to ask server to return timestamps in close response */ 361338c8a9a5SSteve French if (pbuf) 361438c8a9a5SSteve French query_attrs = true; 361538c8a9a5SSteve French 361638c8a9a5SSteve French trace_smb3_close_enter(xid, persistent_fid, tcon->tid, ses->Suid); 361738c8a9a5SSteve French rc = SMB2_close_init(tcon, server, 361838c8a9a5SSteve French &rqst, persistent_fid, volatile_fid, 361938c8a9a5SSteve French query_attrs); 362038c8a9a5SSteve French if (rc) 362138c8a9a5SSteve French goto close_exit; 362238c8a9a5SSteve French 3623433042a9SShyam Prasad N if (retries) 3624433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 3625433042a9SShyam Prasad N 362638c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 362738c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 362838c8a9a5SSteve French rsp = (struct smb2_close_rsp *)rsp_iov.iov_base; 362938c8a9a5SSteve French 363038c8a9a5SSteve French if (rc != 0) { 363138c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_CLOSE_HE); 363238c8a9a5SSteve French trace_smb3_close_err(xid, persistent_fid, tcon->tid, ses->Suid, 363338c8a9a5SSteve French rc); 363438c8a9a5SSteve French goto close_exit; 363538c8a9a5SSteve French } else { 363638c8a9a5SSteve French trace_smb3_close_done(xid, persistent_fid, tcon->tid, 363738c8a9a5SSteve French ses->Suid); 363838c8a9a5SSteve French if (pbuf) 36395ca51814SDmitry Antipov memcpy(&pbuf->network_open_info, 36405ca51814SDmitry Antipov &rsp->network_open_info, 36415ca51814SDmitry Antipov sizeof(pbuf->network_open_info)); 36426f17163bSRitvik Budhiraja atomic_dec(&tcon->num_remote_opens); 364338c8a9a5SSteve French } 364438c8a9a5SSteve French 364538c8a9a5SSteve French close_exit: 364638c8a9a5SSteve French SMB2_close_free(&rqst); 364738c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 364838c8a9a5SSteve French 364938c8a9a5SSteve French /* retry close in a worker thread if this one is interrupted */ 365038c8a9a5SSteve French if (is_interrupt_error(rc)) { 365138c8a9a5SSteve French int tmp_rc; 365238c8a9a5SSteve French 365338c8a9a5SSteve French tmp_rc = smb2_handle_cancelled_close(tcon, persistent_fid, 365438c8a9a5SSteve French volatile_fid); 365538c8a9a5SSteve French if (tmp_rc) 365638c8a9a5SSteve French cifs_dbg(VFS, "handle cancelled close fid 0x%llx returned error %d\n", 365738c8a9a5SSteve French persistent_fid, tmp_rc); 365838c8a9a5SSteve French } 3659433042a9SShyam Prasad N 3660433042a9SShyam Prasad N if (is_replayable_error(rc) && 3661433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 3662433042a9SShyam Prasad N goto replay_again; 3663433042a9SShyam Prasad N 366438c8a9a5SSteve French return rc; 366538c8a9a5SSteve French } 366638c8a9a5SSteve French 366738c8a9a5SSteve French int 366838c8a9a5SSteve French SMB2_close(const unsigned int xid, struct cifs_tcon *tcon, 366938c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid) 367038c8a9a5SSteve French { 367138c8a9a5SSteve French return __SMB2_close(xid, tcon, persistent_fid, volatile_fid, NULL); 367238c8a9a5SSteve French } 367338c8a9a5SSteve French 367438c8a9a5SSteve French int 367538c8a9a5SSteve French smb2_validate_iov(unsigned int offset, unsigned int buffer_length, 367638c8a9a5SSteve French struct kvec *iov, unsigned int min_buf_size) 367738c8a9a5SSteve French { 367838c8a9a5SSteve French unsigned int smb_len = iov->iov_len; 367938c8a9a5SSteve French char *end_of_smb = smb_len + (char *)iov->iov_base; 368038c8a9a5SSteve French char *begin_of_buf = offset + (char *)iov->iov_base; 368138c8a9a5SSteve French char *end_of_buf = begin_of_buf + buffer_length; 368238c8a9a5SSteve French 368338c8a9a5SSteve French 368438c8a9a5SSteve French if (buffer_length < min_buf_size) { 368538c8a9a5SSteve French cifs_dbg(VFS, "buffer length %d smaller than minimum size %d\n", 368638c8a9a5SSteve French buffer_length, min_buf_size); 368738c8a9a5SSteve French return -EINVAL; 368838c8a9a5SSteve French } 368938c8a9a5SSteve French 369038c8a9a5SSteve French /* check if beyond RFC1001 maximum length */ 369138c8a9a5SSteve French if ((smb_len > 0x7FFFFF) || (buffer_length > 0x7FFFFF)) { 369238c8a9a5SSteve French cifs_dbg(VFS, "buffer length %d or smb length %d too large\n", 369338c8a9a5SSteve French buffer_length, smb_len); 369438c8a9a5SSteve French return -EINVAL; 369538c8a9a5SSteve French } 369638c8a9a5SSteve French 369738c8a9a5SSteve French if ((begin_of_buf > end_of_smb) || (end_of_buf > end_of_smb)) { 369838c8a9a5SSteve French cifs_dbg(VFS, "Invalid server response, bad offset to data\n"); 369938c8a9a5SSteve French return -EINVAL; 370038c8a9a5SSteve French } 370138c8a9a5SSteve French 370238c8a9a5SSteve French return 0; 370338c8a9a5SSteve French } 370438c8a9a5SSteve French 370538c8a9a5SSteve French /* 370638c8a9a5SSteve French * If SMB buffer fields are valid, copy into temporary buffer to hold result. 370738c8a9a5SSteve French * Caller must free buffer. 370838c8a9a5SSteve French */ 370938c8a9a5SSteve French int 371038c8a9a5SSteve French smb2_validate_and_copy_iov(unsigned int offset, unsigned int buffer_length, 371138c8a9a5SSteve French struct kvec *iov, unsigned int minbufsize, 371238c8a9a5SSteve French char *data) 371338c8a9a5SSteve French { 371438c8a9a5SSteve French char *begin_of_buf = offset + (char *)iov->iov_base; 371538c8a9a5SSteve French int rc; 371638c8a9a5SSteve French 371738c8a9a5SSteve French if (!data) 371838c8a9a5SSteve French return -EINVAL; 371938c8a9a5SSteve French 372038c8a9a5SSteve French rc = smb2_validate_iov(offset, buffer_length, iov, minbufsize); 372138c8a9a5SSteve French if (rc) 372238c8a9a5SSteve French return rc; 372338c8a9a5SSteve French 372438c8a9a5SSteve French memcpy(data, begin_of_buf, minbufsize); 372538c8a9a5SSteve French 372638c8a9a5SSteve French return 0; 372738c8a9a5SSteve French } 372838c8a9a5SSteve French 372938c8a9a5SSteve French int 373038c8a9a5SSteve French SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server, 373138c8a9a5SSteve French struct smb_rqst *rqst, 373238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 373338c8a9a5SSteve French u8 info_class, u8 info_type, u32 additional_info, 373438c8a9a5SSteve French size_t output_len, size_t input_len, void *input) 373538c8a9a5SSteve French { 373638c8a9a5SSteve French struct smb2_query_info_req *req; 373738c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 373838c8a9a5SSteve French unsigned int total_len; 37393b5f0d0aSPaulo Alcantara size_t len; 374038c8a9a5SSteve French int rc; 374138c8a9a5SSteve French 37423b5f0d0aSPaulo Alcantara if (unlikely(check_add_overflow(input_len, sizeof(*req), &len) || 37433b5f0d0aSPaulo Alcantara len > CIFSMaxBufSize)) 37443b5f0d0aSPaulo Alcantara return -EINVAL; 37453b5f0d0aSPaulo Alcantara 374638c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server, 374738c8a9a5SSteve French (void **) &req, &total_len); 374838c8a9a5SSteve French if (rc) 374938c8a9a5SSteve French return rc; 375038c8a9a5SSteve French 375138c8a9a5SSteve French req->InfoType = info_type; 375238c8a9a5SSteve French req->FileInfoClass = info_class; 375338c8a9a5SSteve French req->PersistentFileId = persistent_fid; 375438c8a9a5SSteve French req->VolatileFileId = volatile_fid; 375538c8a9a5SSteve French req->AdditionalInformation = cpu_to_le32(additional_info); 375638c8a9a5SSteve French 375738c8a9a5SSteve French req->OutputBufferLength = cpu_to_le32(output_len); 375838c8a9a5SSteve French if (input_len) { 375938c8a9a5SSteve French req->InputBufferLength = cpu_to_le32(input_len); 376038c8a9a5SSteve French /* total_len for smb query request never close to le16 max */ 376138c8a9a5SSteve French req->InputBufferOffset = cpu_to_le16(total_len - 1); 376238c8a9a5SSteve French memcpy(req->Buffer, input, input_len); 376338c8a9a5SSteve French } 376438c8a9a5SSteve French 376538c8a9a5SSteve French iov[0].iov_base = (char *)req; 376638c8a9a5SSteve French /* 1 for Buffer */ 37673b5f0d0aSPaulo Alcantara iov[0].iov_len = len; 376838c8a9a5SSteve French return 0; 376938c8a9a5SSteve French } 377038c8a9a5SSteve French 377138c8a9a5SSteve French void 377238c8a9a5SSteve French SMB2_query_info_free(struct smb_rqst *rqst) 377338c8a9a5SSteve French { 377438c8a9a5SSteve French if (rqst && rqst->rq_iov) 37753b5f0d0aSPaulo Alcantara cifs_buf_release(rqst->rq_iov[0].iov_base); /* request */ 377638c8a9a5SSteve French } 377738c8a9a5SSteve French 377838c8a9a5SSteve French static int 377938c8a9a5SSteve French query_info(const unsigned int xid, struct cifs_tcon *tcon, 378038c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u8 info_class, u8 info_type, 378138c8a9a5SSteve French u32 additional_info, size_t output_len, size_t min_len, void **data, 378238c8a9a5SSteve French u32 *dlen) 378338c8a9a5SSteve French { 378438c8a9a5SSteve French struct smb_rqst rqst; 378538c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL; 378638c8a9a5SSteve French struct kvec iov[1]; 378738c8a9a5SSteve French struct kvec rsp_iov; 378838c8a9a5SSteve French int rc = 0; 378938c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 379038c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 379138c8a9a5SSteve French struct TCP_Server_Info *server; 379238c8a9a5SSteve French int flags = 0; 379338c8a9a5SSteve French bool allocated = false; 3794433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 379538c8a9a5SSteve French 379638c8a9a5SSteve French cifs_dbg(FYI, "Query Info\n"); 379738c8a9a5SSteve French 379838c8a9a5SSteve French if (!ses) 379938c8a9a5SSteve French return -EIO; 3800433042a9SShyam Prasad N 3801433042a9SShyam Prasad N replay_again: 3802433042a9SShyam Prasad N /* reinitialize for possible replay */ 3803433042a9SShyam Prasad N flags = 0; 3804433042a9SShyam Prasad N allocated = false; 380538c8a9a5SSteve French server = cifs_pick_channel(ses); 3806433042a9SShyam Prasad N 380738c8a9a5SSteve French if (!server) 380838c8a9a5SSteve French return -EIO; 380938c8a9a5SSteve French 381038c8a9a5SSteve French if (smb3_encryption_required(tcon)) 381138c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 381238c8a9a5SSteve French 381338c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 381438c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 381538c8a9a5SSteve French rqst.rq_iov = iov; 381638c8a9a5SSteve French rqst.rq_nvec = 1; 381738c8a9a5SSteve French 381838c8a9a5SSteve French rc = SMB2_query_info_init(tcon, server, 381938c8a9a5SSteve French &rqst, persistent_fid, volatile_fid, 382038c8a9a5SSteve French info_class, info_type, additional_info, 382138c8a9a5SSteve French output_len, 0, NULL); 382238c8a9a5SSteve French if (rc) 382338c8a9a5SSteve French goto qinf_exit; 382438c8a9a5SSteve French 382538c8a9a5SSteve French trace_smb3_query_info_enter(xid, persistent_fid, tcon->tid, 382638c8a9a5SSteve French ses->Suid, info_class, (__u32)info_type); 382738c8a9a5SSteve French 3828433042a9SShyam Prasad N if (retries) 3829433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 3830433042a9SShyam Prasad N 383138c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 383238c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 383338c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base; 383438c8a9a5SSteve French 383538c8a9a5SSteve French if (rc) { 383638c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE); 383738c8a9a5SSteve French trace_smb3_query_info_err(xid, persistent_fid, tcon->tid, 383838c8a9a5SSteve French ses->Suid, info_class, (__u32)info_type, rc); 383938c8a9a5SSteve French goto qinf_exit; 384038c8a9a5SSteve French } 384138c8a9a5SSteve French 384238c8a9a5SSteve French trace_smb3_query_info_done(xid, persistent_fid, tcon->tid, 384338c8a9a5SSteve French ses->Suid, info_class, (__u32)info_type); 384438c8a9a5SSteve French 384538c8a9a5SSteve French if (dlen) { 384638c8a9a5SSteve French *dlen = le32_to_cpu(rsp->OutputBufferLength); 384738c8a9a5SSteve French if (!*data) { 384838c8a9a5SSteve French *data = kmalloc(*dlen, GFP_KERNEL); 384938c8a9a5SSteve French if (!*data) { 385038c8a9a5SSteve French cifs_tcon_dbg(VFS, 385138c8a9a5SSteve French "Error %d allocating memory for acl\n", 385238c8a9a5SSteve French rc); 385338c8a9a5SSteve French *dlen = 0; 385438c8a9a5SSteve French rc = -ENOMEM; 385538c8a9a5SSteve French goto qinf_exit; 385638c8a9a5SSteve French } 385738c8a9a5SSteve French allocated = true; 385838c8a9a5SSteve French } 385938c8a9a5SSteve French } 386038c8a9a5SSteve French 386138c8a9a5SSteve French rc = smb2_validate_and_copy_iov(le16_to_cpu(rsp->OutputBufferOffset), 386238c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), 386338c8a9a5SSteve French &rsp_iov, dlen ? *dlen : min_len, *data); 386438c8a9a5SSteve French if (rc && allocated) { 386538c8a9a5SSteve French kfree(*data); 386638c8a9a5SSteve French *data = NULL; 386738c8a9a5SSteve French *dlen = 0; 386838c8a9a5SSteve French } 386938c8a9a5SSteve French 387038c8a9a5SSteve French qinf_exit: 387138c8a9a5SSteve French SMB2_query_info_free(&rqst); 387238c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 3873433042a9SShyam Prasad N 3874433042a9SShyam Prasad N if (is_replayable_error(rc) && 3875433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 3876433042a9SShyam Prasad N goto replay_again; 3877433042a9SShyam Prasad N 387838c8a9a5SSteve French return rc; 387938c8a9a5SSteve French } 388038c8a9a5SSteve French 388138c8a9a5SSteve French int SMB2_query_info(const unsigned int xid, struct cifs_tcon *tcon, 388238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct smb2_file_all_info *data) 388338c8a9a5SSteve French { 388438c8a9a5SSteve French return query_info(xid, tcon, persistent_fid, volatile_fid, 388538c8a9a5SSteve French FILE_ALL_INFORMATION, SMB2_O_INFO_FILE, 0, 388638c8a9a5SSteve French sizeof(struct smb2_file_all_info) + PATH_MAX * 2, 388738c8a9a5SSteve French sizeof(struct smb2_file_all_info), (void **)&data, 388838c8a9a5SSteve French NULL); 388938c8a9a5SSteve French } 389038c8a9a5SSteve French 389138c8a9a5SSteve French #if 0 389238c8a9a5SSteve French /* currently unused, as now we are doing compounding instead (see smb311_posix_query_path_info) */ 389338c8a9a5SSteve French int 389438c8a9a5SSteve French SMB311_posix_query_info(const unsigned int xid, struct cifs_tcon *tcon, 389538c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct smb311_posix_qinfo *data, u32 *plen) 389638c8a9a5SSteve French { 389738c8a9a5SSteve French size_t output_len = sizeof(struct smb311_posix_qinfo *) + 389838c8a9a5SSteve French (sizeof(struct cifs_sid) * 2) + (PATH_MAX * 2); 389938c8a9a5SSteve French *plen = 0; 390038c8a9a5SSteve French 390138c8a9a5SSteve French return query_info(xid, tcon, persistent_fid, volatile_fid, 390238c8a9a5SSteve French SMB_FIND_FILE_POSIX_INFO, SMB2_O_INFO_FILE, 0, 390338c8a9a5SSteve French output_len, sizeof(struct smb311_posix_qinfo), (void **)&data, plen); 390438c8a9a5SSteve French /* Note caller must free "data" (passed in above). It may be allocated in query_info call */ 390538c8a9a5SSteve French } 390638c8a9a5SSteve French #endif 390738c8a9a5SSteve French 390838c8a9a5SSteve French int 390938c8a9a5SSteve French SMB2_query_acl(const unsigned int xid, struct cifs_tcon *tcon, 391038c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 391138c8a9a5SSteve French void **data, u32 *plen, u32 extra_info) 391238c8a9a5SSteve French { 391338c8a9a5SSteve French __u32 additional_info = OWNER_SECINFO | GROUP_SECINFO | DACL_SECINFO | 391438c8a9a5SSteve French extra_info; 391538c8a9a5SSteve French *plen = 0; 391638c8a9a5SSteve French 391738c8a9a5SSteve French return query_info(xid, tcon, persistent_fid, volatile_fid, 391838c8a9a5SSteve French 0, SMB2_O_INFO_SECURITY, additional_info, 391938c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE, MIN_SEC_DESC_LEN, data, plen); 392038c8a9a5SSteve French } 392138c8a9a5SSteve French 392238c8a9a5SSteve French int 392338c8a9a5SSteve French SMB2_get_srv_num(const unsigned int xid, struct cifs_tcon *tcon, 392438c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, __le64 *uniqueid) 392538c8a9a5SSteve French { 392638c8a9a5SSteve French return query_info(xid, tcon, persistent_fid, volatile_fid, 392738c8a9a5SSteve French FILE_INTERNAL_INFORMATION, SMB2_O_INFO_FILE, 0, 392838c8a9a5SSteve French sizeof(struct smb2_file_internal_info), 392938c8a9a5SSteve French sizeof(struct smb2_file_internal_info), 393038c8a9a5SSteve French (void **)&uniqueid, NULL); 393138c8a9a5SSteve French } 393238c8a9a5SSteve French 393338c8a9a5SSteve French /* 393438c8a9a5SSteve French * CHANGE_NOTIFY Request is sent to get notifications on changes to a directory 393538c8a9a5SSteve French * See MS-SMB2 2.2.35 and 2.2.36 393638c8a9a5SSteve French */ 393738c8a9a5SSteve French 393838c8a9a5SSteve French static int 393938c8a9a5SSteve French SMB2_notify_init(const unsigned int xid, struct smb_rqst *rqst, 394038c8a9a5SSteve French struct cifs_tcon *tcon, struct TCP_Server_Info *server, 394138c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 394238c8a9a5SSteve French u32 completion_filter, bool watch_tree) 394338c8a9a5SSteve French { 394438c8a9a5SSteve French struct smb2_change_notify_req *req; 394538c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 394638c8a9a5SSteve French unsigned int total_len; 394738c8a9a5SSteve French int rc; 394838c8a9a5SSteve French 394938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server, 395038c8a9a5SSteve French (void **) &req, &total_len); 395138c8a9a5SSteve French if (rc) 395238c8a9a5SSteve French return rc; 395338c8a9a5SSteve French 395438c8a9a5SSteve French req->PersistentFileId = persistent_fid; 395538c8a9a5SSteve French req->VolatileFileId = volatile_fid; 395638c8a9a5SSteve French /* See note 354 of MS-SMB2, 64K max */ 395738c8a9a5SSteve French req->OutputBufferLength = 395838c8a9a5SSteve French cpu_to_le32(SMB2_MAX_BUFFER_SIZE - MAX_SMB2_HDR_SIZE); 395938c8a9a5SSteve French req->CompletionFilter = cpu_to_le32(completion_filter); 396038c8a9a5SSteve French if (watch_tree) 396138c8a9a5SSteve French req->Flags = cpu_to_le16(SMB2_WATCH_TREE); 396238c8a9a5SSteve French else 396338c8a9a5SSteve French req->Flags = 0; 396438c8a9a5SSteve French 396538c8a9a5SSteve French iov[0].iov_base = (char *)req; 396638c8a9a5SSteve French iov[0].iov_len = total_len; 396738c8a9a5SSteve French 396838c8a9a5SSteve French return 0; 396938c8a9a5SSteve French } 397038c8a9a5SSteve French 397138c8a9a5SSteve French int 397238c8a9a5SSteve French SMB2_change_notify(const unsigned int xid, struct cifs_tcon *tcon, 397338c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, bool watch_tree, 397438c8a9a5SSteve French u32 completion_filter, u32 max_out_data_len, char **out_data, 397538c8a9a5SSteve French u32 *plen /* returned data len */) 397638c8a9a5SSteve French { 397738c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 3978433042a9SShyam Prasad N struct TCP_Server_Info *server; 397938c8a9a5SSteve French struct smb_rqst rqst; 398038c8a9a5SSteve French struct smb2_change_notify_rsp *smb_rsp; 398138c8a9a5SSteve French struct kvec iov[1]; 398238c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0}; 398338c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 398438c8a9a5SSteve French int flags = 0; 398538c8a9a5SSteve French int rc = 0; 3986433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 3987433042a9SShyam Prasad N 3988433042a9SShyam Prasad N replay_again: 3989433042a9SShyam Prasad N /* reinitialize for possible replay */ 3990433042a9SShyam Prasad N flags = 0; 3991433042a9SShyam Prasad N server = cifs_pick_channel(ses); 399238c8a9a5SSteve French 399338c8a9a5SSteve French cifs_dbg(FYI, "change notify\n"); 399438c8a9a5SSteve French if (!ses || !server) 399538c8a9a5SSteve French return -EIO; 399638c8a9a5SSteve French 399738c8a9a5SSteve French if (smb3_encryption_required(tcon)) 399838c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 399938c8a9a5SSteve French 400038c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 400138c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 400238c8a9a5SSteve French if (plen) 400338c8a9a5SSteve French *plen = 0; 400438c8a9a5SSteve French 400538c8a9a5SSteve French rqst.rq_iov = iov; 400638c8a9a5SSteve French rqst.rq_nvec = 1; 400738c8a9a5SSteve French 400838c8a9a5SSteve French rc = SMB2_notify_init(xid, &rqst, tcon, server, 400938c8a9a5SSteve French persistent_fid, volatile_fid, 401038c8a9a5SSteve French completion_filter, watch_tree); 401138c8a9a5SSteve French if (rc) 401238c8a9a5SSteve French goto cnotify_exit; 401338c8a9a5SSteve French 401438c8a9a5SSteve French trace_smb3_notify_enter(xid, persistent_fid, tcon->tid, ses->Suid, 401538c8a9a5SSteve French (u8)watch_tree, completion_filter); 4016433042a9SShyam Prasad N 4017433042a9SShyam Prasad N if (retries) 4018433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 4019433042a9SShyam Prasad N 402038c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 402138c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 402238c8a9a5SSteve French 402338c8a9a5SSteve French if (rc != 0) { 402438c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_CHANGE_NOTIFY_HE); 402538c8a9a5SSteve French trace_smb3_notify_err(xid, persistent_fid, tcon->tid, ses->Suid, 402638c8a9a5SSteve French (u8)watch_tree, completion_filter, rc); 402738c8a9a5SSteve French } else { 402838c8a9a5SSteve French trace_smb3_notify_done(xid, persistent_fid, tcon->tid, 402938c8a9a5SSteve French ses->Suid, (u8)watch_tree, completion_filter); 403038c8a9a5SSteve French /* validate that notify information is plausible */ 403138c8a9a5SSteve French if ((rsp_iov.iov_base == NULL) || 403238c8a9a5SSteve French (rsp_iov.iov_len < sizeof(struct smb2_change_notify_rsp) + 1)) 403338c8a9a5SSteve French goto cnotify_exit; 403438c8a9a5SSteve French 403538c8a9a5SSteve French smb_rsp = (struct smb2_change_notify_rsp *)rsp_iov.iov_base; 403638c8a9a5SSteve French 403738c8a9a5SSteve French smb2_validate_iov(le16_to_cpu(smb_rsp->OutputBufferOffset), 403838c8a9a5SSteve French le32_to_cpu(smb_rsp->OutputBufferLength), &rsp_iov, 403938c8a9a5SSteve French sizeof(struct file_notify_information)); 404038c8a9a5SSteve French 404138c8a9a5SSteve French *out_data = kmemdup((char *)smb_rsp + le16_to_cpu(smb_rsp->OutputBufferOffset), 404238c8a9a5SSteve French le32_to_cpu(smb_rsp->OutputBufferLength), GFP_KERNEL); 404338c8a9a5SSteve French if (*out_data == NULL) { 404438c8a9a5SSteve French rc = -ENOMEM; 404538c8a9a5SSteve French goto cnotify_exit; 4046b535cc79SSteve French } else if (plen) 404738c8a9a5SSteve French *plen = le32_to_cpu(smb_rsp->OutputBufferLength); 404838c8a9a5SSteve French } 404938c8a9a5SSteve French 405038c8a9a5SSteve French cnotify_exit: 405138c8a9a5SSteve French if (rqst.rq_iov) 405238c8a9a5SSteve French cifs_small_buf_release(rqst.rq_iov[0].iov_base); /* request */ 405338c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 4054433042a9SShyam Prasad N 4055433042a9SShyam Prasad N if (is_replayable_error(rc) && 4056433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 4057433042a9SShyam Prasad N goto replay_again; 4058433042a9SShyam Prasad N 405938c8a9a5SSteve French return rc; 406038c8a9a5SSteve French } 406138c8a9a5SSteve French 406238c8a9a5SSteve French 406338c8a9a5SSteve French 406438c8a9a5SSteve French /* 406538c8a9a5SSteve French * This is a no-op for now. We're not really interested in the reply, but 406638c8a9a5SSteve French * rather in the fact that the server sent one and that server->lstrp 406738c8a9a5SSteve French * gets updated. 406838c8a9a5SSteve French * 406938c8a9a5SSteve French * FIXME: maybe we should consider checking that the reply matches request? 407038c8a9a5SSteve French */ 407138c8a9a5SSteve French static void 407238c8a9a5SSteve French smb2_echo_callback(struct mid_q_entry *mid) 407338c8a9a5SSteve French { 407438c8a9a5SSteve French struct TCP_Server_Info *server = mid->callback_data; 407538c8a9a5SSteve French struct smb2_echo_rsp *rsp = (struct smb2_echo_rsp *)mid->resp_buf; 407638c8a9a5SSteve French struct cifs_credits credits = { .value = 0, .instance = 0 }; 407738c8a9a5SSteve French 407838c8a9a5SSteve French if (mid->mid_state == MID_RESPONSE_RECEIVED 407938c8a9a5SSteve French || mid->mid_state == MID_RESPONSE_MALFORMED) { 408038c8a9a5SSteve French credits.value = le16_to_cpu(rsp->hdr.CreditRequest); 408138c8a9a5SSteve French credits.instance = server->reconnect_instance; 408238c8a9a5SSteve French } 408338c8a9a5SSteve French 408438c8a9a5SSteve French release_mid(mid); 408538c8a9a5SSteve French add_credits(server, &credits, CIFS_ECHO_OP); 408638c8a9a5SSteve French } 408738c8a9a5SSteve French 408838c8a9a5SSteve French void smb2_reconnect_server(struct work_struct *work) 408938c8a9a5SSteve French { 409038c8a9a5SSteve French struct TCP_Server_Info *server = container_of(work, 409138c8a9a5SSteve French struct TCP_Server_Info, reconnect.work); 409238c8a9a5SSteve French struct TCP_Server_Info *pserver; 409338c8a9a5SSteve French struct cifs_ses *ses, *ses2; 409438c8a9a5SSteve French struct cifs_tcon *tcon, *tcon2; 409538c8a9a5SSteve French struct list_head tmp_list, tmp_ses_list; 40968358f46bSColin Ian King bool ses_exist = false; 409738c8a9a5SSteve French bool tcon_selected = false; 409838c8a9a5SSteve French int rc; 409938c8a9a5SSteve French bool resched = false; 410038c8a9a5SSteve French 410107e86408SShyam Prasad N /* first check if ref count has reached 0, if not inc ref count */ 410207e86408SShyam Prasad N spin_lock(&cifs_tcp_ses_lock); 410307e86408SShyam Prasad N if (!server->srv_count) { 410407e86408SShyam Prasad N spin_unlock(&cifs_tcp_ses_lock); 410507e86408SShyam Prasad N return; 410607e86408SShyam Prasad N } 410707e86408SShyam Prasad N server->srv_count++; 410807e86408SShyam Prasad N spin_unlock(&cifs_tcp_ses_lock); 410907e86408SShyam Prasad N 411038c8a9a5SSteve French /* If server is a channel, select the primary channel */ 4111b3773b19SSteve French pserver = SERVER_IS_CHAN(server) ? server->primary_server : server; 411238c8a9a5SSteve French 411338c8a9a5SSteve French /* Prevent simultaneous reconnects that can corrupt tcon->rlist list */ 411438c8a9a5SSteve French mutex_lock(&pserver->reconnect_mutex); 411538c8a9a5SSteve French 41163e161536SShyam Prasad N /* if the server is marked for termination, drop the ref count here */ 41173e161536SShyam Prasad N if (server->terminate) { 41183e161536SShyam Prasad N cifs_put_tcp_session(server, true); 41193e161536SShyam Prasad N mutex_unlock(&pserver->reconnect_mutex); 41203e161536SShyam Prasad N return; 41213e161536SShyam Prasad N } 41223e161536SShyam Prasad N 412338c8a9a5SSteve French INIT_LIST_HEAD(&tmp_list); 412438c8a9a5SSteve French INIT_LIST_HEAD(&tmp_ses_list); 412538c8a9a5SSteve French cifs_dbg(FYI, "Reconnecting tcons and channels\n"); 412638c8a9a5SSteve French 412738c8a9a5SSteve French spin_lock(&cifs_tcp_ses_lock); 412838c8a9a5SSteve French list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) { 412999f28070SWinston Wen spin_lock(&ses->ses_lock); 413099f28070SWinston Wen if (ses->ses_status == SES_EXITING) { 413199f28070SWinston Wen spin_unlock(&ses->ses_lock); 413299f28070SWinston Wen continue; 413399f28070SWinston Wen } 413499f28070SWinston Wen spin_unlock(&ses->ses_lock); 413538c8a9a5SSteve French 413638c8a9a5SSteve French tcon_selected = false; 413738c8a9a5SSteve French 413838c8a9a5SSteve French list_for_each_entry(tcon, &ses->tcon_list, tcon_list) { 413938c8a9a5SSteve French if (tcon->need_reconnect || tcon->need_reopen_files) { 414038c8a9a5SSteve French tcon->tc_count++; 414138c8a9a5SSteve French list_add_tail(&tcon->rlist, &tmp_list); 41428358f46bSColin Ian King tcon_selected = true; 414338c8a9a5SSteve French } 414438c8a9a5SSteve French } 414538c8a9a5SSteve French /* 414638c8a9a5SSteve French * IPC has the same lifetime as its session and uses its 414738c8a9a5SSteve French * refcount. 414838c8a9a5SSteve French */ 414938c8a9a5SSteve French if (ses->tcon_ipc && ses->tcon_ipc->need_reconnect) { 415038c8a9a5SSteve French list_add_tail(&ses->tcon_ipc->rlist, &tmp_list); 41518358f46bSColin Ian King tcon_selected = true; 415238c8a9a5SSteve French cifs_smb_ses_inc_refcount(ses); 415338c8a9a5SSteve French } 415438c8a9a5SSteve French /* 415538c8a9a5SSteve French * handle the case where channel needs to reconnect 415638c8a9a5SSteve French * binding session, but tcon is healthy (some other channel 415738c8a9a5SSteve French * is active) 415838c8a9a5SSteve French */ 415938c8a9a5SSteve French spin_lock(&ses->chan_lock); 416038c8a9a5SSteve French if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) { 416138c8a9a5SSteve French list_add_tail(&ses->rlist, &tmp_ses_list); 416238c8a9a5SSteve French ses_exist = true; 416338c8a9a5SSteve French cifs_smb_ses_inc_refcount(ses); 416438c8a9a5SSteve French } 416538c8a9a5SSteve French spin_unlock(&ses->chan_lock); 416638c8a9a5SSteve French } 416738c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock); 416838c8a9a5SSteve French 416938c8a9a5SSteve French list_for_each_entry_safe(tcon, tcon2, &tmp_list, rlist) { 417007e86408SShyam Prasad N rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true); 417138c8a9a5SSteve French if (!rc) 417238c8a9a5SSteve French cifs_reopen_persistent_handles(tcon); 417338c8a9a5SSteve French else 417438c8a9a5SSteve French resched = true; 417538c8a9a5SSteve French list_del_init(&tcon->rlist); 417638c8a9a5SSteve French if (tcon->ipc) 417738c8a9a5SSteve French cifs_put_smb_ses(tcon->ses); 417838c8a9a5SSteve French else 417938c8a9a5SSteve French cifs_put_tcon(tcon); 418038c8a9a5SSteve French } 418138c8a9a5SSteve French 418238c8a9a5SSteve French if (!ses_exist) 418338c8a9a5SSteve French goto done; 418438c8a9a5SSteve French 418538c8a9a5SSteve French /* allocate a dummy tcon struct used for reconnect */ 41862da338ffSSteve French tcon = tcon_info_alloc(false); 418738c8a9a5SSteve French if (!tcon) { 418838c8a9a5SSteve French resched = true; 418938c8a9a5SSteve French list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) { 419038c8a9a5SSteve French list_del_init(&ses->rlist); 419138c8a9a5SSteve French cifs_put_smb_ses(ses); 419238c8a9a5SSteve French } 419338c8a9a5SSteve French goto done; 419438c8a9a5SSteve French } 419538c8a9a5SSteve French 419638c8a9a5SSteve French tcon->status = TID_GOOD; 419738c8a9a5SSteve French tcon->retry = false; 419838c8a9a5SSteve French tcon->need_reconnect = false; 419938c8a9a5SSteve French 420038c8a9a5SSteve French /* now reconnect sessions for necessary channels */ 420138c8a9a5SSteve French list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) { 420238c8a9a5SSteve French tcon->ses = ses; 420307e86408SShyam Prasad N rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true); 420438c8a9a5SSteve French if (rc) 420538c8a9a5SSteve French resched = true; 420638c8a9a5SSteve French list_del_init(&ses->rlist); 420738c8a9a5SSteve French cifs_put_smb_ses(ses); 420838c8a9a5SSteve French } 420938c8a9a5SSteve French tconInfoFree(tcon); 421038c8a9a5SSteve French 421138c8a9a5SSteve French done: 421238c8a9a5SSteve French cifs_dbg(FYI, "Reconnecting tcons and channels finished\n"); 42133a0ef868SShyam Prasad N if (resched) 421438c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ); 421538c8a9a5SSteve French mutex_unlock(&pserver->reconnect_mutex); 421638c8a9a5SSteve French 421738c8a9a5SSteve French /* now we can safely release srv struct */ 421807e86408SShyam Prasad N cifs_put_tcp_session(server, true); 421938c8a9a5SSteve French } 422038c8a9a5SSteve French 422138c8a9a5SSteve French int 422238c8a9a5SSteve French SMB2_echo(struct TCP_Server_Info *server) 422338c8a9a5SSteve French { 422438c8a9a5SSteve French struct smb2_echo_req *req; 422538c8a9a5SSteve French int rc = 0; 422638c8a9a5SSteve French struct kvec iov[1]; 422738c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = iov, 422838c8a9a5SSteve French .rq_nvec = 1 }; 422938c8a9a5SSteve French unsigned int total_len; 423038c8a9a5SSteve French 423138c8a9a5SSteve French cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id); 423238c8a9a5SSteve French 423338c8a9a5SSteve French spin_lock(&server->srv_lock); 423438c8a9a5SSteve French if (server->ops->need_neg && 423538c8a9a5SSteve French server->ops->need_neg(server)) { 423638c8a9a5SSteve French spin_unlock(&server->srv_lock); 423738c8a9a5SSteve French /* No need to send echo on newly established connections */ 42383a0ef868SShyam Prasad N mod_delayed_work(cifsiod_wq, &server->reconnect, 0); 423938c8a9a5SSteve French return rc; 424038c8a9a5SSteve French } 424138c8a9a5SSteve French spin_unlock(&server->srv_lock); 424238c8a9a5SSteve French 424338c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_ECHO, NULL, server, 424438c8a9a5SSteve French (void **)&req, &total_len); 424538c8a9a5SSteve French if (rc) 424638c8a9a5SSteve French return rc; 424738c8a9a5SSteve French 424838c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1); 424938c8a9a5SSteve French 425038c8a9a5SSteve French iov[0].iov_len = total_len; 425138c8a9a5SSteve French iov[0].iov_base = (char *)req; 425238c8a9a5SSteve French 425338c8a9a5SSteve French rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL, 425438c8a9a5SSteve French server, CIFS_ECHO_OP, NULL); 425538c8a9a5SSteve French if (rc) 425638c8a9a5SSteve French cifs_dbg(FYI, "Echo request failed: %d\n", rc); 425738c8a9a5SSteve French 425838c8a9a5SSteve French cifs_small_buf_release(req); 425938c8a9a5SSteve French return rc; 426038c8a9a5SSteve French } 426138c8a9a5SSteve French 426238c8a9a5SSteve French void 426338c8a9a5SSteve French SMB2_flush_free(struct smb_rqst *rqst) 426438c8a9a5SSteve French { 426538c8a9a5SSteve French if (rqst && rqst->rq_iov) 426638c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ 426738c8a9a5SSteve French } 426838c8a9a5SSteve French 426938c8a9a5SSteve French int 427038c8a9a5SSteve French SMB2_flush_init(const unsigned int xid, struct smb_rqst *rqst, 427138c8a9a5SSteve French struct cifs_tcon *tcon, struct TCP_Server_Info *server, 427238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid) 427338c8a9a5SSteve French { 427438c8a9a5SSteve French struct smb2_flush_req *req; 427538c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 427638c8a9a5SSteve French unsigned int total_len; 427738c8a9a5SSteve French int rc; 427838c8a9a5SSteve French 427938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server, 428038c8a9a5SSteve French (void **) &req, &total_len); 428138c8a9a5SSteve French if (rc) 428238c8a9a5SSteve French return rc; 428338c8a9a5SSteve French 428438c8a9a5SSteve French req->PersistentFileId = persistent_fid; 428538c8a9a5SSteve French req->VolatileFileId = volatile_fid; 428638c8a9a5SSteve French 428738c8a9a5SSteve French iov[0].iov_base = (char *)req; 428838c8a9a5SSteve French iov[0].iov_len = total_len; 428938c8a9a5SSteve French 429038c8a9a5SSteve French return 0; 429138c8a9a5SSteve French } 429238c8a9a5SSteve French 429338c8a9a5SSteve French int 429438c8a9a5SSteve French SMB2_flush(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, 429538c8a9a5SSteve French u64 volatile_fid) 429638c8a9a5SSteve French { 429738c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 429838c8a9a5SSteve French struct smb_rqst rqst; 429938c8a9a5SSteve French struct kvec iov[1]; 430038c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0}; 4301433042a9SShyam Prasad N struct TCP_Server_Info *server; 430238c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 430338c8a9a5SSteve French int flags = 0; 430438c8a9a5SSteve French int rc = 0; 4305433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 4306433042a9SShyam Prasad N 4307433042a9SShyam Prasad N replay_again: 4308433042a9SShyam Prasad N /* reinitialize for possible replay */ 4309433042a9SShyam Prasad N flags = 0; 4310433042a9SShyam Prasad N server = cifs_pick_channel(ses); 431138c8a9a5SSteve French 431238c8a9a5SSteve French cifs_dbg(FYI, "flush\n"); 431338c8a9a5SSteve French if (!ses || !(ses->server)) 431438c8a9a5SSteve French return -EIO; 431538c8a9a5SSteve French 431638c8a9a5SSteve French if (smb3_encryption_required(tcon)) 431738c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 431838c8a9a5SSteve French 431938c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 432038c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 432138c8a9a5SSteve French rqst.rq_iov = iov; 432238c8a9a5SSteve French rqst.rq_nvec = 1; 432338c8a9a5SSteve French 432438c8a9a5SSteve French rc = SMB2_flush_init(xid, &rqst, tcon, server, 432538c8a9a5SSteve French persistent_fid, volatile_fid); 432638c8a9a5SSteve French if (rc) 432738c8a9a5SSteve French goto flush_exit; 432838c8a9a5SSteve French 432938c8a9a5SSteve French trace_smb3_flush_enter(xid, persistent_fid, tcon->tid, ses->Suid); 4330433042a9SShyam Prasad N 4331433042a9SShyam Prasad N if (retries) 4332433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 4333433042a9SShyam Prasad N 433438c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 433538c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 433638c8a9a5SSteve French 433738c8a9a5SSteve French if (rc != 0) { 433838c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_FLUSH_HE); 433938c8a9a5SSteve French trace_smb3_flush_err(xid, persistent_fid, tcon->tid, ses->Suid, 434038c8a9a5SSteve French rc); 434138c8a9a5SSteve French } else 434238c8a9a5SSteve French trace_smb3_flush_done(xid, persistent_fid, tcon->tid, 434338c8a9a5SSteve French ses->Suid); 434438c8a9a5SSteve French 434538c8a9a5SSteve French flush_exit: 434638c8a9a5SSteve French SMB2_flush_free(&rqst); 434738c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 4348433042a9SShyam Prasad N 4349433042a9SShyam Prasad N if (is_replayable_error(rc) && 4350433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 4351433042a9SShyam Prasad N goto replay_again; 4352433042a9SShyam Prasad N 435338c8a9a5SSteve French return rc; 435438c8a9a5SSteve French } 435538c8a9a5SSteve French 435638c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 435738c8a9a5SSteve French static inline bool smb3_use_rdma_offload(struct cifs_io_parms *io_parms) 435838c8a9a5SSteve French { 435938c8a9a5SSteve French struct TCP_Server_Info *server = io_parms->server; 436038c8a9a5SSteve French struct cifs_tcon *tcon = io_parms->tcon; 436138c8a9a5SSteve French 436238c8a9a5SSteve French /* we can only offload if we're connected */ 436338c8a9a5SSteve French if (!server || !tcon) 436438c8a9a5SSteve French return false; 436538c8a9a5SSteve French 436638c8a9a5SSteve French /* we can only offload on an rdma connection */ 436738c8a9a5SSteve French if (!server->rdma || !server->smbd_conn) 436838c8a9a5SSteve French return false; 436938c8a9a5SSteve French 437038c8a9a5SSteve French /* we don't support signed offload yet */ 437138c8a9a5SSteve French if (server->sign) 437238c8a9a5SSteve French return false; 437338c8a9a5SSteve French 437438c8a9a5SSteve French /* we don't support encrypted offload yet */ 437538c8a9a5SSteve French if (smb3_encryption_required(tcon)) 437638c8a9a5SSteve French return false; 437738c8a9a5SSteve French 437838c8a9a5SSteve French /* offload also has its overhead, so only do it if desired */ 437938c8a9a5SSteve French if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold) 438038c8a9a5SSteve French return false; 438138c8a9a5SSteve French 438238c8a9a5SSteve French return true; 438338c8a9a5SSteve French } 438438c8a9a5SSteve French #endif /* CONFIG_CIFS_SMB_DIRECT */ 438538c8a9a5SSteve French 438638c8a9a5SSteve French /* 438738c8a9a5SSteve French * To form a chain of read requests, any read requests after the first should 438838c8a9a5SSteve French * have the end_of_chain boolean set to true. 438938c8a9a5SSteve French */ 439038c8a9a5SSteve French static int 439138c8a9a5SSteve French smb2_new_read_req(void **buf, unsigned int *total_len, 439238c8a9a5SSteve French struct cifs_io_parms *io_parms, struct cifs_readdata *rdata, 439338c8a9a5SSteve French unsigned int remaining_bytes, int request_type) 439438c8a9a5SSteve French { 439538c8a9a5SSteve French int rc = -EACCES; 439638c8a9a5SSteve French struct smb2_read_req *req = NULL; 439738c8a9a5SSteve French struct smb2_hdr *shdr; 439838c8a9a5SSteve French struct TCP_Server_Info *server = io_parms->server; 439938c8a9a5SSteve French 440038c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server, 440138c8a9a5SSteve French (void **) &req, total_len); 440238c8a9a5SSteve French if (rc) 440338c8a9a5SSteve French return rc; 440438c8a9a5SSteve French 440538c8a9a5SSteve French if (server == NULL) 440638c8a9a5SSteve French return -ECONNABORTED; 440738c8a9a5SSteve French 440838c8a9a5SSteve French shdr = &req->hdr; 440938c8a9a5SSteve French shdr->Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid); 441038c8a9a5SSteve French 441138c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid; 441238c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid; 441338c8a9a5SSteve French req->ReadChannelInfoOffset = 0; /* reserved */ 441438c8a9a5SSteve French req->ReadChannelInfoLength = 0; /* reserved */ 441538c8a9a5SSteve French req->Channel = 0; /* reserved */ 441638c8a9a5SSteve French req->MinimumCount = 0; 441738c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length); 441838c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset); 441938c8a9a5SSteve French 442038c8a9a5SSteve French trace_smb3_read_enter(0 /* xid */, 442138c8a9a5SSteve French io_parms->persistent_fid, 442238c8a9a5SSteve French io_parms->tcon->tid, io_parms->tcon->ses->Suid, 442338c8a9a5SSteve French io_parms->offset, io_parms->length); 442438c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 442538c8a9a5SSteve French /* 442638c8a9a5SSteve French * If we want to do a RDMA write, fill in and append 442738c8a9a5SSteve French * smbd_buffer_descriptor_v1 to the end of read request 442838c8a9a5SSteve French */ 442938c8a9a5SSteve French if (smb3_use_rdma_offload(io_parms)) { 443038c8a9a5SSteve French struct smbd_buffer_descriptor_v1 *v1; 443138c8a9a5SSteve French bool need_invalidate = server->dialect == SMB30_PROT_ID; 443238c8a9a5SSteve French 443338c8a9a5SSteve French rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->iter, 443438c8a9a5SSteve French true, need_invalidate); 443538c8a9a5SSteve French if (!rdata->mr) 443638c8a9a5SSteve French return -EAGAIN; 443738c8a9a5SSteve French 443838c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1_INVALIDATE; 443938c8a9a5SSteve French if (need_invalidate) 444038c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1; 444138c8a9a5SSteve French req->ReadChannelInfoOffset = 444238c8a9a5SSteve French cpu_to_le16(offsetof(struct smb2_read_req, Buffer)); 444338c8a9a5SSteve French req->ReadChannelInfoLength = 444438c8a9a5SSteve French cpu_to_le16(sizeof(struct smbd_buffer_descriptor_v1)); 444538c8a9a5SSteve French v1 = (struct smbd_buffer_descriptor_v1 *) &req->Buffer[0]; 444638c8a9a5SSteve French v1->offset = cpu_to_le64(rdata->mr->mr->iova); 444738c8a9a5SSteve French v1->token = cpu_to_le32(rdata->mr->mr->rkey); 444838c8a9a5SSteve French v1->length = cpu_to_le32(rdata->mr->mr->length); 444938c8a9a5SSteve French 445038c8a9a5SSteve French *total_len += sizeof(*v1) - 1; 445138c8a9a5SSteve French } 445238c8a9a5SSteve French #endif 445338c8a9a5SSteve French if (request_type & CHAINED_REQUEST) { 445438c8a9a5SSteve French if (!(request_type & END_OF_CHAIN)) { 445538c8a9a5SSteve French /* next 8-byte aligned request */ 445638c8a9a5SSteve French *total_len = ALIGN(*total_len, 8); 445738c8a9a5SSteve French shdr->NextCommand = cpu_to_le32(*total_len); 445838c8a9a5SSteve French } else /* END_OF_CHAIN */ 445938c8a9a5SSteve French shdr->NextCommand = 0; 446038c8a9a5SSteve French if (request_type & RELATED_REQUEST) { 446138c8a9a5SSteve French shdr->Flags |= SMB2_FLAGS_RELATED_OPERATIONS; 446238c8a9a5SSteve French /* 446338c8a9a5SSteve French * Related requests use info from previous read request 446438c8a9a5SSteve French * in chain. 446538c8a9a5SSteve French */ 446638c8a9a5SSteve French shdr->SessionId = cpu_to_le64(0xFFFFFFFFFFFFFFFF); 446738c8a9a5SSteve French shdr->Id.SyncId.TreeId = cpu_to_le32(0xFFFFFFFF); 446838c8a9a5SSteve French req->PersistentFileId = (u64)-1; 446938c8a9a5SSteve French req->VolatileFileId = (u64)-1; 447038c8a9a5SSteve French } 447138c8a9a5SSteve French } 447238c8a9a5SSteve French if (remaining_bytes > io_parms->length) 447338c8a9a5SSteve French req->RemainingBytes = cpu_to_le32(remaining_bytes); 447438c8a9a5SSteve French else 447538c8a9a5SSteve French req->RemainingBytes = 0; 447638c8a9a5SSteve French 447738c8a9a5SSteve French *buf = req; 447838c8a9a5SSteve French return rc; 447938c8a9a5SSteve French } 448038c8a9a5SSteve French 448138c8a9a5SSteve French static void 448238c8a9a5SSteve French smb2_readv_callback(struct mid_q_entry *mid) 448338c8a9a5SSteve French { 448438c8a9a5SSteve French struct cifs_readdata *rdata = mid->callback_data; 448538c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink); 448638c8a9a5SSteve French struct TCP_Server_Info *server = rdata->server; 448738c8a9a5SSteve French struct smb2_hdr *shdr = 448838c8a9a5SSteve French (struct smb2_hdr *)rdata->iov[0].iov_base; 448938c8a9a5SSteve French struct cifs_credits credits = { .value = 0, .instance = 0 }; 449038c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = &rdata->iov[1], .rq_nvec = 1 }; 449138c8a9a5SSteve French 449238c8a9a5SSteve French if (rdata->got_bytes) { 449338c8a9a5SSteve French rqst.rq_iter = rdata->iter; 449438c8a9a5SSteve French rqst.rq_iter_size = iov_iter_count(&rdata->iter); 449538c8a9a5SSteve French } 449638c8a9a5SSteve French 449738c8a9a5SSteve French WARN_ONCE(rdata->server != mid->server, 449838c8a9a5SSteve French "rdata server %p != mid server %p", 449938c8a9a5SSteve French rdata->server, mid->server); 450038c8a9a5SSteve French 450138c8a9a5SSteve French cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n", 450238c8a9a5SSteve French __func__, mid->mid, mid->mid_state, rdata->result, 450338c8a9a5SSteve French rdata->bytes); 450438c8a9a5SSteve French 450538c8a9a5SSteve French switch (mid->mid_state) { 450638c8a9a5SSteve French case MID_RESPONSE_RECEIVED: 450738c8a9a5SSteve French credits.value = le16_to_cpu(shdr->CreditRequest); 450838c8a9a5SSteve French credits.instance = server->reconnect_instance; 450938c8a9a5SSteve French /* result already set, check signature */ 451038c8a9a5SSteve French if (server->sign && !mid->decrypted) { 451138c8a9a5SSteve French int rc; 451238c8a9a5SSteve French 451338c8a9a5SSteve French iov_iter_revert(&rqst.rq_iter, rdata->got_bytes); 451438c8a9a5SSteve French iov_iter_truncate(&rqst.rq_iter, rdata->got_bytes); 451538c8a9a5SSteve French rc = smb2_verify_signature(&rqst, server); 451638c8a9a5SSteve French if (rc) 451738c8a9a5SSteve French cifs_tcon_dbg(VFS, "SMB signature verification returned error = %d\n", 451838c8a9a5SSteve French rc); 451938c8a9a5SSteve French } 452038c8a9a5SSteve French /* FIXME: should this be counted toward the initiating task? */ 452138c8a9a5SSteve French task_io_account_read(rdata->got_bytes); 452238c8a9a5SSteve French cifs_stats_bytes_read(tcon, rdata->got_bytes); 452338c8a9a5SSteve French break; 452438c8a9a5SSteve French case MID_REQUEST_SUBMITTED: 452538c8a9a5SSteve French case MID_RETRY_NEEDED: 452638c8a9a5SSteve French rdata->result = -EAGAIN; 452738c8a9a5SSteve French if (server->sign && rdata->got_bytes) 452838c8a9a5SSteve French /* reset bytes number since we can not check a sign */ 452938c8a9a5SSteve French rdata->got_bytes = 0; 453038c8a9a5SSteve French /* FIXME: should this be counted toward the initiating task? */ 453138c8a9a5SSteve French task_io_account_read(rdata->got_bytes); 453238c8a9a5SSteve French cifs_stats_bytes_read(tcon, rdata->got_bytes); 453338c8a9a5SSteve French break; 453438c8a9a5SSteve French case MID_RESPONSE_MALFORMED: 453538c8a9a5SSteve French credits.value = le16_to_cpu(shdr->CreditRequest); 453638c8a9a5SSteve French credits.instance = server->reconnect_instance; 453738c8a9a5SSteve French fallthrough; 453838c8a9a5SSteve French default: 453938c8a9a5SSteve French rdata->result = -EIO; 454038c8a9a5SSteve French } 454138c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 454238c8a9a5SSteve French /* 454338c8a9a5SSteve French * If this rdata has a memmory registered, the MR can be freed 454438c8a9a5SSteve French * MR needs to be freed as soon as I/O finishes to prevent deadlock 454538c8a9a5SSteve French * because they have limited number and are used for future I/Os 454638c8a9a5SSteve French */ 454738c8a9a5SSteve French if (rdata->mr) { 454838c8a9a5SSteve French smbd_deregister_mr(rdata->mr); 454938c8a9a5SSteve French rdata->mr = NULL; 455038c8a9a5SSteve French } 455138c8a9a5SSteve French #endif 455238c8a9a5SSteve French if (rdata->result && rdata->result != -ENODATA) { 455338c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_READ_HE); 455438c8a9a5SSteve French trace_smb3_read_err(0 /* xid */, 455538c8a9a5SSteve French rdata->cfile->fid.persistent_fid, 455638c8a9a5SSteve French tcon->tid, tcon->ses->Suid, rdata->offset, 455738c8a9a5SSteve French rdata->bytes, rdata->result); 455838c8a9a5SSteve French } else 455938c8a9a5SSteve French trace_smb3_read_done(0 /* xid */, 456038c8a9a5SSteve French rdata->cfile->fid.persistent_fid, 456138c8a9a5SSteve French tcon->tid, tcon->ses->Suid, 456238c8a9a5SSteve French rdata->offset, rdata->got_bytes); 456338c8a9a5SSteve French 456438c8a9a5SSteve French queue_work(cifsiod_wq, &rdata->work); 456538c8a9a5SSteve French release_mid(mid); 456638c8a9a5SSteve French add_credits(server, &credits, 0); 456738c8a9a5SSteve French } 456838c8a9a5SSteve French 456938c8a9a5SSteve French /* smb2_async_readv - send an async read, and set up mid to handle result */ 457038c8a9a5SSteve French int 457138c8a9a5SSteve French smb2_async_readv(struct cifs_readdata *rdata) 457238c8a9a5SSteve French { 457338c8a9a5SSteve French int rc, flags = 0; 457438c8a9a5SSteve French char *buf; 457538c8a9a5SSteve French struct smb2_hdr *shdr; 457638c8a9a5SSteve French struct cifs_io_parms io_parms; 457738c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = rdata->iov, 457838c8a9a5SSteve French .rq_nvec = 1 }; 457938c8a9a5SSteve French struct TCP_Server_Info *server; 458038c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink); 458138c8a9a5SSteve French unsigned int total_len; 45825e90aa21SShyam Prasad N int credit_request; 458338c8a9a5SSteve French 458438c8a9a5SSteve French cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n", 458538c8a9a5SSteve French __func__, rdata->offset, rdata->bytes); 458638c8a9a5SSteve French 458738c8a9a5SSteve French if (!rdata->server) 458838c8a9a5SSteve French rdata->server = cifs_pick_channel(tcon->ses); 458938c8a9a5SSteve French 459038c8a9a5SSteve French io_parms.tcon = tlink_tcon(rdata->cfile->tlink); 459138c8a9a5SSteve French io_parms.server = server = rdata->server; 459238c8a9a5SSteve French io_parms.offset = rdata->offset; 459338c8a9a5SSteve French io_parms.length = rdata->bytes; 459438c8a9a5SSteve French io_parms.persistent_fid = rdata->cfile->fid.persistent_fid; 459538c8a9a5SSteve French io_parms.volatile_fid = rdata->cfile->fid.volatile_fid; 459638c8a9a5SSteve French io_parms.pid = rdata->pid; 459738c8a9a5SSteve French 459838c8a9a5SSteve French rc = smb2_new_read_req( 459938c8a9a5SSteve French (void **) &buf, &total_len, &io_parms, rdata, 0, 0); 460038c8a9a5SSteve French if (rc) 460138c8a9a5SSteve French return rc; 460238c8a9a5SSteve French 460338c8a9a5SSteve French if (smb3_encryption_required(io_parms.tcon)) 460438c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 460538c8a9a5SSteve French 460638c8a9a5SSteve French rdata->iov[0].iov_base = buf; 460738c8a9a5SSteve French rdata->iov[0].iov_len = total_len; 460838c8a9a5SSteve French 460938c8a9a5SSteve French shdr = (struct smb2_hdr *)buf; 461038c8a9a5SSteve French 461138c8a9a5SSteve French if (rdata->credits.value > 0) { 461238c8a9a5SSteve French shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(rdata->bytes, 461338c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE)); 46145e90aa21SShyam Prasad N credit_request = le16_to_cpu(shdr->CreditCharge) + 8; 46155e90aa21SShyam Prasad N if (server->credits >= server->max_credits) 46165e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(0); 46175e90aa21SShyam Prasad N else 46185e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16( 46195e90aa21SShyam Prasad N min_t(int, server->max_credits - 46205e90aa21SShyam Prasad N server->credits, credit_request)); 462138c8a9a5SSteve French 462238c8a9a5SSteve French rc = adjust_credits(server, &rdata->credits, rdata->bytes); 462338c8a9a5SSteve French if (rc) 462438c8a9a5SSteve French goto async_readv_out; 462538c8a9a5SSteve French 462638c8a9a5SSteve French flags |= CIFS_HAS_CREDITS; 462738c8a9a5SSteve French } 462838c8a9a5SSteve French 462938c8a9a5SSteve French kref_get(&rdata->refcount); 463038c8a9a5SSteve French rc = cifs_call_async(server, &rqst, 463138c8a9a5SSteve French cifs_readv_receive, smb2_readv_callback, 463238c8a9a5SSteve French smb3_handle_read_data, rdata, flags, 463338c8a9a5SSteve French &rdata->credits); 463438c8a9a5SSteve French if (rc) { 463538c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 463638c8a9a5SSteve French cifs_stats_fail_inc(io_parms.tcon, SMB2_READ_HE); 463738c8a9a5SSteve French trace_smb3_read_err(0 /* xid */, io_parms.persistent_fid, 463838c8a9a5SSteve French io_parms.tcon->tid, 463938c8a9a5SSteve French io_parms.tcon->ses->Suid, 464038c8a9a5SSteve French io_parms.offset, io_parms.length, rc); 464138c8a9a5SSteve French } 464238c8a9a5SSteve French 464338c8a9a5SSteve French async_readv_out: 464438c8a9a5SSteve French cifs_small_buf_release(buf); 464538c8a9a5SSteve French return rc; 464638c8a9a5SSteve French } 464738c8a9a5SSteve French 464838c8a9a5SSteve French int 464938c8a9a5SSteve French SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms, 465038c8a9a5SSteve French unsigned int *nbytes, char **buf, int *buf_type) 465138c8a9a5SSteve French { 465238c8a9a5SSteve French struct smb_rqst rqst; 465338c8a9a5SSteve French int resp_buftype, rc; 465438c8a9a5SSteve French struct smb2_read_req *req = NULL; 465538c8a9a5SSteve French struct smb2_read_rsp *rsp = NULL; 465638c8a9a5SSteve French struct kvec iov[1]; 465738c8a9a5SSteve French struct kvec rsp_iov; 465838c8a9a5SSteve French unsigned int total_len; 465938c8a9a5SSteve French int flags = CIFS_LOG_ERROR; 466038c8a9a5SSteve French struct cifs_ses *ses = io_parms->tcon->ses; 466138c8a9a5SSteve French 466238c8a9a5SSteve French if (!io_parms->server) 466338c8a9a5SSteve French io_parms->server = cifs_pick_channel(io_parms->tcon->ses); 466438c8a9a5SSteve French 466538c8a9a5SSteve French *nbytes = 0; 466638c8a9a5SSteve French rc = smb2_new_read_req((void **)&req, &total_len, io_parms, NULL, 0, 0); 466738c8a9a5SSteve French if (rc) 466838c8a9a5SSteve French return rc; 466938c8a9a5SSteve French 467038c8a9a5SSteve French if (smb3_encryption_required(io_parms->tcon)) 467138c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 467238c8a9a5SSteve French 467338c8a9a5SSteve French iov[0].iov_base = (char *)req; 467438c8a9a5SSteve French iov[0].iov_len = total_len; 467538c8a9a5SSteve French 467638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 467738c8a9a5SSteve French rqst.rq_iov = iov; 467838c8a9a5SSteve French rqst.rq_nvec = 1; 467938c8a9a5SSteve French 468038c8a9a5SSteve French rc = cifs_send_recv(xid, ses, io_parms->server, 468138c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 468238c8a9a5SSteve French rsp = (struct smb2_read_rsp *)rsp_iov.iov_base; 468338c8a9a5SSteve French 468438c8a9a5SSteve French if (rc) { 468538c8a9a5SSteve French if (rc != -ENODATA) { 468638c8a9a5SSteve French cifs_stats_fail_inc(io_parms->tcon, SMB2_READ_HE); 468738c8a9a5SSteve French cifs_dbg(VFS, "Send error in read = %d\n", rc); 468838c8a9a5SSteve French trace_smb3_read_err(xid, 468938c8a9a5SSteve French req->PersistentFileId, 469038c8a9a5SSteve French io_parms->tcon->tid, ses->Suid, 469138c8a9a5SSteve French io_parms->offset, io_parms->length, 469238c8a9a5SSteve French rc); 469338c8a9a5SSteve French } else 469438c8a9a5SSteve French trace_smb3_read_done(xid, req->PersistentFileId, io_parms->tcon->tid, 469538c8a9a5SSteve French ses->Suid, io_parms->offset, 0); 469638c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 469738c8a9a5SSteve French cifs_small_buf_release(req); 469838c8a9a5SSteve French return rc == -ENODATA ? 0 : rc; 469938c8a9a5SSteve French } else 470038c8a9a5SSteve French trace_smb3_read_done(xid, 470138c8a9a5SSteve French req->PersistentFileId, 470238c8a9a5SSteve French io_parms->tcon->tid, ses->Suid, 470338c8a9a5SSteve French io_parms->offset, io_parms->length); 470438c8a9a5SSteve French 470538c8a9a5SSteve French cifs_small_buf_release(req); 470638c8a9a5SSteve French 470738c8a9a5SSteve French *nbytes = le32_to_cpu(rsp->DataLength); 470838c8a9a5SSteve French if ((*nbytes > CIFS_MAX_MSGSIZE) || 470938c8a9a5SSteve French (*nbytes > io_parms->length)) { 471038c8a9a5SSteve French cifs_dbg(FYI, "bad length %d for count %d\n", 471138c8a9a5SSteve French *nbytes, io_parms->length); 471238c8a9a5SSteve French rc = -EIO; 471338c8a9a5SSteve French *nbytes = 0; 471438c8a9a5SSteve French } 471538c8a9a5SSteve French 471638c8a9a5SSteve French if (*buf) { 471738c8a9a5SSteve French memcpy(*buf, (char *)rsp + rsp->DataOffset, *nbytes); 471838c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 471938c8a9a5SSteve French } else if (resp_buftype != CIFS_NO_BUFFER) { 472038c8a9a5SSteve French *buf = rsp_iov.iov_base; 472138c8a9a5SSteve French if (resp_buftype == CIFS_SMALL_BUFFER) 472238c8a9a5SSteve French *buf_type = CIFS_SMALL_BUFFER; 472338c8a9a5SSteve French else if (resp_buftype == CIFS_LARGE_BUFFER) 472438c8a9a5SSteve French *buf_type = CIFS_LARGE_BUFFER; 472538c8a9a5SSteve French } 472638c8a9a5SSteve French return rc; 472738c8a9a5SSteve French } 472838c8a9a5SSteve French 472938c8a9a5SSteve French /* 473038c8a9a5SSteve French * Check the mid_state and signature on received buffer (if any), and queue the 473138c8a9a5SSteve French * workqueue completion task. 473238c8a9a5SSteve French */ 473338c8a9a5SSteve French static void 473438c8a9a5SSteve French smb2_writev_callback(struct mid_q_entry *mid) 473538c8a9a5SSteve French { 473638c8a9a5SSteve French struct cifs_writedata *wdata = mid->callback_data; 473738c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink); 473838c8a9a5SSteve French struct TCP_Server_Info *server = wdata->server; 473938c8a9a5SSteve French unsigned int written; 474038c8a9a5SSteve French struct smb2_write_rsp *rsp = (struct smb2_write_rsp *)mid->resp_buf; 474138c8a9a5SSteve French struct cifs_credits credits = { .value = 0, .instance = 0 }; 474238c8a9a5SSteve French 474338c8a9a5SSteve French WARN_ONCE(wdata->server != mid->server, 474438c8a9a5SSteve French "wdata server %p != mid server %p", 474538c8a9a5SSteve French wdata->server, mid->server); 474638c8a9a5SSteve French 474738c8a9a5SSteve French switch (mid->mid_state) { 474838c8a9a5SSteve French case MID_RESPONSE_RECEIVED: 474938c8a9a5SSteve French credits.value = le16_to_cpu(rsp->hdr.CreditRequest); 475038c8a9a5SSteve French credits.instance = server->reconnect_instance; 475138c8a9a5SSteve French wdata->result = smb2_check_receive(mid, server, 0); 475238c8a9a5SSteve French if (wdata->result != 0) 475338c8a9a5SSteve French break; 475438c8a9a5SSteve French 475538c8a9a5SSteve French written = le32_to_cpu(rsp->DataLength); 475638c8a9a5SSteve French /* 475738c8a9a5SSteve French * Mask off high 16 bits when bytes written as returned 475838c8a9a5SSteve French * by the server is greater than bytes requested by the 475938c8a9a5SSteve French * client. OS/2 servers are known to set incorrect 476038c8a9a5SSteve French * CountHigh values. 476138c8a9a5SSteve French */ 476238c8a9a5SSteve French if (written > wdata->bytes) 476338c8a9a5SSteve French written &= 0xFFFF; 476438c8a9a5SSteve French 476538c8a9a5SSteve French if (written < wdata->bytes) 476638c8a9a5SSteve French wdata->result = -ENOSPC; 476738c8a9a5SSteve French else 476838c8a9a5SSteve French wdata->bytes = written; 476938c8a9a5SSteve French break; 477038c8a9a5SSteve French case MID_REQUEST_SUBMITTED: 477138c8a9a5SSteve French case MID_RETRY_NEEDED: 477238c8a9a5SSteve French wdata->result = -EAGAIN; 477338c8a9a5SSteve French break; 477438c8a9a5SSteve French case MID_RESPONSE_MALFORMED: 477538c8a9a5SSteve French credits.value = le16_to_cpu(rsp->hdr.CreditRequest); 477638c8a9a5SSteve French credits.instance = server->reconnect_instance; 477738c8a9a5SSteve French fallthrough; 477838c8a9a5SSteve French default: 477938c8a9a5SSteve French wdata->result = -EIO; 478038c8a9a5SSteve French break; 478138c8a9a5SSteve French } 478238c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 478338c8a9a5SSteve French /* 478438c8a9a5SSteve French * If this wdata has a memory registered, the MR can be freed 478538c8a9a5SSteve French * The number of MRs available is limited, it's important to recover 478638c8a9a5SSteve French * used MR as soon as I/O is finished. Hold MR longer in the later 478738c8a9a5SSteve French * I/O process can possibly result in I/O deadlock due to lack of MR 478838c8a9a5SSteve French * to send request on I/O retry 478938c8a9a5SSteve French */ 479038c8a9a5SSteve French if (wdata->mr) { 479138c8a9a5SSteve French smbd_deregister_mr(wdata->mr); 479238c8a9a5SSteve French wdata->mr = NULL; 479338c8a9a5SSteve French } 479438c8a9a5SSteve French #endif 479538c8a9a5SSteve French if (wdata->result) { 479638c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_WRITE_HE); 479738c8a9a5SSteve French trace_smb3_write_err(0 /* no xid */, 479838c8a9a5SSteve French wdata->cfile->fid.persistent_fid, 479938c8a9a5SSteve French tcon->tid, tcon->ses->Suid, wdata->offset, 480038c8a9a5SSteve French wdata->bytes, wdata->result); 480138c8a9a5SSteve French if (wdata->result == -ENOSPC) 480238c8a9a5SSteve French pr_warn_once("Out of space writing to %s\n", 480338c8a9a5SSteve French tcon->tree_name); 480438c8a9a5SSteve French } else 480538c8a9a5SSteve French trace_smb3_write_done(0 /* no xid */, 480638c8a9a5SSteve French wdata->cfile->fid.persistent_fid, 480738c8a9a5SSteve French tcon->tid, tcon->ses->Suid, 480838c8a9a5SSteve French wdata->offset, wdata->bytes); 480938c8a9a5SSteve French 481038c8a9a5SSteve French queue_work(cifsiod_wq, &wdata->work); 481138c8a9a5SSteve French release_mid(mid); 481238c8a9a5SSteve French add_credits(server, &credits, 0); 481338c8a9a5SSteve French } 481438c8a9a5SSteve French 481538c8a9a5SSteve French /* smb2_async_writev - send an async write, and set up mid to handle result */ 481638c8a9a5SSteve French int 481738c8a9a5SSteve French smb2_async_writev(struct cifs_writedata *wdata, 481838c8a9a5SSteve French void (*release)(struct kref *kref)) 481938c8a9a5SSteve French { 482038c8a9a5SSteve French int rc = -EACCES, flags = 0; 482138c8a9a5SSteve French struct smb2_write_req *req = NULL; 482238c8a9a5SSteve French struct smb2_hdr *shdr; 482338c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink); 482438c8a9a5SSteve French struct TCP_Server_Info *server = wdata->server; 482538c8a9a5SSteve French struct kvec iov[1]; 482638c8a9a5SSteve French struct smb_rqst rqst = { }; 482738c8a9a5SSteve French unsigned int total_len; 482838c8a9a5SSteve French struct cifs_io_parms _io_parms; 482938c8a9a5SSteve French struct cifs_io_parms *io_parms = NULL; 48305e90aa21SShyam Prasad N int credit_request; 483138c8a9a5SSteve French 4832cdd7870aSShyam Prasad N if (!wdata->server || wdata->replay) 483338c8a9a5SSteve French server = wdata->server = cifs_pick_channel(tcon->ses); 483438c8a9a5SSteve French 483538c8a9a5SSteve French /* 483638c8a9a5SSteve French * in future we may get cifs_io_parms passed in from the caller, 483738c8a9a5SSteve French * but for now we construct it here... 483838c8a9a5SSteve French */ 483938c8a9a5SSteve French _io_parms = (struct cifs_io_parms) { 484038c8a9a5SSteve French .tcon = tcon, 484138c8a9a5SSteve French .server = server, 484238c8a9a5SSteve French .offset = wdata->offset, 484338c8a9a5SSteve French .length = wdata->bytes, 484438c8a9a5SSteve French .persistent_fid = wdata->cfile->fid.persistent_fid, 484538c8a9a5SSteve French .volatile_fid = wdata->cfile->fid.volatile_fid, 484638c8a9a5SSteve French .pid = wdata->pid, 484738c8a9a5SSteve French }; 484838c8a9a5SSteve French io_parms = &_io_parms; 484938c8a9a5SSteve French 485038c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_WRITE, tcon, server, 485138c8a9a5SSteve French (void **) &req, &total_len); 485238c8a9a5SSteve French if (rc) 485338c8a9a5SSteve French return rc; 485438c8a9a5SSteve French 485538c8a9a5SSteve French if (smb3_encryption_required(tcon)) 485638c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 485738c8a9a5SSteve French 485838c8a9a5SSteve French shdr = (struct smb2_hdr *)req; 485938c8a9a5SSteve French shdr->Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid); 486038c8a9a5SSteve French 486138c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid; 486238c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid; 486338c8a9a5SSteve French req->WriteChannelInfoOffset = 0; 486438c8a9a5SSteve French req->WriteChannelInfoLength = 0; 486538c8a9a5SSteve French req->Channel = SMB2_CHANNEL_NONE; 486638c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset); 486738c8a9a5SSteve French req->DataOffset = cpu_to_le16( 486838c8a9a5SSteve French offsetof(struct smb2_write_req, Buffer)); 486938c8a9a5SSteve French req->RemainingBytes = 0; 487038c8a9a5SSteve French 487138c8a9a5SSteve French trace_smb3_write_enter(0 /* xid */, 487238c8a9a5SSteve French io_parms->persistent_fid, 487338c8a9a5SSteve French io_parms->tcon->tid, 487438c8a9a5SSteve French io_parms->tcon->ses->Suid, 487538c8a9a5SSteve French io_parms->offset, 487638c8a9a5SSteve French io_parms->length); 487738c8a9a5SSteve French 487838c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 487938c8a9a5SSteve French /* 488038c8a9a5SSteve French * If we want to do a server RDMA read, fill in and append 488138c8a9a5SSteve French * smbd_buffer_descriptor_v1 to the end of write request 488238c8a9a5SSteve French */ 488338c8a9a5SSteve French if (smb3_use_rdma_offload(io_parms)) { 488438c8a9a5SSteve French struct smbd_buffer_descriptor_v1 *v1; 488538c8a9a5SSteve French size_t data_size = iov_iter_count(&wdata->iter); 488638c8a9a5SSteve French bool need_invalidate = server->dialect == SMB30_PROT_ID; 488738c8a9a5SSteve French 488838c8a9a5SSteve French wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->iter, 488938c8a9a5SSteve French false, need_invalidate); 489038c8a9a5SSteve French if (!wdata->mr) { 489138c8a9a5SSteve French rc = -EAGAIN; 489238c8a9a5SSteve French goto async_writev_out; 489338c8a9a5SSteve French } 489438c8a9a5SSteve French req->Length = 0; 489538c8a9a5SSteve French req->DataOffset = 0; 489638c8a9a5SSteve French req->RemainingBytes = cpu_to_le32(data_size); 489738c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1_INVALIDATE; 489838c8a9a5SSteve French if (need_invalidate) 489938c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1; 490038c8a9a5SSteve French req->WriteChannelInfoOffset = 490138c8a9a5SSteve French cpu_to_le16(offsetof(struct smb2_write_req, Buffer)); 490238c8a9a5SSteve French req->WriteChannelInfoLength = 490338c8a9a5SSteve French cpu_to_le16(sizeof(struct smbd_buffer_descriptor_v1)); 490438c8a9a5SSteve French v1 = (struct smbd_buffer_descriptor_v1 *) &req->Buffer[0]; 490538c8a9a5SSteve French v1->offset = cpu_to_le64(wdata->mr->mr->iova); 490638c8a9a5SSteve French v1->token = cpu_to_le32(wdata->mr->mr->rkey); 490738c8a9a5SSteve French v1->length = cpu_to_le32(wdata->mr->mr->length); 490838c8a9a5SSteve French } 490938c8a9a5SSteve French #endif 491038c8a9a5SSteve French iov[0].iov_len = total_len - 1; 491138c8a9a5SSteve French iov[0].iov_base = (char *)req; 491238c8a9a5SSteve French 491338c8a9a5SSteve French rqst.rq_iov = iov; 491438c8a9a5SSteve French rqst.rq_nvec = 1; 491538c8a9a5SSteve French rqst.rq_iter = wdata->iter; 491638c8a9a5SSteve French rqst.rq_iter_size = iov_iter_count(&rqst.rq_iter); 4917cdd7870aSShyam Prasad N if (wdata->replay) 4918cdd7870aSShyam Prasad N smb2_set_replay(server, &rqst); 491938c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 492038c8a9a5SSteve French if (wdata->mr) 492138c8a9a5SSteve French iov[0].iov_len += sizeof(struct smbd_buffer_descriptor_v1); 492238c8a9a5SSteve French #endif 492338c8a9a5SSteve French cifs_dbg(FYI, "async write at %llu %u bytes iter=%zx\n", 492438c8a9a5SSteve French io_parms->offset, io_parms->length, iov_iter_count(&rqst.rq_iter)); 492538c8a9a5SSteve French 492638c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 492738c8a9a5SSteve French /* For RDMA read, I/O size is in RemainingBytes not in Length */ 492838c8a9a5SSteve French if (!wdata->mr) 492938c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length); 493038c8a9a5SSteve French #else 493138c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length); 493238c8a9a5SSteve French #endif 493338c8a9a5SSteve French 493438c8a9a5SSteve French if (wdata->credits.value > 0) { 493538c8a9a5SSteve French shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(wdata->bytes, 493638c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE)); 49375e90aa21SShyam Prasad N credit_request = le16_to_cpu(shdr->CreditCharge) + 8; 49385e90aa21SShyam Prasad N if (server->credits >= server->max_credits) 49395e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(0); 49405e90aa21SShyam Prasad N else 49415e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16( 49425e90aa21SShyam Prasad N min_t(int, server->max_credits - 49435e90aa21SShyam Prasad N server->credits, credit_request)); 494438c8a9a5SSteve French 494538c8a9a5SSteve French rc = adjust_credits(server, &wdata->credits, io_parms->length); 494638c8a9a5SSteve French if (rc) 494738c8a9a5SSteve French goto async_writev_out; 494838c8a9a5SSteve French 494938c8a9a5SSteve French flags |= CIFS_HAS_CREDITS; 495038c8a9a5SSteve French } 495138c8a9a5SSteve French 495238c8a9a5SSteve French kref_get(&wdata->refcount); 495338c8a9a5SSteve French rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL, 495438c8a9a5SSteve French wdata, flags, &wdata->credits); 495538c8a9a5SSteve French 495638c8a9a5SSteve French if (rc) { 495738c8a9a5SSteve French trace_smb3_write_err(0 /* no xid */, 495838c8a9a5SSteve French io_parms->persistent_fid, 495938c8a9a5SSteve French io_parms->tcon->tid, 496038c8a9a5SSteve French io_parms->tcon->ses->Suid, 496138c8a9a5SSteve French io_parms->offset, 496238c8a9a5SSteve French io_parms->length, 496338c8a9a5SSteve French rc); 496438c8a9a5SSteve French kref_put(&wdata->refcount, release); 496538c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_WRITE_HE); 496638c8a9a5SSteve French } 496738c8a9a5SSteve French 496838c8a9a5SSteve French async_writev_out: 496938c8a9a5SSteve French cifs_small_buf_release(req); 497038c8a9a5SSteve French return rc; 497138c8a9a5SSteve French } 497238c8a9a5SSteve French 497338c8a9a5SSteve French /* 497438c8a9a5SSteve French * SMB2_write function gets iov pointer to kvec array with n_vec as a length. 497538c8a9a5SSteve French * The length field from io_parms must be at least 1 and indicates a number of 497638c8a9a5SSteve French * elements with data to write that begins with position 1 in iov array. All 497738c8a9a5SSteve French * data length is specified by count. 497838c8a9a5SSteve French */ 497938c8a9a5SSteve French int 498038c8a9a5SSteve French SMB2_write(const unsigned int xid, struct cifs_io_parms *io_parms, 498138c8a9a5SSteve French unsigned int *nbytes, struct kvec *iov, int n_vec) 498238c8a9a5SSteve French { 498338c8a9a5SSteve French struct smb_rqst rqst; 498438c8a9a5SSteve French int rc = 0; 498538c8a9a5SSteve French struct smb2_write_req *req = NULL; 498638c8a9a5SSteve French struct smb2_write_rsp *rsp = NULL; 498738c8a9a5SSteve French int resp_buftype; 498838c8a9a5SSteve French struct kvec rsp_iov; 498938c8a9a5SSteve French int flags = 0; 499038c8a9a5SSteve French unsigned int total_len; 499138c8a9a5SSteve French struct TCP_Server_Info *server; 4992433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 499338c8a9a5SSteve French 4994433042a9SShyam Prasad N replay_again: 4995433042a9SShyam Prasad N /* reinitialize for possible replay */ 4996433042a9SShyam Prasad N flags = 0; 499738c8a9a5SSteve French *nbytes = 0; 499838c8a9a5SSteve French if (!io_parms->server) 499938c8a9a5SSteve French io_parms->server = cifs_pick_channel(io_parms->tcon->ses); 500038c8a9a5SSteve French server = io_parms->server; 500138c8a9a5SSteve French if (server == NULL) 500238c8a9a5SSteve French return -ECONNABORTED; 500338c8a9a5SSteve French 5004433042a9SShyam Prasad N if (n_vec < 1) 5005433042a9SShyam Prasad N return rc; 5006433042a9SShyam Prasad N 500738c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server, 500838c8a9a5SSteve French (void **) &req, &total_len); 500938c8a9a5SSteve French if (rc) 501038c8a9a5SSteve French return rc; 501138c8a9a5SSteve French 501238c8a9a5SSteve French if (smb3_encryption_required(io_parms->tcon)) 501338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 501438c8a9a5SSteve French 501538c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid); 501638c8a9a5SSteve French 501738c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid; 501838c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid; 501938c8a9a5SSteve French req->WriteChannelInfoOffset = 0; 502038c8a9a5SSteve French req->WriteChannelInfoLength = 0; 502138c8a9a5SSteve French req->Channel = 0; 502238c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length); 502338c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset); 502438c8a9a5SSteve French req->DataOffset = cpu_to_le16( 502538c8a9a5SSteve French offsetof(struct smb2_write_req, Buffer)); 502638c8a9a5SSteve French req->RemainingBytes = 0; 502738c8a9a5SSteve French 502838c8a9a5SSteve French trace_smb3_write_enter(xid, io_parms->persistent_fid, 502938c8a9a5SSteve French io_parms->tcon->tid, io_parms->tcon->ses->Suid, 503038c8a9a5SSteve French io_parms->offset, io_parms->length); 503138c8a9a5SSteve French 503238c8a9a5SSteve French iov[0].iov_base = (char *)req; 503338c8a9a5SSteve French /* 1 for Buffer */ 503438c8a9a5SSteve French iov[0].iov_len = total_len - 1; 503538c8a9a5SSteve French 503638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 503738c8a9a5SSteve French rqst.rq_iov = iov; 503838c8a9a5SSteve French rqst.rq_nvec = n_vec + 1; 503938c8a9a5SSteve French 5040433042a9SShyam Prasad N if (retries) 5041433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5042433042a9SShyam Prasad N 504338c8a9a5SSteve French rc = cifs_send_recv(xid, io_parms->tcon->ses, server, 504438c8a9a5SSteve French &rqst, 504538c8a9a5SSteve French &resp_buftype, flags, &rsp_iov); 504638c8a9a5SSteve French rsp = (struct smb2_write_rsp *)rsp_iov.iov_base; 504738c8a9a5SSteve French 504838c8a9a5SSteve French if (rc) { 504938c8a9a5SSteve French trace_smb3_write_err(xid, 505038c8a9a5SSteve French req->PersistentFileId, 505138c8a9a5SSteve French io_parms->tcon->tid, 505238c8a9a5SSteve French io_parms->tcon->ses->Suid, 505338c8a9a5SSteve French io_parms->offset, io_parms->length, rc); 505438c8a9a5SSteve French cifs_stats_fail_inc(io_parms->tcon, SMB2_WRITE_HE); 505538c8a9a5SSteve French cifs_dbg(VFS, "Send error in write = %d\n", rc); 505638c8a9a5SSteve French } else { 505738c8a9a5SSteve French *nbytes = le32_to_cpu(rsp->DataLength); 505838c8a9a5SSteve French trace_smb3_write_done(xid, 505938c8a9a5SSteve French req->PersistentFileId, 506038c8a9a5SSteve French io_parms->tcon->tid, 506138c8a9a5SSteve French io_parms->tcon->ses->Suid, 506238c8a9a5SSteve French io_parms->offset, *nbytes); 506338c8a9a5SSteve French } 506438c8a9a5SSteve French 506538c8a9a5SSteve French cifs_small_buf_release(req); 506638c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 5067433042a9SShyam Prasad N 5068433042a9SShyam Prasad N if (is_replayable_error(rc) && 5069433042a9SShyam Prasad N smb2_should_replay(io_parms->tcon, &retries, &cur_sleep)) 5070433042a9SShyam Prasad N goto replay_again; 5071433042a9SShyam Prasad N 507238c8a9a5SSteve French return rc; 507338c8a9a5SSteve French } 507438c8a9a5SSteve French 507538c8a9a5SSteve French int posix_info_sid_size(const void *beg, const void *end) 507638c8a9a5SSteve French { 507738c8a9a5SSteve French size_t subauth; 507838c8a9a5SSteve French int total; 507938c8a9a5SSteve French 508038c8a9a5SSteve French if (beg + 1 > end) 508138c8a9a5SSteve French return -1; 508238c8a9a5SSteve French 508338c8a9a5SSteve French subauth = *(u8 *)(beg+1); 508438c8a9a5SSteve French if (subauth < 1 || subauth > 15) 508538c8a9a5SSteve French return -1; 508638c8a9a5SSteve French 508738c8a9a5SSteve French total = 1 + 1 + 6 + 4*subauth; 508838c8a9a5SSteve French if (beg + total > end) 508938c8a9a5SSteve French return -1; 509038c8a9a5SSteve French 509138c8a9a5SSteve French return total; 509238c8a9a5SSteve French } 509338c8a9a5SSteve French 509438c8a9a5SSteve French int posix_info_parse(const void *beg, const void *end, 509538c8a9a5SSteve French struct smb2_posix_info_parsed *out) 509638c8a9a5SSteve French 509738c8a9a5SSteve French { 509838c8a9a5SSteve French int total_len = 0; 509938c8a9a5SSteve French int owner_len, group_len; 510038c8a9a5SSteve French int name_len; 510138c8a9a5SSteve French const void *owner_sid; 510238c8a9a5SSteve French const void *group_sid; 510338c8a9a5SSteve French const void *name; 510438c8a9a5SSteve French 510538c8a9a5SSteve French /* if no end bound given, assume payload to be correct */ 510638c8a9a5SSteve French if (!end) { 510738c8a9a5SSteve French const struct smb2_posix_info *p = beg; 510838c8a9a5SSteve French 510938c8a9a5SSteve French end = beg + le32_to_cpu(p->NextEntryOffset); 511038c8a9a5SSteve French /* last element will have a 0 offset, pick a sensible bound */ 511138c8a9a5SSteve French if (end == beg) 511238c8a9a5SSteve French end += 0xFFFF; 511338c8a9a5SSteve French } 511438c8a9a5SSteve French 511538c8a9a5SSteve French /* check base buf */ 511638c8a9a5SSteve French if (beg + sizeof(struct smb2_posix_info) > end) 511738c8a9a5SSteve French return -1; 511838c8a9a5SSteve French total_len = sizeof(struct smb2_posix_info); 511938c8a9a5SSteve French 512038c8a9a5SSteve French /* check owner sid */ 512138c8a9a5SSteve French owner_sid = beg + total_len; 512238c8a9a5SSteve French owner_len = posix_info_sid_size(owner_sid, end); 512338c8a9a5SSteve French if (owner_len < 0) 512438c8a9a5SSteve French return -1; 512538c8a9a5SSteve French total_len += owner_len; 512638c8a9a5SSteve French 512738c8a9a5SSteve French /* check group sid */ 512838c8a9a5SSteve French group_sid = beg + total_len; 512938c8a9a5SSteve French group_len = posix_info_sid_size(group_sid, end); 513038c8a9a5SSteve French if (group_len < 0) 513138c8a9a5SSteve French return -1; 513238c8a9a5SSteve French total_len += group_len; 513338c8a9a5SSteve French 513438c8a9a5SSteve French /* check name len */ 513538c8a9a5SSteve French if (beg + total_len + 4 > end) 513638c8a9a5SSteve French return -1; 513738c8a9a5SSteve French name_len = le32_to_cpu(*(__le32 *)(beg + total_len)); 513838c8a9a5SSteve French if (name_len < 1 || name_len > 0xFFFF) 513938c8a9a5SSteve French return -1; 514038c8a9a5SSteve French total_len += 4; 514138c8a9a5SSteve French 514238c8a9a5SSteve French /* check name */ 514338c8a9a5SSteve French name = beg + total_len; 514438c8a9a5SSteve French if (name + name_len > end) 514538c8a9a5SSteve French return -1; 514638c8a9a5SSteve French total_len += name_len; 514738c8a9a5SSteve French 514838c8a9a5SSteve French if (out) { 514938c8a9a5SSteve French out->base = beg; 515038c8a9a5SSteve French out->size = total_len; 515138c8a9a5SSteve French out->name_len = name_len; 515238c8a9a5SSteve French out->name = name; 515338c8a9a5SSteve French memcpy(&out->owner, owner_sid, owner_len); 515438c8a9a5SSteve French memcpy(&out->group, group_sid, group_len); 515538c8a9a5SSteve French } 515638c8a9a5SSteve French return total_len; 515738c8a9a5SSteve French } 515838c8a9a5SSteve French 515938c8a9a5SSteve French static int posix_info_extra_size(const void *beg, const void *end) 516038c8a9a5SSteve French { 516138c8a9a5SSteve French int len = posix_info_parse(beg, end, NULL); 516238c8a9a5SSteve French 516338c8a9a5SSteve French if (len < 0) 516438c8a9a5SSteve French return -1; 516538c8a9a5SSteve French return len - sizeof(struct smb2_posix_info); 516638c8a9a5SSteve French } 516738c8a9a5SSteve French 516838c8a9a5SSteve French static unsigned int 516938c8a9a5SSteve French num_entries(int infotype, char *bufstart, char *end_of_buf, char **lastentry, 517038c8a9a5SSteve French size_t size) 517138c8a9a5SSteve French { 517238c8a9a5SSteve French int len; 517338c8a9a5SSteve French unsigned int entrycount = 0; 517438c8a9a5SSteve French unsigned int next_offset = 0; 517538c8a9a5SSteve French char *entryptr; 517638c8a9a5SSteve French FILE_DIRECTORY_INFO *dir_info; 517738c8a9a5SSteve French 517838c8a9a5SSteve French if (bufstart == NULL) 517938c8a9a5SSteve French return 0; 518038c8a9a5SSteve French 518138c8a9a5SSteve French entryptr = bufstart; 518238c8a9a5SSteve French 518338c8a9a5SSteve French while (1) { 518438c8a9a5SSteve French if (entryptr + next_offset < entryptr || 518538c8a9a5SSteve French entryptr + next_offset > end_of_buf || 518638c8a9a5SSteve French entryptr + next_offset + size > end_of_buf) { 518738c8a9a5SSteve French cifs_dbg(VFS, "malformed search entry would overflow\n"); 518838c8a9a5SSteve French break; 518938c8a9a5SSteve French } 519038c8a9a5SSteve French 519138c8a9a5SSteve French entryptr = entryptr + next_offset; 519238c8a9a5SSteve French dir_info = (FILE_DIRECTORY_INFO *)entryptr; 519338c8a9a5SSteve French 519438c8a9a5SSteve French if (infotype == SMB_FIND_FILE_POSIX_INFO) 519538c8a9a5SSteve French len = posix_info_extra_size(entryptr, end_of_buf); 519638c8a9a5SSteve French else 519738c8a9a5SSteve French len = le32_to_cpu(dir_info->FileNameLength); 519838c8a9a5SSteve French 519938c8a9a5SSteve French if (len < 0 || 520038c8a9a5SSteve French entryptr + len < entryptr || 520138c8a9a5SSteve French entryptr + len > end_of_buf || 520238c8a9a5SSteve French entryptr + len + size > end_of_buf) { 520338c8a9a5SSteve French cifs_dbg(VFS, "directory entry name would overflow frame end of buf %p\n", 520438c8a9a5SSteve French end_of_buf); 520538c8a9a5SSteve French break; 520638c8a9a5SSteve French } 520738c8a9a5SSteve French 520838c8a9a5SSteve French *lastentry = entryptr; 520938c8a9a5SSteve French entrycount++; 521038c8a9a5SSteve French 521138c8a9a5SSteve French next_offset = le32_to_cpu(dir_info->NextEntryOffset); 521238c8a9a5SSteve French if (!next_offset) 521338c8a9a5SSteve French break; 521438c8a9a5SSteve French } 521538c8a9a5SSteve French 521638c8a9a5SSteve French return entrycount; 521738c8a9a5SSteve French } 521838c8a9a5SSteve French 521938c8a9a5SSteve French /* 522038c8a9a5SSteve French * Readdir/FindFirst 522138c8a9a5SSteve French */ 522238c8a9a5SSteve French int SMB2_query_directory_init(const unsigned int xid, 522338c8a9a5SSteve French struct cifs_tcon *tcon, 522438c8a9a5SSteve French struct TCP_Server_Info *server, 522538c8a9a5SSteve French struct smb_rqst *rqst, 522638c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 522738c8a9a5SSteve French int index, int info_level) 522838c8a9a5SSteve French { 522938c8a9a5SSteve French struct smb2_query_directory_req *req; 523038c8a9a5SSteve French unsigned char *bufptr; 523138c8a9a5SSteve French __le16 asteriks = cpu_to_le16('*'); 523238c8a9a5SSteve French unsigned int output_size = CIFSMaxBufSize - 523338c8a9a5SSteve French MAX_SMB2_CREATE_RESPONSE_SIZE - 523438c8a9a5SSteve French MAX_SMB2_CLOSE_RESPONSE_SIZE; 523538c8a9a5SSteve French unsigned int total_len; 523638c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 523738c8a9a5SSteve French int len, rc; 523838c8a9a5SSteve French 523938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server, 524038c8a9a5SSteve French (void **) &req, &total_len); 524138c8a9a5SSteve French if (rc) 524238c8a9a5SSteve French return rc; 524338c8a9a5SSteve French 524438c8a9a5SSteve French switch (info_level) { 524538c8a9a5SSteve French case SMB_FIND_FILE_DIRECTORY_INFO: 524638c8a9a5SSteve French req->FileInformationClass = FILE_DIRECTORY_INFORMATION; 524738c8a9a5SSteve French break; 524838c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO: 524938c8a9a5SSteve French req->FileInformationClass = FILEID_FULL_DIRECTORY_INFORMATION; 525038c8a9a5SSteve French break; 525138c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 525238c8a9a5SSteve French req->FileInformationClass = SMB_FIND_FILE_POSIX_INFO; 525338c8a9a5SSteve French break; 5254cacc0a9cSPaulo Alcantara case SMB_FIND_FILE_FULL_DIRECTORY_INFO: 5255cacc0a9cSPaulo Alcantara req->FileInformationClass = FILE_FULL_DIRECTORY_INFORMATION; 5256cacc0a9cSPaulo Alcantara break; 525738c8a9a5SSteve French default: 525838c8a9a5SSteve French cifs_tcon_dbg(VFS, "info level %u isn't supported\n", 525938c8a9a5SSteve French info_level); 526038c8a9a5SSteve French return -EINVAL; 526138c8a9a5SSteve French } 526238c8a9a5SSteve French 526338c8a9a5SSteve French req->FileIndex = cpu_to_le32(index); 526438c8a9a5SSteve French req->PersistentFileId = persistent_fid; 526538c8a9a5SSteve French req->VolatileFileId = volatile_fid; 526638c8a9a5SSteve French 526738c8a9a5SSteve French len = 0x2; 526838c8a9a5SSteve French bufptr = req->Buffer; 526938c8a9a5SSteve French memcpy(bufptr, &asteriks, len); 527038c8a9a5SSteve French 527138c8a9a5SSteve French req->FileNameOffset = 527238c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_query_directory_req)); 527338c8a9a5SSteve French req->FileNameLength = cpu_to_le16(len); 527438c8a9a5SSteve French /* 527538c8a9a5SSteve French * BB could be 30 bytes or so longer if we used SMB2 specific 527638c8a9a5SSteve French * buffer lengths, but this is safe and close enough. 527738c8a9a5SSteve French */ 527838c8a9a5SSteve French output_size = min_t(unsigned int, output_size, server->maxBuf); 527938c8a9a5SSteve French output_size = min_t(unsigned int, output_size, 2 << 15); 528038c8a9a5SSteve French req->OutputBufferLength = cpu_to_le32(output_size); 528138c8a9a5SSteve French 528238c8a9a5SSteve French iov[0].iov_base = (char *)req; 528338c8a9a5SSteve French /* 1 for Buffer */ 528438c8a9a5SSteve French iov[0].iov_len = total_len - 1; 528538c8a9a5SSteve French 528638c8a9a5SSteve French iov[1].iov_base = (char *)(req->Buffer); 528738c8a9a5SSteve French iov[1].iov_len = len; 528838c8a9a5SSteve French 528938c8a9a5SSteve French trace_smb3_query_dir_enter(xid, persistent_fid, tcon->tid, 529038c8a9a5SSteve French tcon->ses->Suid, index, output_size); 529138c8a9a5SSteve French 529238c8a9a5SSteve French return 0; 529338c8a9a5SSteve French } 529438c8a9a5SSteve French 529538c8a9a5SSteve French void SMB2_query_directory_free(struct smb_rqst *rqst) 529638c8a9a5SSteve French { 529738c8a9a5SSteve French if (rqst && rqst->rq_iov) { 529838c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ 529938c8a9a5SSteve French } 530038c8a9a5SSteve French } 530138c8a9a5SSteve French 530238c8a9a5SSteve French int 530338c8a9a5SSteve French smb2_parse_query_directory(struct cifs_tcon *tcon, 530438c8a9a5SSteve French struct kvec *rsp_iov, 530538c8a9a5SSteve French int resp_buftype, 530638c8a9a5SSteve French struct cifs_search_info *srch_inf) 530738c8a9a5SSteve French { 530838c8a9a5SSteve French struct smb2_query_directory_rsp *rsp; 530938c8a9a5SSteve French size_t info_buf_size; 531038c8a9a5SSteve French char *end_of_smb; 531138c8a9a5SSteve French int rc; 531238c8a9a5SSteve French 531338c8a9a5SSteve French rsp = (struct smb2_query_directory_rsp *)rsp_iov->iov_base; 531438c8a9a5SSteve French 531538c8a9a5SSteve French switch (srch_inf->info_level) { 531638c8a9a5SSteve French case SMB_FIND_FILE_DIRECTORY_INFO: 531738c8a9a5SSteve French info_buf_size = sizeof(FILE_DIRECTORY_INFO); 531838c8a9a5SSteve French break; 531938c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO: 532038c8a9a5SSteve French info_buf_size = sizeof(SEARCH_ID_FULL_DIR_INFO); 532138c8a9a5SSteve French break; 532238c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO: 532338c8a9a5SSteve French /* note that posix payload are variable size */ 532438c8a9a5SSteve French info_buf_size = sizeof(struct smb2_posix_info); 532538c8a9a5SSteve French break; 5326cacc0a9cSPaulo Alcantara case SMB_FIND_FILE_FULL_DIRECTORY_INFO: 5327cacc0a9cSPaulo Alcantara info_buf_size = sizeof(FILE_FULL_DIRECTORY_INFO); 5328cacc0a9cSPaulo Alcantara break; 532938c8a9a5SSteve French default: 533038c8a9a5SSteve French cifs_tcon_dbg(VFS, "info level %u isn't supported\n", 533138c8a9a5SSteve French srch_inf->info_level); 533238c8a9a5SSteve French return -EINVAL; 533338c8a9a5SSteve French } 533438c8a9a5SSteve French 533538c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset), 533638c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), rsp_iov, 533738c8a9a5SSteve French info_buf_size); 533838c8a9a5SSteve French if (rc) { 533938c8a9a5SSteve French cifs_tcon_dbg(VFS, "bad info payload"); 534038c8a9a5SSteve French return rc; 534138c8a9a5SSteve French } 534238c8a9a5SSteve French 534338c8a9a5SSteve French srch_inf->unicode = true; 534438c8a9a5SSteve French 534538c8a9a5SSteve French if (srch_inf->ntwrk_buf_start) { 534638c8a9a5SSteve French if (srch_inf->smallBuf) 534738c8a9a5SSteve French cifs_small_buf_release(srch_inf->ntwrk_buf_start); 534838c8a9a5SSteve French else 534938c8a9a5SSteve French cifs_buf_release(srch_inf->ntwrk_buf_start); 535038c8a9a5SSteve French } 535138c8a9a5SSteve French srch_inf->ntwrk_buf_start = (char *)rsp; 535238c8a9a5SSteve French srch_inf->srch_entries_start = srch_inf->last_entry = 535338c8a9a5SSteve French (char *)rsp + le16_to_cpu(rsp->OutputBufferOffset); 535438c8a9a5SSteve French end_of_smb = rsp_iov->iov_len + (char *)rsp; 535538c8a9a5SSteve French 535638c8a9a5SSteve French srch_inf->entries_in_buffer = num_entries( 535738c8a9a5SSteve French srch_inf->info_level, 535838c8a9a5SSteve French srch_inf->srch_entries_start, 535938c8a9a5SSteve French end_of_smb, 536038c8a9a5SSteve French &srch_inf->last_entry, 536138c8a9a5SSteve French info_buf_size); 536238c8a9a5SSteve French 536338c8a9a5SSteve French srch_inf->index_of_last_entry += srch_inf->entries_in_buffer; 536438c8a9a5SSteve French cifs_dbg(FYI, "num entries %d last_index %lld srch start %p srch end %p\n", 536538c8a9a5SSteve French srch_inf->entries_in_buffer, srch_inf->index_of_last_entry, 536638c8a9a5SSteve French srch_inf->srch_entries_start, srch_inf->last_entry); 536738c8a9a5SSteve French if (resp_buftype == CIFS_LARGE_BUFFER) 536838c8a9a5SSteve French srch_inf->smallBuf = false; 536938c8a9a5SSteve French else if (resp_buftype == CIFS_SMALL_BUFFER) 537038c8a9a5SSteve French srch_inf->smallBuf = true; 537138c8a9a5SSteve French else 537238c8a9a5SSteve French cifs_tcon_dbg(VFS, "Invalid search buffer type\n"); 537338c8a9a5SSteve French 537438c8a9a5SSteve French return 0; 537538c8a9a5SSteve French } 537638c8a9a5SSteve French 537738c8a9a5SSteve French int 537838c8a9a5SSteve French SMB2_query_directory(const unsigned int xid, struct cifs_tcon *tcon, 537938c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, int index, 538038c8a9a5SSteve French struct cifs_search_info *srch_inf) 538138c8a9a5SSteve French { 538238c8a9a5SSteve French struct smb_rqst rqst; 538338c8a9a5SSteve French struct kvec iov[SMB2_QUERY_DIRECTORY_IOV_SIZE]; 538438c8a9a5SSteve French struct smb2_query_directory_rsp *rsp = NULL; 538538c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER; 538638c8a9a5SSteve French struct kvec rsp_iov; 538738c8a9a5SSteve French int rc = 0; 538838c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5389433042a9SShyam Prasad N struct TCP_Server_Info *server; 539038c8a9a5SSteve French int flags = 0; 5391433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5392433042a9SShyam Prasad N 5393433042a9SShyam Prasad N replay_again: 5394433042a9SShyam Prasad N /* reinitialize for possible replay */ 5395433042a9SShyam Prasad N flags = 0; 5396433042a9SShyam Prasad N server = cifs_pick_channel(ses); 539738c8a9a5SSteve French 539838c8a9a5SSteve French if (!ses || !(ses->server)) 539938c8a9a5SSteve French return -EIO; 540038c8a9a5SSteve French 540138c8a9a5SSteve French if (smb3_encryption_required(tcon)) 540238c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 540338c8a9a5SSteve French 540438c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 540538c8a9a5SSteve French memset(&iov, 0, sizeof(iov)); 540638c8a9a5SSteve French rqst.rq_iov = iov; 540738c8a9a5SSteve French rqst.rq_nvec = SMB2_QUERY_DIRECTORY_IOV_SIZE; 540838c8a9a5SSteve French 540938c8a9a5SSteve French rc = SMB2_query_directory_init(xid, tcon, server, 541038c8a9a5SSteve French &rqst, persistent_fid, 541138c8a9a5SSteve French volatile_fid, index, 541238c8a9a5SSteve French srch_inf->info_level); 541338c8a9a5SSteve French if (rc) 541438c8a9a5SSteve French goto qdir_exit; 541538c8a9a5SSteve French 5416433042a9SShyam Prasad N if (retries) 5417433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5418433042a9SShyam Prasad N 541938c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 542038c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 542138c8a9a5SSteve French rsp = (struct smb2_query_directory_rsp *)rsp_iov.iov_base; 542238c8a9a5SSteve French 542338c8a9a5SSteve French if (rc) { 542438c8a9a5SSteve French if (rc == -ENODATA && 542538c8a9a5SSteve French rsp->hdr.Status == STATUS_NO_MORE_FILES) { 542638c8a9a5SSteve French trace_smb3_query_dir_done(xid, persistent_fid, 542738c8a9a5SSteve French tcon->tid, tcon->ses->Suid, index, 0); 542838c8a9a5SSteve French srch_inf->endOfSearch = true; 542938c8a9a5SSteve French rc = 0; 543038c8a9a5SSteve French } else { 543138c8a9a5SSteve French trace_smb3_query_dir_err(xid, persistent_fid, tcon->tid, 543238c8a9a5SSteve French tcon->ses->Suid, index, 0, rc); 543338c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_DIRECTORY_HE); 543438c8a9a5SSteve French } 543538c8a9a5SSteve French goto qdir_exit; 543638c8a9a5SSteve French } 543738c8a9a5SSteve French 543838c8a9a5SSteve French rc = smb2_parse_query_directory(tcon, &rsp_iov, resp_buftype, 543938c8a9a5SSteve French srch_inf); 544038c8a9a5SSteve French if (rc) { 544138c8a9a5SSteve French trace_smb3_query_dir_err(xid, persistent_fid, tcon->tid, 544238c8a9a5SSteve French tcon->ses->Suid, index, 0, rc); 544338c8a9a5SSteve French goto qdir_exit; 544438c8a9a5SSteve French } 544538c8a9a5SSteve French resp_buftype = CIFS_NO_BUFFER; 544638c8a9a5SSteve French 544738c8a9a5SSteve French trace_smb3_query_dir_done(xid, persistent_fid, tcon->tid, 544838c8a9a5SSteve French tcon->ses->Suid, index, srch_inf->entries_in_buffer); 544938c8a9a5SSteve French 545038c8a9a5SSteve French qdir_exit: 545138c8a9a5SSteve French SMB2_query_directory_free(&rqst); 545238c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 5453433042a9SShyam Prasad N 5454433042a9SShyam Prasad N if (is_replayable_error(rc) && 5455433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5456433042a9SShyam Prasad N goto replay_again; 5457433042a9SShyam Prasad N 545838c8a9a5SSteve French return rc; 545938c8a9a5SSteve French } 546038c8a9a5SSteve French 546138c8a9a5SSteve French int 546238c8a9a5SSteve French SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server, 546338c8a9a5SSteve French struct smb_rqst *rqst, 546438c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u32 pid, 546538c8a9a5SSteve French u8 info_class, u8 info_type, u32 additional_info, 546638c8a9a5SSteve French void **data, unsigned int *size) 546738c8a9a5SSteve French { 546838c8a9a5SSteve French struct smb2_set_info_req *req; 546938c8a9a5SSteve French struct kvec *iov = rqst->rq_iov; 547038c8a9a5SSteve French unsigned int i, total_len; 547138c8a9a5SSteve French int rc; 547238c8a9a5SSteve French 547338c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server, 547438c8a9a5SSteve French (void **) &req, &total_len); 547538c8a9a5SSteve French if (rc) 547638c8a9a5SSteve French return rc; 547738c8a9a5SSteve French 547838c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(pid); 547938c8a9a5SSteve French req->InfoType = info_type; 548038c8a9a5SSteve French req->FileInfoClass = info_class; 548138c8a9a5SSteve French req->PersistentFileId = persistent_fid; 548238c8a9a5SSteve French req->VolatileFileId = volatile_fid; 548338c8a9a5SSteve French req->AdditionalInformation = cpu_to_le32(additional_info); 548438c8a9a5SSteve French 548538c8a9a5SSteve French req->BufferOffset = cpu_to_le16(sizeof(struct smb2_set_info_req)); 548638c8a9a5SSteve French req->BufferLength = cpu_to_le32(*size); 548738c8a9a5SSteve French 548838c8a9a5SSteve French memcpy(req->Buffer, *data, *size); 548938c8a9a5SSteve French total_len += *size; 549038c8a9a5SSteve French 549138c8a9a5SSteve French iov[0].iov_base = (char *)req; 549238c8a9a5SSteve French /* 1 for Buffer */ 549338c8a9a5SSteve French iov[0].iov_len = total_len - 1; 549438c8a9a5SSteve French 549538c8a9a5SSteve French for (i = 1; i < rqst->rq_nvec; i++) { 549638c8a9a5SSteve French le32_add_cpu(&req->BufferLength, size[i]); 549738c8a9a5SSteve French iov[i].iov_base = (char *)data[i]; 549838c8a9a5SSteve French iov[i].iov_len = size[i]; 549938c8a9a5SSteve French } 550038c8a9a5SSteve French 550138c8a9a5SSteve French return 0; 550238c8a9a5SSteve French } 550338c8a9a5SSteve French 550438c8a9a5SSteve French void 550538c8a9a5SSteve French SMB2_set_info_free(struct smb_rqst *rqst) 550638c8a9a5SSteve French { 550738c8a9a5SSteve French if (rqst && rqst->rq_iov) 550838c8a9a5SSteve French cifs_buf_release(rqst->rq_iov[0].iov_base); /* request */ 550938c8a9a5SSteve French } 551038c8a9a5SSteve French 551138c8a9a5SSteve French static int 551238c8a9a5SSteve French send_set_info(const unsigned int xid, struct cifs_tcon *tcon, 551338c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u32 pid, u8 info_class, 551438c8a9a5SSteve French u8 info_type, u32 additional_info, unsigned int num, 551538c8a9a5SSteve French void **data, unsigned int *size) 551638c8a9a5SSteve French { 551738c8a9a5SSteve French struct smb_rqst rqst; 551838c8a9a5SSteve French struct smb2_set_info_rsp *rsp = NULL; 551938c8a9a5SSteve French struct kvec *iov; 552038c8a9a5SSteve French struct kvec rsp_iov; 552138c8a9a5SSteve French int rc = 0; 552238c8a9a5SSteve French int resp_buftype; 552338c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5524433042a9SShyam Prasad N struct TCP_Server_Info *server; 552538c8a9a5SSteve French int flags = 0; 5526433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5527433042a9SShyam Prasad N 5528433042a9SShyam Prasad N replay_again: 5529433042a9SShyam Prasad N /* reinitialize for possible replay */ 5530433042a9SShyam Prasad N flags = 0; 5531433042a9SShyam Prasad N server = cifs_pick_channel(ses); 553238c8a9a5SSteve French 553338c8a9a5SSteve French if (!ses || !server) 553438c8a9a5SSteve French return -EIO; 553538c8a9a5SSteve French 553638c8a9a5SSteve French if (!num) 553738c8a9a5SSteve French return -EINVAL; 553838c8a9a5SSteve French 553938c8a9a5SSteve French if (smb3_encryption_required(tcon)) 554038c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 554138c8a9a5SSteve French 554238c8a9a5SSteve French iov = kmalloc_array(num, sizeof(struct kvec), GFP_KERNEL); 554338c8a9a5SSteve French if (!iov) 554438c8a9a5SSteve French return -ENOMEM; 554538c8a9a5SSteve French 554638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 554738c8a9a5SSteve French rqst.rq_iov = iov; 554838c8a9a5SSteve French rqst.rq_nvec = num; 554938c8a9a5SSteve French 555038c8a9a5SSteve French rc = SMB2_set_info_init(tcon, server, 555138c8a9a5SSteve French &rqst, persistent_fid, volatile_fid, pid, 555238c8a9a5SSteve French info_class, info_type, additional_info, 555338c8a9a5SSteve French data, size); 555438c8a9a5SSteve French if (rc) { 555538c8a9a5SSteve French kfree(iov); 555638c8a9a5SSteve French return rc; 555738c8a9a5SSteve French } 555838c8a9a5SSteve French 5559433042a9SShyam Prasad N if (retries) 5560433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 556138c8a9a5SSteve French 556238c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 556338c8a9a5SSteve French &rqst, &resp_buftype, flags, 556438c8a9a5SSteve French &rsp_iov); 556538c8a9a5SSteve French SMB2_set_info_free(&rqst); 556638c8a9a5SSteve French rsp = (struct smb2_set_info_rsp *)rsp_iov.iov_base; 556738c8a9a5SSteve French 556838c8a9a5SSteve French if (rc != 0) { 556938c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_SET_INFO_HE); 557038c8a9a5SSteve French trace_smb3_set_info_err(xid, persistent_fid, tcon->tid, 557138c8a9a5SSteve French ses->Suid, info_class, (__u32)info_type, rc); 557238c8a9a5SSteve French } 557338c8a9a5SSteve French 557438c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp); 557538c8a9a5SSteve French kfree(iov); 5576433042a9SShyam Prasad N 5577433042a9SShyam Prasad N if (is_replayable_error(rc) && 5578433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5579433042a9SShyam Prasad N goto replay_again; 5580433042a9SShyam Prasad N 558138c8a9a5SSteve French return rc; 558238c8a9a5SSteve French } 558338c8a9a5SSteve French 558438c8a9a5SSteve French int 558538c8a9a5SSteve French SMB2_set_eof(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, 5586774c6452SDavid Howells u64 volatile_fid, u32 pid, loff_t new_eof) 558738c8a9a5SSteve French { 558838c8a9a5SSteve French struct smb2_file_eof_info info; 558938c8a9a5SSteve French void *data; 559038c8a9a5SSteve French unsigned int size; 559138c8a9a5SSteve French 5592774c6452SDavid Howells info.EndOfFile = cpu_to_le64(new_eof); 559338c8a9a5SSteve French 559438c8a9a5SSteve French data = &info; 559538c8a9a5SSteve French size = sizeof(struct smb2_file_eof_info); 559638c8a9a5SSteve French 5597774c6452SDavid Howells trace_smb3_set_eof(xid, persistent_fid, tcon->tid, tcon->ses->Suid, new_eof); 559838c8a9a5SSteve French 559938c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid, 560038c8a9a5SSteve French pid, FILE_END_OF_FILE_INFORMATION, SMB2_O_INFO_FILE, 560138c8a9a5SSteve French 0, 1, &data, &size); 560238c8a9a5SSteve French } 560338c8a9a5SSteve French 560438c8a9a5SSteve French int 560538c8a9a5SSteve French SMB2_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 560638c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 560738c8a9a5SSteve French struct cifs_ntsd *pnntsd, int pacllen, int aclflag) 560838c8a9a5SSteve French { 560938c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid, 561038c8a9a5SSteve French current->tgid, 0, SMB2_O_INFO_SECURITY, aclflag, 561138c8a9a5SSteve French 1, (void **)&pnntsd, &pacllen); 561238c8a9a5SSteve French } 561338c8a9a5SSteve French 561438c8a9a5SSteve French int 561538c8a9a5SSteve French SMB2_set_ea(const unsigned int xid, struct cifs_tcon *tcon, 561638c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, 561738c8a9a5SSteve French struct smb2_file_full_ea_info *buf, int len) 561838c8a9a5SSteve French { 561938c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid, 562038c8a9a5SSteve French current->tgid, FILE_FULL_EA_INFORMATION, SMB2_O_INFO_FILE, 562138c8a9a5SSteve French 0, 1, (void **)&buf, &len); 562238c8a9a5SSteve French } 562338c8a9a5SSteve French 562438c8a9a5SSteve French int 562538c8a9a5SSteve French SMB2_oplock_break(const unsigned int xid, struct cifs_tcon *tcon, 562638c8a9a5SSteve French const u64 persistent_fid, const u64 volatile_fid, 562738c8a9a5SSteve French __u8 oplock_level) 562838c8a9a5SSteve French { 562938c8a9a5SSteve French struct smb_rqst rqst; 563038c8a9a5SSteve French int rc; 563138c8a9a5SSteve French struct smb2_oplock_break *req = NULL; 563238c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5633433042a9SShyam Prasad N struct TCP_Server_Info *server; 563438c8a9a5SSteve French int flags = CIFS_OBREAK_OP; 563538c8a9a5SSteve French unsigned int total_len; 563638c8a9a5SSteve French struct kvec iov[1]; 563738c8a9a5SSteve French struct kvec rsp_iov; 563838c8a9a5SSteve French int resp_buf_type; 5639433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5640433042a9SShyam Prasad N 5641433042a9SShyam Prasad N replay_again: 5642433042a9SShyam Prasad N /* reinitialize for possible replay */ 5643433042a9SShyam Prasad N flags = CIFS_OBREAK_OP; 5644433042a9SShyam Prasad N server = cifs_pick_channel(ses); 564538c8a9a5SSteve French 564638c8a9a5SSteve French cifs_dbg(FYI, "SMB2_oplock_break\n"); 564738c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server, 564838c8a9a5SSteve French (void **) &req, &total_len); 564938c8a9a5SSteve French if (rc) 565038c8a9a5SSteve French return rc; 565138c8a9a5SSteve French 565238c8a9a5SSteve French if (smb3_encryption_required(tcon)) 565338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 565438c8a9a5SSteve French 565538c8a9a5SSteve French req->VolatileFid = volatile_fid; 565638c8a9a5SSteve French req->PersistentFid = persistent_fid; 565738c8a9a5SSteve French req->OplockLevel = oplock_level; 565838c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1); 565938c8a9a5SSteve French 566038c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF; 566138c8a9a5SSteve French 566238c8a9a5SSteve French iov[0].iov_base = (char *)req; 566338c8a9a5SSteve French iov[0].iov_len = total_len; 566438c8a9a5SSteve French 566538c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 566638c8a9a5SSteve French rqst.rq_iov = iov; 566738c8a9a5SSteve French rqst.rq_nvec = 1; 566838c8a9a5SSteve French 5669433042a9SShyam Prasad N if (retries) 5670433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5671433042a9SShyam Prasad N 567238c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 567338c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov); 567438c8a9a5SSteve French cifs_small_buf_release(req); 567538c8a9a5SSteve French if (rc) { 567638c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE); 567738c8a9a5SSteve French cifs_dbg(FYI, "Send error in Oplock Break = %d\n", rc); 567838c8a9a5SSteve French } 567938c8a9a5SSteve French 5680433042a9SShyam Prasad N if (is_replayable_error(rc) && 5681433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5682433042a9SShyam Prasad N goto replay_again; 5683433042a9SShyam Prasad N 568438c8a9a5SSteve French return rc; 568538c8a9a5SSteve French } 568638c8a9a5SSteve French 568738c8a9a5SSteve French void 568838c8a9a5SSteve French smb2_copy_fs_info_to_kstatfs(struct smb2_fs_full_size_info *pfs_inf, 568938c8a9a5SSteve French struct kstatfs *kst) 569038c8a9a5SSteve French { 569138c8a9a5SSteve French kst->f_bsize = le32_to_cpu(pfs_inf->BytesPerSector) * 569238c8a9a5SSteve French le32_to_cpu(pfs_inf->SectorsPerAllocationUnit); 569338c8a9a5SSteve French kst->f_blocks = le64_to_cpu(pfs_inf->TotalAllocationUnits); 569438c8a9a5SSteve French kst->f_bfree = kst->f_bavail = 569538c8a9a5SSteve French le64_to_cpu(pfs_inf->CallerAvailableAllocationUnits); 569638c8a9a5SSteve French return; 569738c8a9a5SSteve French } 569838c8a9a5SSteve French 569938c8a9a5SSteve French static void 570038c8a9a5SSteve French copy_posix_fs_info_to_kstatfs(FILE_SYSTEM_POSIX_INFO *response_data, 570138c8a9a5SSteve French struct kstatfs *kst) 570238c8a9a5SSteve French { 570338c8a9a5SSteve French kst->f_bsize = le32_to_cpu(response_data->BlockSize); 570438c8a9a5SSteve French kst->f_blocks = le64_to_cpu(response_data->TotalBlocks); 570538c8a9a5SSteve French kst->f_bfree = le64_to_cpu(response_data->BlocksAvail); 570638c8a9a5SSteve French if (response_data->UserBlocksAvail == cpu_to_le64(-1)) 570738c8a9a5SSteve French kst->f_bavail = kst->f_bfree; 570838c8a9a5SSteve French else 570938c8a9a5SSteve French kst->f_bavail = le64_to_cpu(response_data->UserBlocksAvail); 571038c8a9a5SSteve French if (response_data->TotalFileNodes != cpu_to_le64(-1)) 571138c8a9a5SSteve French kst->f_files = le64_to_cpu(response_data->TotalFileNodes); 571238c8a9a5SSteve French if (response_data->FreeFileNodes != cpu_to_le64(-1)) 571338c8a9a5SSteve French kst->f_ffree = le64_to_cpu(response_data->FreeFileNodes); 571438c8a9a5SSteve French 571538c8a9a5SSteve French return; 571638c8a9a5SSteve French } 571738c8a9a5SSteve French 571838c8a9a5SSteve French static int 571938c8a9a5SSteve French build_qfs_info_req(struct kvec *iov, struct cifs_tcon *tcon, 572038c8a9a5SSteve French struct TCP_Server_Info *server, 572138c8a9a5SSteve French int level, int outbuf_len, u64 persistent_fid, 572238c8a9a5SSteve French u64 volatile_fid) 572338c8a9a5SSteve French { 572438c8a9a5SSteve French int rc; 572538c8a9a5SSteve French struct smb2_query_info_req *req; 572638c8a9a5SSteve French unsigned int total_len; 572738c8a9a5SSteve French 572838c8a9a5SSteve French cifs_dbg(FYI, "Query FSInfo level %d\n", level); 572938c8a9a5SSteve French 573038c8a9a5SSteve French if ((tcon->ses == NULL) || server == NULL) 573138c8a9a5SSteve French return -EIO; 573238c8a9a5SSteve French 573338c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server, 573438c8a9a5SSteve French (void **) &req, &total_len); 573538c8a9a5SSteve French if (rc) 573638c8a9a5SSteve French return rc; 573738c8a9a5SSteve French 573838c8a9a5SSteve French req->InfoType = SMB2_O_INFO_FILESYSTEM; 573938c8a9a5SSteve French req->FileInfoClass = level; 574038c8a9a5SSteve French req->PersistentFileId = persistent_fid; 574138c8a9a5SSteve French req->VolatileFileId = volatile_fid; 574238c8a9a5SSteve French /* 1 for pad */ 574338c8a9a5SSteve French req->InputBufferOffset = 574438c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_query_info_req)); 574538c8a9a5SSteve French req->OutputBufferLength = cpu_to_le32( 574638c8a9a5SSteve French outbuf_len + sizeof(struct smb2_query_info_rsp)); 574738c8a9a5SSteve French 574838c8a9a5SSteve French iov->iov_base = (char *)req; 574938c8a9a5SSteve French iov->iov_len = total_len; 575038c8a9a5SSteve French return 0; 575138c8a9a5SSteve French } 575238c8a9a5SSteve French 57533b5f0d0aSPaulo Alcantara static inline void free_qfs_info_req(struct kvec *iov) 57543b5f0d0aSPaulo Alcantara { 57553b5f0d0aSPaulo Alcantara cifs_buf_release(iov->iov_base); 57563b5f0d0aSPaulo Alcantara } 57573b5f0d0aSPaulo Alcantara 575838c8a9a5SSteve French int 575938c8a9a5SSteve French SMB311_posix_qfs_info(const unsigned int xid, struct cifs_tcon *tcon, 576038c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata) 576138c8a9a5SSteve French { 576238c8a9a5SSteve French struct smb_rqst rqst; 576338c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL; 576438c8a9a5SSteve French struct kvec iov; 576538c8a9a5SSteve French struct kvec rsp_iov; 576638c8a9a5SSteve French int rc = 0; 576738c8a9a5SSteve French int resp_buftype; 576838c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5769433042a9SShyam Prasad N struct TCP_Server_Info *server; 577038c8a9a5SSteve French FILE_SYSTEM_POSIX_INFO *info = NULL; 577138c8a9a5SSteve French int flags = 0; 5772433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5773433042a9SShyam Prasad N 5774433042a9SShyam Prasad N replay_again: 5775433042a9SShyam Prasad N /* reinitialize for possible replay */ 5776433042a9SShyam Prasad N flags = 0; 5777433042a9SShyam Prasad N server = cifs_pick_channel(ses); 577838c8a9a5SSteve French 577938c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server, 578038c8a9a5SSteve French FS_POSIX_INFORMATION, 578138c8a9a5SSteve French sizeof(FILE_SYSTEM_POSIX_INFO), 578238c8a9a5SSteve French persistent_fid, volatile_fid); 578338c8a9a5SSteve French if (rc) 578438c8a9a5SSteve French return rc; 578538c8a9a5SSteve French 578638c8a9a5SSteve French if (smb3_encryption_required(tcon)) 578738c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 578838c8a9a5SSteve French 578938c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 579038c8a9a5SSteve French rqst.rq_iov = &iov; 579138c8a9a5SSteve French rqst.rq_nvec = 1; 579238c8a9a5SSteve French 5793433042a9SShyam Prasad N if (retries) 5794433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5795433042a9SShyam Prasad N 579638c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 579738c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 57983b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov); 579938c8a9a5SSteve French if (rc) { 580038c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE); 580138c8a9a5SSteve French goto posix_qfsinf_exit; 580238c8a9a5SSteve French } 580338c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base; 580438c8a9a5SSteve French 580538c8a9a5SSteve French info = (FILE_SYSTEM_POSIX_INFO *)( 580638c8a9a5SSteve French le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp); 580738c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset), 580838c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), &rsp_iov, 580938c8a9a5SSteve French sizeof(FILE_SYSTEM_POSIX_INFO)); 581038c8a9a5SSteve French if (!rc) 581138c8a9a5SSteve French copy_posix_fs_info_to_kstatfs(info, fsdata); 581238c8a9a5SSteve French 581338c8a9a5SSteve French posix_qfsinf_exit: 581438c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 5815433042a9SShyam Prasad N 5816433042a9SShyam Prasad N if (is_replayable_error(rc) && 5817433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5818433042a9SShyam Prasad N goto replay_again; 5819433042a9SShyam Prasad N 582038c8a9a5SSteve French return rc; 582138c8a9a5SSteve French } 582238c8a9a5SSteve French 582338c8a9a5SSteve French int 582438c8a9a5SSteve French SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon, 582538c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata) 582638c8a9a5SSteve French { 582738c8a9a5SSteve French struct smb_rqst rqst; 582838c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL; 582938c8a9a5SSteve French struct kvec iov; 583038c8a9a5SSteve French struct kvec rsp_iov; 583138c8a9a5SSteve French int rc = 0; 583238c8a9a5SSteve French int resp_buftype; 583338c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5834433042a9SShyam Prasad N struct TCP_Server_Info *server; 583538c8a9a5SSteve French struct smb2_fs_full_size_info *info = NULL; 583638c8a9a5SSteve French int flags = 0; 5837433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5838433042a9SShyam Prasad N 5839433042a9SShyam Prasad N replay_again: 5840433042a9SShyam Prasad N /* reinitialize for possible replay */ 5841433042a9SShyam Prasad N flags = 0; 5842433042a9SShyam Prasad N server = cifs_pick_channel(ses); 584338c8a9a5SSteve French 584438c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server, 584538c8a9a5SSteve French FS_FULL_SIZE_INFORMATION, 584638c8a9a5SSteve French sizeof(struct smb2_fs_full_size_info), 584738c8a9a5SSteve French persistent_fid, volatile_fid); 584838c8a9a5SSteve French if (rc) 584938c8a9a5SSteve French return rc; 585038c8a9a5SSteve French 585138c8a9a5SSteve French if (smb3_encryption_required(tcon)) 585238c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 585338c8a9a5SSteve French 585438c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 585538c8a9a5SSteve French rqst.rq_iov = &iov; 585638c8a9a5SSteve French rqst.rq_nvec = 1; 585738c8a9a5SSteve French 5858433042a9SShyam Prasad N if (retries) 5859433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5860433042a9SShyam Prasad N 586138c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 586238c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 58633b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov); 586438c8a9a5SSteve French if (rc) { 586538c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE); 586638c8a9a5SSteve French goto qfsinf_exit; 586738c8a9a5SSteve French } 586838c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base; 586938c8a9a5SSteve French 587038c8a9a5SSteve French info = (struct smb2_fs_full_size_info *)( 587138c8a9a5SSteve French le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp); 587238c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset), 587338c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), &rsp_iov, 587438c8a9a5SSteve French sizeof(struct smb2_fs_full_size_info)); 587538c8a9a5SSteve French if (!rc) 587638c8a9a5SSteve French smb2_copy_fs_info_to_kstatfs(info, fsdata); 587738c8a9a5SSteve French 587838c8a9a5SSteve French qfsinf_exit: 587938c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 5880433042a9SShyam Prasad N 5881433042a9SShyam Prasad N if (is_replayable_error(rc) && 5882433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5883433042a9SShyam Prasad N goto replay_again; 5884433042a9SShyam Prasad N 588538c8a9a5SSteve French return rc; 588638c8a9a5SSteve French } 588738c8a9a5SSteve French 588838c8a9a5SSteve French int 588938c8a9a5SSteve French SMB2_QFS_attr(const unsigned int xid, struct cifs_tcon *tcon, 589038c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, int level) 589138c8a9a5SSteve French { 589238c8a9a5SSteve French struct smb_rqst rqst; 589338c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL; 589438c8a9a5SSteve French struct kvec iov; 589538c8a9a5SSteve French struct kvec rsp_iov; 589638c8a9a5SSteve French int rc = 0; 589738c8a9a5SSteve French int resp_buftype, max_len, min_len; 589838c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 5899433042a9SShyam Prasad N struct TCP_Server_Info *server; 590038c8a9a5SSteve French unsigned int rsp_len, offset; 590138c8a9a5SSteve French int flags = 0; 5902433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 5903433042a9SShyam Prasad N 5904433042a9SShyam Prasad N replay_again: 5905433042a9SShyam Prasad N /* reinitialize for possible replay */ 5906433042a9SShyam Prasad N flags = 0; 5907433042a9SShyam Prasad N server = cifs_pick_channel(ses); 590838c8a9a5SSteve French 590938c8a9a5SSteve French if (level == FS_DEVICE_INFORMATION) { 591038c8a9a5SSteve French max_len = sizeof(FILE_SYSTEM_DEVICE_INFO); 591138c8a9a5SSteve French min_len = sizeof(FILE_SYSTEM_DEVICE_INFO); 591238c8a9a5SSteve French } else if (level == FS_ATTRIBUTE_INFORMATION) { 591338c8a9a5SSteve French max_len = sizeof(FILE_SYSTEM_ATTRIBUTE_INFO); 591438c8a9a5SSteve French min_len = MIN_FS_ATTR_INFO_SIZE; 591538c8a9a5SSteve French } else if (level == FS_SECTOR_SIZE_INFORMATION) { 591638c8a9a5SSteve French max_len = sizeof(struct smb3_fs_ss_info); 591738c8a9a5SSteve French min_len = sizeof(struct smb3_fs_ss_info); 591838c8a9a5SSteve French } else if (level == FS_VOLUME_INFORMATION) { 591938c8a9a5SSteve French max_len = sizeof(struct smb3_fs_vol_info) + MAX_VOL_LABEL_LEN; 592038c8a9a5SSteve French min_len = sizeof(struct smb3_fs_vol_info); 592138c8a9a5SSteve French } else { 592238c8a9a5SSteve French cifs_dbg(FYI, "Invalid qfsinfo level %d\n", level); 592338c8a9a5SSteve French return -EINVAL; 592438c8a9a5SSteve French } 592538c8a9a5SSteve French 592638c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server, 592738c8a9a5SSteve French level, max_len, 592838c8a9a5SSteve French persistent_fid, volatile_fid); 592938c8a9a5SSteve French if (rc) 593038c8a9a5SSteve French return rc; 593138c8a9a5SSteve French 593238c8a9a5SSteve French if (smb3_encryption_required(tcon)) 593338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 593438c8a9a5SSteve French 593538c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 593638c8a9a5SSteve French rqst.rq_iov = &iov; 593738c8a9a5SSteve French rqst.rq_nvec = 1; 593838c8a9a5SSteve French 5939433042a9SShyam Prasad N if (retries) 5940433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 5941433042a9SShyam Prasad N 594238c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 594338c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov); 59443b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov); 594538c8a9a5SSteve French if (rc) { 594638c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE); 594738c8a9a5SSteve French goto qfsattr_exit; 594838c8a9a5SSteve French } 594938c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base; 595038c8a9a5SSteve French 595138c8a9a5SSteve French rsp_len = le32_to_cpu(rsp->OutputBufferLength); 595238c8a9a5SSteve French offset = le16_to_cpu(rsp->OutputBufferOffset); 595338c8a9a5SSteve French rc = smb2_validate_iov(offset, rsp_len, &rsp_iov, min_len); 595438c8a9a5SSteve French if (rc) 595538c8a9a5SSteve French goto qfsattr_exit; 595638c8a9a5SSteve French 595738c8a9a5SSteve French if (level == FS_ATTRIBUTE_INFORMATION) 595838c8a9a5SSteve French memcpy(&tcon->fsAttrInfo, offset 595938c8a9a5SSteve French + (char *)rsp, min_t(unsigned int, 596038c8a9a5SSteve French rsp_len, max_len)); 596138c8a9a5SSteve French else if (level == FS_DEVICE_INFORMATION) 596238c8a9a5SSteve French memcpy(&tcon->fsDevInfo, offset 596338c8a9a5SSteve French + (char *)rsp, sizeof(FILE_SYSTEM_DEVICE_INFO)); 596438c8a9a5SSteve French else if (level == FS_SECTOR_SIZE_INFORMATION) { 596538c8a9a5SSteve French struct smb3_fs_ss_info *ss_info = (struct smb3_fs_ss_info *) 596638c8a9a5SSteve French (offset + (char *)rsp); 596738c8a9a5SSteve French tcon->ss_flags = le32_to_cpu(ss_info->Flags); 596838c8a9a5SSteve French tcon->perf_sector_size = 596938c8a9a5SSteve French le32_to_cpu(ss_info->PhysicalBytesPerSectorForPerf); 597038c8a9a5SSteve French } else if (level == FS_VOLUME_INFORMATION) { 597138c8a9a5SSteve French struct smb3_fs_vol_info *vol_info = (struct smb3_fs_vol_info *) 597238c8a9a5SSteve French (offset + (char *)rsp); 597338c8a9a5SSteve French tcon->vol_serial_number = vol_info->VolumeSerialNumber; 597438c8a9a5SSteve French tcon->vol_create_time = vol_info->VolumeCreationTime; 597538c8a9a5SSteve French } 597638c8a9a5SSteve French 597738c8a9a5SSteve French qfsattr_exit: 597838c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base); 5979433042a9SShyam Prasad N 5980433042a9SShyam Prasad N if (is_replayable_error(rc) && 5981433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 5982433042a9SShyam Prasad N goto replay_again; 5983433042a9SShyam Prasad N 598438c8a9a5SSteve French return rc; 598538c8a9a5SSteve French } 598638c8a9a5SSteve French 598738c8a9a5SSteve French int 598838c8a9a5SSteve French smb2_lockv(const unsigned int xid, struct cifs_tcon *tcon, 598938c8a9a5SSteve French const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid, 599038c8a9a5SSteve French const __u32 num_lock, struct smb2_lock_element *buf) 599138c8a9a5SSteve French { 599238c8a9a5SSteve French struct smb_rqst rqst; 599338c8a9a5SSteve French int rc = 0; 599438c8a9a5SSteve French struct smb2_lock_req *req = NULL; 599538c8a9a5SSteve French struct kvec iov[2]; 599638c8a9a5SSteve French struct kvec rsp_iov; 599738c8a9a5SSteve French int resp_buf_type; 599838c8a9a5SSteve French unsigned int count; 599938c8a9a5SSteve French int flags = CIFS_NO_RSP_BUF; 600038c8a9a5SSteve French unsigned int total_len; 6001433042a9SShyam Prasad N struct TCP_Server_Info *server; 6002433042a9SShyam Prasad N int retries = 0, cur_sleep = 1; 6003433042a9SShyam Prasad N 6004433042a9SShyam Prasad N replay_again: 6005433042a9SShyam Prasad N /* reinitialize for possible replay */ 6006433042a9SShyam Prasad N flags = CIFS_NO_RSP_BUF; 6007433042a9SShyam Prasad N server = cifs_pick_channel(tcon->ses); 600838c8a9a5SSteve French 600938c8a9a5SSteve French cifs_dbg(FYI, "smb2_lockv num lock %d\n", num_lock); 601038c8a9a5SSteve French 601138c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_LOCK, tcon, server, 601238c8a9a5SSteve French (void **) &req, &total_len); 601338c8a9a5SSteve French if (rc) 601438c8a9a5SSteve French return rc; 601538c8a9a5SSteve French 601638c8a9a5SSteve French if (smb3_encryption_required(tcon)) 601738c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 601838c8a9a5SSteve French 601938c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(pid); 602038c8a9a5SSteve French req->LockCount = cpu_to_le16(num_lock); 602138c8a9a5SSteve French 602238c8a9a5SSteve French req->PersistentFileId = persist_fid; 602338c8a9a5SSteve French req->VolatileFileId = volatile_fid; 602438c8a9a5SSteve French 602538c8a9a5SSteve French count = num_lock * sizeof(struct smb2_lock_element); 602638c8a9a5SSteve French 602738c8a9a5SSteve French iov[0].iov_base = (char *)req; 602838c8a9a5SSteve French iov[0].iov_len = total_len - sizeof(struct smb2_lock_element); 602938c8a9a5SSteve French iov[1].iov_base = (char *)buf; 603038c8a9a5SSteve French iov[1].iov_len = count; 603138c8a9a5SSteve French 603238c8a9a5SSteve French cifs_stats_inc(&tcon->stats.cifs_stats.num_locks); 603338c8a9a5SSteve French 603438c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 603538c8a9a5SSteve French rqst.rq_iov = iov; 603638c8a9a5SSteve French rqst.rq_nvec = 2; 603738c8a9a5SSteve French 6038433042a9SShyam Prasad N if (retries) 6039433042a9SShyam Prasad N smb2_set_replay(server, &rqst); 6040433042a9SShyam Prasad N 604138c8a9a5SSteve French rc = cifs_send_recv(xid, tcon->ses, server, 604238c8a9a5SSteve French &rqst, &resp_buf_type, flags, 604338c8a9a5SSteve French &rsp_iov); 604438c8a9a5SSteve French cifs_small_buf_release(req); 604538c8a9a5SSteve French if (rc) { 604638c8a9a5SSteve French cifs_dbg(FYI, "Send error in smb2_lockv = %d\n", rc); 604738c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_LOCK_HE); 604838c8a9a5SSteve French trace_smb3_lock_err(xid, persist_fid, tcon->tid, 604938c8a9a5SSteve French tcon->ses->Suid, rc); 605038c8a9a5SSteve French } 605138c8a9a5SSteve French 6052433042a9SShyam Prasad N if (is_replayable_error(rc) && 6053433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep)) 6054433042a9SShyam Prasad N goto replay_again; 6055433042a9SShyam Prasad N 605638c8a9a5SSteve French return rc; 605738c8a9a5SSteve French } 605838c8a9a5SSteve French 605938c8a9a5SSteve French int 606038c8a9a5SSteve French SMB2_lock(const unsigned int xid, struct cifs_tcon *tcon, 606138c8a9a5SSteve French const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid, 606238c8a9a5SSteve French const __u64 length, const __u64 offset, const __u32 lock_flags, 606338c8a9a5SSteve French const bool wait) 606438c8a9a5SSteve French { 606538c8a9a5SSteve French struct smb2_lock_element lock; 606638c8a9a5SSteve French 606738c8a9a5SSteve French lock.Offset = cpu_to_le64(offset); 606838c8a9a5SSteve French lock.Length = cpu_to_le64(length); 606938c8a9a5SSteve French lock.Flags = cpu_to_le32(lock_flags); 607038c8a9a5SSteve French if (!wait && lock_flags != SMB2_LOCKFLAG_UNLOCK) 607138c8a9a5SSteve French lock.Flags |= cpu_to_le32(SMB2_LOCKFLAG_FAIL_IMMEDIATELY); 607238c8a9a5SSteve French 607338c8a9a5SSteve French return smb2_lockv(xid, tcon, persist_fid, volatile_fid, pid, 1, &lock); 607438c8a9a5SSteve French } 607538c8a9a5SSteve French 607638c8a9a5SSteve French int 607738c8a9a5SSteve French SMB2_lease_break(const unsigned int xid, struct cifs_tcon *tcon, 607838c8a9a5SSteve French __u8 *lease_key, const __le32 lease_state) 607938c8a9a5SSteve French { 608038c8a9a5SSteve French struct smb_rqst rqst; 608138c8a9a5SSteve French int rc; 608238c8a9a5SSteve French struct smb2_lease_ack *req = NULL; 608338c8a9a5SSteve French struct cifs_ses *ses = tcon->ses; 608438c8a9a5SSteve French int flags = CIFS_OBREAK_OP; 608538c8a9a5SSteve French unsigned int total_len; 608638c8a9a5SSteve French struct kvec iov[1]; 608738c8a9a5SSteve French struct kvec rsp_iov; 608838c8a9a5SSteve French int resp_buf_type; 608938c8a9a5SSteve French __u64 *please_key_high; 609038c8a9a5SSteve French __u64 *please_key_low; 609138c8a9a5SSteve French struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses); 609238c8a9a5SSteve French 609338c8a9a5SSteve French cifs_dbg(FYI, "SMB2_lease_break\n"); 609438c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server, 609538c8a9a5SSteve French (void **) &req, &total_len); 609638c8a9a5SSteve French if (rc) 609738c8a9a5SSteve French return rc; 609838c8a9a5SSteve French 609938c8a9a5SSteve French if (smb3_encryption_required(tcon)) 610038c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ; 610138c8a9a5SSteve French 610238c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1); 610338c8a9a5SSteve French req->StructureSize = cpu_to_le16(36); 610438c8a9a5SSteve French total_len += 12; 610538c8a9a5SSteve French 610638c8a9a5SSteve French memcpy(req->LeaseKey, lease_key, 16); 610738c8a9a5SSteve French req->LeaseState = lease_state; 610838c8a9a5SSteve French 610938c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF; 611038c8a9a5SSteve French 611138c8a9a5SSteve French iov[0].iov_base = (char *)req; 611238c8a9a5SSteve French iov[0].iov_len = total_len; 611338c8a9a5SSteve French 611438c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst)); 611538c8a9a5SSteve French rqst.rq_iov = iov; 611638c8a9a5SSteve French rqst.rq_nvec = 1; 611738c8a9a5SSteve French 611838c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server, 611938c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov); 612038c8a9a5SSteve French cifs_small_buf_release(req); 612138c8a9a5SSteve French 612238c8a9a5SSteve French please_key_low = (__u64 *)lease_key; 612338c8a9a5SSteve French please_key_high = (__u64 *)(lease_key+8); 612438c8a9a5SSteve French if (rc) { 612538c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE); 612638c8a9a5SSteve French trace_smb3_lease_err(le32_to_cpu(lease_state), tcon->tid, 612738c8a9a5SSteve French ses->Suid, *please_key_low, *please_key_high, rc); 612838c8a9a5SSteve French cifs_dbg(FYI, "Send error in Lease Break = %d\n", rc); 612938c8a9a5SSteve French } else 613038c8a9a5SSteve French trace_smb3_lease_done(le32_to_cpu(lease_state), tcon->tid, 613138c8a9a5SSteve French ses->Suid, *please_key_low, *please_key_high); 613238c8a9a5SSteve French 613338c8a9a5SSteve French return rc; 613438c8a9a5SSteve French } 6135