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
smb3_encryption_required(const struct cifs_tcon * tcon)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
smb2_hdr_assemble(struct smb2_hdr * shdr,__le16 smb2_cmd,const struct cifs_tcon * tcon,struct TCP_Server_Info * server)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
cifs_chan_skip_or_disable(struct cifs_ses * ses,struct TCP_Server_Info * server,bool from_reconnect)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
smb2_reconnect(__le16 smb2_command,struct cifs_tcon * tcon,struct TCP_Server_Info * server,bool from_reconnect)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
fill_small_buf(__le16 smb2_command,struct cifs_tcon * tcon,struct TCP_Server_Info * server,void * buf,unsigned int * total_len)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 */
__smb2_plain_req_init(__le16 smb2_command,struct cifs_tcon * tcon,struct TCP_Server_Info * server,void ** request_buf,unsigned int * total_len)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
smb2_plain_req_init(__le16 smb2_command,struct cifs_tcon * tcon,struct TCP_Server_Info * server,void ** request_buf,unsigned int * total_len)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
smb2_ioctl_req_init(u32 opcode,struct cifs_tcon * tcon,struct TCP_Server_Info * server,void ** request_buf,unsigned int * total_len)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
build_preauth_ctxt(struct smb2_preauth_neg_context * pneg_ctxt)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
build_compression_ctxt(struct smb2_compression_capabilities_context * pneg_ctxt)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
build_signing_ctxt(struct smb2_signing_capabilities * pneg_ctxt)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
build_encrypt_ctxt(struct smb2_encryption_neg_context * pneg_ctxt)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
build_netname_ctxt(struct smb2_netname_neg_context * pneg_ctxt,char * hostname)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
build_posix_ctxt(struct smb2_posix_neg_context * pneg_ctxt)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
assemble_neg_contexts(struct smb2_negotiate_req * req,struct TCP_Server_Info * server,unsigned int * total_len)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
746e8aee4f4SEnzo 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 */
decode_preauth_context(struct smb2_preauth_neg_context * ctxt)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
decode_compress_ctx(struct TCP_Server_Info * server,struct smb2_compression_capabilities_context * ctxt)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);
794e8aee4f4SEnzo Matsumiya __le16 alg;
795e8aee4f4SEnzo Matsumiya
796e8aee4f4SEnzo 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 }
807e8aee4f4SEnzo Matsumiya
80838c8a9a5SSteve French if (le16_to_cpu(ctxt->CompressionAlgorithmCount) != 1) {
809e8aee4f4SEnzo Matsumiya pr_warn_once("invalid SMB3 compress algorithm count\n");
81038c8a9a5SSteve French return;
81138c8a9a5SSteve French }
812e8aee4f4SEnzo Matsumiya
813e8aee4f4SEnzo Matsumiya alg = ctxt->CompressionAlgorithms[0];
814e8aee4f4SEnzo Matsumiya
815e8aee4f4SEnzo Matsumiya /* 'NONE' (0) compressor type is never negotiated */
816e8aee4f4SEnzo Matsumiya if (alg == 0 || le16_to_cpu(alg) > 3) {
817e8aee4f4SEnzo Matsumiya pr_warn_once("invalid compression algorithm '%u'\n", alg);
81838c8a9a5SSteve French return;
81938c8a9a5SSteve French }
820e8aee4f4SEnzo Matsumiya
821e8aee4f4SEnzo Matsumiya server->compression.alg = alg;
822e8aee4f4SEnzo Matsumiya server->compression.enabled = true;
82338c8a9a5SSteve French }
82438c8a9a5SSteve French
decode_encrypt_ctx(struct TCP_Server_Info * server,struct smb2_encryption_neg_context * ctxt)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
decode_signing_ctx(struct TCP_Server_Info * server,struct smb2_signing_capabilities * pctxt)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
smb311_decode_neg_context(struct smb2_negotiate_rsp * rsp,struct TCP_Server_Info * server,unsigned int len_of_smb)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 *
create_posix_buf(umode_t mode)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
add_posix_context(struct kvec * iov,unsigned int * num_iovec,umode_t mode)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
SMB2_negotiate(const unsigned int xid,struct cifs_ses * ses,struct TCP_Server_Info * server)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
smb3_validate_negotiate(const unsigned int xid,struct cifs_tcon * tcon)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
smb2_select_sectype(struct TCP_Server_Info * server,enum securityEnum requested)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
SMB2_sess_alloc_buffer(struct SMB2_sess_data * sess_data)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
SMB2_sess_free_buffer(struct SMB2_sess_data * sess_data)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
SMB2_sess_sendreceive(struct SMB2_sess_data * sess_data)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
SMB2_sess_establish_session(struct SMB2_sess_data * sess_data)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
SMB2_auth_kerberos(struct SMB2_sess_data * sess_data)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
SMB2_auth_kerberos(struct SMB2_sess_data * sess_data)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
SMB2_sess_auth_rawntlmssp_negotiate(struct SMB2_sess_data * sess_data)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
SMB2_sess_auth_rawntlmssp_authenticate(struct SMB2_sess_data * sess_data)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
SMB2_select_sec(struct SMB2_sess_data * sess_data)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
SMB2_sess_setup(const unsigned int xid,struct cifs_ses * ses,struct TCP_Server_Info * server,const struct nls_table * nls_cp)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
SMB2_logoff(const unsigned int xid,struct cifs_ses * ses)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
cifs_stats_fail_inc(struct cifs_tcon * tcon,uint16_t code)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 */
init_copy_chunk_defaults(struct cifs_tcon * tcon)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
SMB2_tcon(const unsigned int xid,struct cifs_ses * ses,const char * tree,struct cifs_tcon * tcon,const struct nls_table * cp)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
SMB2_tdis(const unsigned int xid,struct cifs_tcon * tcon)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 *
create_durable_buf(void)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 *
create_reconnect_durable_buf(struct cifs_fid * fid)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
parse_query_id_ctxt(struct create_context * cc,struct smb2_file_all_info * buf)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
parse_posix_ctxt(struct create_context * cc,struct smb2_file_all_info * info,struct create_posix_rsp * posix)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
smb2_parse_contexts(struct TCP_Server_Info * server,struct kvec * rsp_iov,unsigned int * epoch,char * lease_key,__u8 * oplock,struct smb2_file_all_info * buf,struct create_posix_rsp * posix)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
add_lease_context(struct TCP_Server_Info * server,struct smb2_create_req * req,struct kvec * iov,unsigned int * num_iovec,u8 * lease_key,__u8 * oplock)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 *
create_durable_v2_buf(struct cifs_open_parms * oparms)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 *
create_reconnect_durable_v2_buf(struct cifs_fid * fid)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
add_durable_v2_context(struct kvec * iov,unsigned int * num_iovec,struct cifs_open_parms * oparms)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
add_durable_reconnect_v2_context(struct kvec * iov,unsigned int * num_iovec,struct cifs_open_parms * oparms)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
add_durable_context(struct kvec * iov,unsigned int * num_iovec,struct cifs_open_parms * oparms,bool use_persistent)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 *
create_twarp_buf(__u64 timewarp)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
add_twarp_context(struct kvec * iov,unsigned int * num_iovec,__u64 timewarp)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 */
setup_owner_group_sids(char * buf)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 *
create_sd_buf(umode_t mode,bool set_owner,unsigned int * len)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
add_sd_context(struct kvec * iov,unsigned int * num_iovec,umode_t mode,bool set_owner)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 *
create_query_id_buf(void)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
add_query_id_context(struct kvec * iov,unsigned int * num_iovec)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
add_ea_context(struct cifs_open_parms * oparms,struct kvec * rq_iov,unsigned int * num_iovs)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
alloc_path_with_tree_prefix(__le16 ** out_path,int * out_size,int * out_len,const char * treename,const __le16 * path)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
smb311_posix_mkdir(const unsigned int xid,struct inode * inode,umode_t mode,struct cifs_tcon * tcon,const char * full_path,struct cifs_sb_info * cifs_sb)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
SMB2_open_init(struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,__u8 * oplock,struct cifs_open_parms * oparms,__le16 * path)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
SMB2_open_free(struct smb_rqst * rqst)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
SMB2_open(const unsigned int xid,struct cifs_open_parms * oparms,__le16 * path,__u8 * oplock,struct smb2_file_all_info * buf,struct create_posix_rsp * posix,struct kvec * err_iov,int * buftype)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
SMB2_ioctl_init(struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,u64 persistent_fid,u64 volatile_fid,u32 opcode,char * in_data,u32 indatalen,__u32 max_response_size)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
SMB2_ioctl_free(struct smb_rqst * rqst)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
SMB2_ioctl(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,u32 opcode,char * in_data,u32 indatalen,u32 max_out_data_len,char ** out_data,u32 * plen)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
SMB2_set_compression(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid)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
SMB2_close_init(struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,u64 persistent_fid,u64 volatile_fid,bool query_attrs)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
SMB2_close_free(struct smb_rqst * rqst)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
__SMB2_close(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct smb2_file_network_open_info * pbuf)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
SMB2_close(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid)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
smb2_validate_iov(unsigned int offset,unsigned int buffer_length,struct kvec * iov,unsigned int min_buf_size)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
smb2_validate_and_copy_iov(unsigned int offset,unsigned int buffer_length,struct kvec * iov,unsigned int minbufsize,char * data)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
SMB2_query_info_init(struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,u64 persistent_fid,u64 volatile_fid,u8 info_class,u8 info_type,u32 additional_info,size_t output_len,size_t input_len,void * input)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
SMB2_query_info_free(struct smb_rqst * rqst)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
query_info(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,u8 info_class,u8 info_type,u32 additional_info,size_t output_len,size_t min_len,void ** data,u32 * dlen)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
SMB2_query_info(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct smb2_file_all_info * data)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
SMB2_query_acl(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,void ** data,u32 * plen,u32 extra_info)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
SMB2_get_srv_num(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,__le64 * uniqueid)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
SMB2_notify_init(const unsigned int xid,struct smb_rqst * rqst,struct cifs_tcon * tcon,struct TCP_Server_Info * server,u64 persistent_fid,u64 volatile_fid,u32 completion_filter,bool watch_tree)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
SMB2_change_notify(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,bool watch_tree,u32 completion_filter,u32 max_out_data_len,char ** out_data,u32 * plen)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
smb2_echo_callback(struct mid_q_entry * mid)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
smb2_reconnect_server(struct work_struct * work)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++;
414107e76ea1SDavid Howells trace_smb3_tcon_ref(tcon->debug_id, tcon->tc_count,
414207e76ea1SDavid Howells netfs_trace_tcon_ref_get_reconnect_server);
414338c8a9a5SSteve French list_add_tail(&tcon->rlist, &tmp_list);
41448358f46bSColin Ian King tcon_selected = true;
414538c8a9a5SSteve French }
414638c8a9a5SSteve French }
414738c8a9a5SSteve French /*
414838c8a9a5SSteve French * IPC has the same lifetime as its session and uses its
414938c8a9a5SSteve French * refcount.
415038c8a9a5SSteve French */
415138c8a9a5SSteve French if (ses->tcon_ipc && ses->tcon_ipc->need_reconnect) {
415238c8a9a5SSteve French list_add_tail(&ses->tcon_ipc->rlist, &tmp_list);
41538358f46bSColin Ian King tcon_selected = true;
415438c8a9a5SSteve French cifs_smb_ses_inc_refcount(ses);
415538c8a9a5SSteve French }
415638c8a9a5SSteve French /*
415738c8a9a5SSteve French * handle the case where channel needs to reconnect
415838c8a9a5SSteve French * binding session, but tcon is healthy (some other channel
415938c8a9a5SSteve French * is active)
416038c8a9a5SSteve French */
416138c8a9a5SSteve French spin_lock(&ses->chan_lock);
416238c8a9a5SSteve French if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {
416338c8a9a5SSteve French list_add_tail(&ses->rlist, &tmp_ses_list);
416438c8a9a5SSteve French ses_exist = true;
416538c8a9a5SSteve French cifs_smb_ses_inc_refcount(ses);
416638c8a9a5SSteve French }
416738c8a9a5SSteve French spin_unlock(&ses->chan_lock);
416838c8a9a5SSteve French }
416938c8a9a5SSteve French spin_unlock(&cifs_tcp_ses_lock);
417038c8a9a5SSteve French
417138c8a9a5SSteve French list_for_each_entry_safe(tcon, tcon2, &tmp_list, rlist) {
417207e86408SShyam Prasad N rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
417338c8a9a5SSteve French if (!rc)
417438c8a9a5SSteve French cifs_reopen_persistent_handles(tcon);
417538c8a9a5SSteve French else
417638c8a9a5SSteve French resched = true;
417738c8a9a5SSteve French list_del_init(&tcon->rlist);
417838c8a9a5SSteve French if (tcon->ipc)
417938c8a9a5SSteve French cifs_put_smb_ses(tcon->ses);
418038c8a9a5SSteve French else
418107e76ea1SDavid Howells cifs_put_tcon(tcon, netfs_trace_tcon_ref_put_reconnect_server);
418238c8a9a5SSteve French }
418338c8a9a5SSteve French
418438c8a9a5SSteve French if (!ses_exist)
418538c8a9a5SSteve French goto done;
418638c8a9a5SSteve French
418738c8a9a5SSteve French /* allocate a dummy tcon struct used for reconnect */
418807e76ea1SDavid Howells tcon = tcon_info_alloc(false, netfs_trace_tcon_ref_new_reconnect_server);
418938c8a9a5SSteve French if (!tcon) {
419038c8a9a5SSteve French resched = true;
419138c8a9a5SSteve French list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) {
419238c8a9a5SSteve French list_del_init(&ses->rlist);
419338c8a9a5SSteve French cifs_put_smb_ses(ses);
419438c8a9a5SSteve French }
419538c8a9a5SSteve French goto done;
419638c8a9a5SSteve French }
419738c8a9a5SSteve French
419838c8a9a5SSteve French tcon->status = TID_GOOD;
419938c8a9a5SSteve French tcon->retry = false;
420038c8a9a5SSteve French tcon->need_reconnect = false;
420138c8a9a5SSteve French
420238c8a9a5SSteve French /* now reconnect sessions for necessary channels */
420338c8a9a5SSteve French list_for_each_entry_safe(ses, ses2, &tmp_ses_list, rlist) {
420438c8a9a5SSteve French tcon->ses = ses;
420507e86408SShyam Prasad N rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
420638c8a9a5SSteve French if (rc)
420738c8a9a5SSteve French resched = true;
420838c8a9a5SSteve French list_del_init(&ses->rlist);
420938c8a9a5SSteve French cifs_put_smb_ses(ses);
421038c8a9a5SSteve French }
421107e76ea1SDavid Howells tconInfoFree(tcon, netfs_trace_tcon_ref_free_reconnect_server);
421238c8a9a5SSteve French
421338c8a9a5SSteve French done:
421438c8a9a5SSteve French cifs_dbg(FYI, "Reconnecting tcons and channels finished\n");
42153a0ef868SShyam Prasad N if (resched)
421638c8a9a5SSteve French queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
421738c8a9a5SSteve French mutex_unlock(&pserver->reconnect_mutex);
421838c8a9a5SSteve French
421938c8a9a5SSteve French /* now we can safely release srv struct */
422007e86408SShyam Prasad N cifs_put_tcp_session(server, true);
422138c8a9a5SSteve French }
422238c8a9a5SSteve French
422338c8a9a5SSteve French int
SMB2_echo(struct TCP_Server_Info * server)422438c8a9a5SSteve French SMB2_echo(struct TCP_Server_Info *server)
422538c8a9a5SSteve French {
422638c8a9a5SSteve French struct smb2_echo_req *req;
422738c8a9a5SSteve French int rc = 0;
422838c8a9a5SSteve French struct kvec iov[1];
422938c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = iov,
423038c8a9a5SSteve French .rq_nvec = 1 };
423138c8a9a5SSteve French unsigned int total_len;
423238c8a9a5SSteve French
423338c8a9a5SSteve French cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);
423438c8a9a5SSteve French
423538c8a9a5SSteve French spin_lock(&server->srv_lock);
423638c8a9a5SSteve French if (server->ops->need_neg &&
423738c8a9a5SSteve French server->ops->need_neg(server)) {
423838c8a9a5SSteve French spin_unlock(&server->srv_lock);
423938c8a9a5SSteve French /* No need to send echo on newly established connections */
42403a0ef868SShyam Prasad N mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
424138c8a9a5SSteve French return rc;
424238c8a9a5SSteve French }
424338c8a9a5SSteve French spin_unlock(&server->srv_lock);
424438c8a9a5SSteve French
424538c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
424638c8a9a5SSteve French (void **)&req, &total_len);
424738c8a9a5SSteve French if (rc)
424838c8a9a5SSteve French return rc;
424938c8a9a5SSteve French
425038c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1);
425138c8a9a5SSteve French
425238c8a9a5SSteve French iov[0].iov_len = total_len;
425338c8a9a5SSteve French iov[0].iov_base = (char *)req;
425438c8a9a5SSteve French
425538c8a9a5SSteve French rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
425638c8a9a5SSteve French server, CIFS_ECHO_OP, NULL);
425738c8a9a5SSteve French if (rc)
425838c8a9a5SSteve French cifs_dbg(FYI, "Echo request failed: %d\n", rc);
425938c8a9a5SSteve French
426038c8a9a5SSteve French cifs_small_buf_release(req);
426138c8a9a5SSteve French return rc;
426238c8a9a5SSteve French }
426338c8a9a5SSteve French
426438c8a9a5SSteve French void
SMB2_flush_free(struct smb_rqst * rqst)426538c8a9a5SSteve French SMB2_flush_free(struct smb_rqst *rqst)
426638c8a9a5SSteve French {
426738c8a9a5SSteve French if (rqst && rqst->rq_iov)
426838c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */
426938c8a9a5SSteve French }
427038c8a9a5SSteve French
427138c8a9a5SSteve French int
SMB2_flush_init(const unsigned int xid,struct smb_rqst * rqst,struct cifs_tcon * tcon,struct TCP_Server_Info * server,u64 persistent_fid,u64 volatile_fid)427238c8a9a5SSteve French SMB2_flush_init(const unsigned int xid, struct smb_rqst *rqst,
427338c8a9a5SSteve French struct cifs_tcon *tcon, struct TCP_Server_Info *server,
427438c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid)
427538c8a9a5SSteve French {
427638c8a9a5SSteve French struct smb2_flush_req *req;
427738c8a9a5SSteve French struct kvec *iov = rqst->rq_iov;
427838c8a9a5SSteve French unsigned int total_len;
427938c8a9a5SSteve French int rc;
428038c8a9a5SSteve French
428138c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
428238c8a9a5SSteve French (void **) &req, &total_len);
428338c8a9a5SSteve French if (rc)
428438c8a9a5SSteve French return rc;
428538c8a9a5SSteve French
428638c8a9a5SSteve French req->PersistentFileId = persistent_fid;
428738c8a9a5SSteve French req->VolatileFileId = volatile_fid;
428838c8a9a5SSteve French
428938c8a9a5SSteve French iov[0].iov_base = (char *)req;
429038c8a9a5SSteve French iov[0].iov_len = total_len;
429138c8a9a5SSteve French
429238c8a9a5SSteve French return 0;
429338c8a9a5SSteve French }
429438c8a9a5SSteve French
429538c8a9a5SSteve French int
SMB2_flush(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid)429638c8a9a5SSteve French SMB2_flush(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
429738c8a9a5SSteve French u64 volatile_fid)
429838c8a9a5SSteve French {
429938c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
430038c8a9a5SSteve French struct smb_rqst rqst;
430138c8a9a5SSteve French struct kvec iov[1];
430238c8a9a5SSteve French struct kvec rsp_iov = {NULL, 0};
4303433042a9SShyam Prasad N struct TCP_Server_Info *server;
430438c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER;
430538c8a9a5SSteve French int flags = 0;
430638c8a9a5SSteve French int rc = 0;
4307433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
4308433042a9SShyam Prasad N
4309433042a9SShyam Prasad N replay_again:
4310433042a9SShyam Prasad N /* reinitialize for possible replay */
4311433042a9SShyam Prasad N flags = 0;
4312433042a9SShyam Prasad N server = cifs_pick_channel(ses);
431338c8a9a5SSteve French
431438c8a9a5SSteve French cifs_dbg(FYI, "flush\n");
431538c8a9a5SSteve French if (!ses || !(ses->server))
431638c8a9a5SSteve French return -EIO;
431738c8a9a5SSteve French
431838c8a9a5SSteve French if (smb3_encryption_required(tcon))
431938c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
432038c8a9a5SSteve French
432138c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
432238c8a9a5SSteve French memset(&iov, 0, sizeof(iov));
432338c8a9a5SSteve French rqst.rq_iov = iov;
432438c8a9a5SSteve French rqst.rq_nvec = 1;
432538c8a9a5SSteve French
432638c8a9a5SSteve French rc = SMB2_flush_init(xid, &rqst, tcon, server,
432738c8a9a5SSteve French persistent_fid, volatile_fid);
432838c8a9a5SSteve French if (rc)
432938c8a9a5SSteve French goto flush_exit;
433038c8a9a5SSteve French
433138c8a9a5SSteve French trace_smb3_flush_enter(xid, persistent_fid, tcon->tid, ses->Suid);
4332433042a9SShyam Prasad N
4333433042a9SShyam Prasad N if (retries)
4334433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
4335433042a9SShyam Prasad N
433638c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
433738c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
433838c8a9a5SSteve French
433938c8a9a5SSteve French if (rc != 0) {
434038c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_FLUSH_HE);
434138c8a9a5SSteve French trace_smb3_flush_err(xid, persistent_fid, tcon->tid, ses->Suid,
434238c8a9a5SSteve French rc);
434338c8a9a5SSteve French } else
434438c8a9a5SSteve French trace_smb3_flush_done(xid, persistent_fid, tcon->tid,
434538c8a9a5SSteve French ses->Suid);
434638c8a9a5SSteve French
434738c8a9a5SSteve French flush_exit:
434838c8a9a5SSteve French SMB2_flush_free(&rqst);
434938c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
4350433042a9SShyam Prasad N
4351433042a9SShyam Prasad N if (is_replayable_error(rc) &&
4352433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
4353433042a9SShyam Prasad N goto replay_again;
4354433042a9SShyam Prasad N
435538c8a9a5SSteve French return rc;
435638c8a9a5SSteve French }
435738c8a9a5SSteve French
435838c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
smb3_use_rdma_offload(struct cifs_io_parms * io_parms)435938c8a9a5SSteve French static inline bool smb3_use_rdma_offload(struct cifs_io_parms *io_parms)
436038c8a9a5SSteve French {
436138c8a9a5SSteve French struct TCP_Server_Info *server = io_parms->server;
436238c8a9a5SSteve French struct cifs_tcon *tcon = io_parms->tcon;
436338c8a9a5SSteve French
436438c8a9a5SSteve French /* we can only offload if we're connected */
436538c8a9a5SSteve French if (!server || !tcon)
436638c8a9a5SSteve French return false;
436738c8a9a5SSteve French
436838c8a9a5SSteve French /* we can only offload on an rdma connection */
436938c8a9a5SSteve French if (!server->rdma || !server->smbd_conn)
437038c8a9a5SSteve French return false;
437138c8a9a5SSteve French
437238c8a9a5SSteve French /* we don't support signed offload yet */
437338c8a9a5SSteve French if (server->sign)
437438c8a9a5SSteve French return false;
437538c8a9a5SSteve French
437638c8a9a5SSteve French /* we don't support encrypted offload yet */
437738c8a9a5SSteve French if (smb3_encryption_required(tcon))
437838c8a9a5SSteve French return false;
437938c8a9a5SSteve French
438038c8a9a5SSteve French /* offload also has its overhead, so only do it if desired */
438138c8a9a5SSteve French if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
438238c8a9a5SSteve French return false;
438338c8a9a5SSteve French
438438c8a9a5SSteve French return true;
438538c8a9a5SSteve French }
438638c8a9a5SSteve French #endif /* CONFIG_CIFS_SMB_DIRECT */
438738c8a9a5SSteve French
438838c8a9a5SSteve French /*
438938c8a9a5SSteve French * To form a chain of read requests, any read requests after the first should
439038c8a9a5SSteve French * have the end_of_chain boolean set to true.
439138c8a9a5SSteve French */
439238c8a9a5SSteve French static int
smb2_new_read_req(void ** buf,unsigned int * total_len,struct cifs_io_parms * io_parms,struct cifs_readdata * rdata,unsigned int remaining_bytes,int request_type)439338c8a9a5SSteve French smb2_new_read_req(void **buf, unsigned int *total_len,
439438c8a9a5SSteve French struct cifs_io_parms *io_parms, struct cifs_readdata *rdata,
439538c8a9a5SSteve French unsigned int remaining_bytes, int request_type)
439638c8a9a5SSteve French {
439738c8a9a5SSteve French int rc = -EACCES;
439838c8a9a5SSteve French struct smb2_read_req *req = NULL;
439938c8a9a5SSteve French struct smb2_hdr *shdr;
440038c8a9a5SSteve French struct TCP_Server_Info *server = io_parms->server;
440138c8a9a5SSteve French
440238c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
440338c8a9a5SSteve French (void **) &req, total_len);
440438c8a9a5SSteve French if (rc)
440538c8a9a5SSteve French return rc;
440638c8a9a5SSteve French
440738c8a9a5SSteve French if (server == NULL)
440838c8a9a5SSteve French return -ECONNABORTED;
440938c8a9a5SSteve French
441038c8a9a5SSteve French shdr = &req->hdr;
441138c8a9a5SSteve French shdr->Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid);
441238c8a9a5SSteve French
441338c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid;
441438c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid;
441538c8a9a5SSteve French req->ReadChannelInfoOffset = 0; /* reserved */
441638c8a9a5SSteve French req->ReadChannelInfoLength = 0; /* reserved */
441738c8a9a5SSteve French req->Channel = 0; /* reserved */
441838c8a9a5SSteve French req->MinimumCount = 0;
441938c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length);
442038c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset);
442138c8a9a5SSteve French
442238c8a9a5SSteve French trace_smb3_read_enter(0 /* xid */,
442338c8a9a5SSteve French io_parms->persistent_fid,
442438c8a9a5SSteve French io_parms->tcon->tid, io_parms->tcon->ses->Suid,
442538c8a9a5SSteve French io_parms->offset, io_parms->length);
442638c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
442738c8a9a5SSteve French /*
442838c8a9a5SSteve French * If we want to do a RDMA write, fill in and append
442938c8a9a5SSteve French * smbd_buffer_descriptor_v1 to the end of read request
443038c8a9a5SSteve French */
443138c8a9a5SSteve French if (smb3_use_rdma_offload(io_parms)) {
443238c8a9a5SSteve French struct smbd_buffer_descriptor_v1 *v1;
443338c8a9a5SSteve French bool need_invalidate = server->dialect == SMB30_PROT_ID;
443438c8a9a5SSteve French
443538c8a9a5SSteve French rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->iter,
443638c8a9a5SSteve French true, need_invalidate);
443738c8a9a5SSteve French if (!rdata->mr)
443838c8a9a5SSteve French return -EAGAIN;
443938c8a9a5SSteve French
444038c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1_INVALIDATE;
444138c8a9a5SSteve French if (need_invalidate)
444238c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1;
444338c8a9a5SSteve French req->ReadChannelInfoOffset =
444438c8a9a5SSteve French cpu_to_le16(offsetof(struct smb2_read_req, Buffer));
444538c8a9a5SSteve French req->ReadChannelInfoLength =
444638c8a9a5SSteve French cpu_to_le16(sizeof(struct smbd_buffer_descriptor_v1));
444738c8a9a5SSteve French v1 = (struct smbd_buffer_descriptor_v1 *) &req->Buffer[0];
444838c8a9a5SSteve French v1->offset = cpu_to_le64(rdata->mr->mr->iova);
444938c8a9a5SSteve French v1->token = cpu_to_le32(rdata->mr->mr->rkey);
445038c8a9a5SSteve French v1->length = cpu_to_le32(rdata->mr->mr->length);
445138c8a9a5SSteve French
445238c8a9a5SSteve French *total_len += sizeof(*v1) - 1;
445338c8a9a5SSteve French }
445438c8a9a5SSteve French #endif
445538c8a9a5SSteve French if (request_type & CHAINED_REQUEST) {
445638c8a9a5SSteve French if (!(request_type & END_OF_CHAIN)) {
445738c8a9a5SSteve French /* next 8-byte aligned request */
445838c8a9a5SSteve French *total_len = ALIGN(*total_len, 8);
445938c8a9a5SSteve French shdr->NextCommand = cpu_to_le32(*total_len);
446038c8a9a5SSteve French } else /* END_OF_CHAIN */
446138c8a9a5SSteve French shdr->NextCommand = 0;
446238c8a9a5SSteve French if (request_type & RELATED_REQUEST) {
446338c8a9a5SSteve French shdr->Flags |= SMB2_FLAGS_RELATED_OPERATIONS;
446438c8a9a5SSteve French /*
446538c8a9a5SSteve French * Related requests use info from previous read request
446638c8a9a5SSteve French * in chain.
446738c8a9a5SSteve French */
446838c8a9a5SSteve French shdr->SessionId = cpu_to_le64(0xFFFFFFFFFFFFFFFF);
446938c8a9a5SSteve French shdr->Id.SyncId.TreeId = cpu_to_le32(0xFFFFFFFF);
447038c8a9a5SSteve French req->PersistentFileId = (u64)-1;
447138c8a9a5SSteve French req->VolatileFileId = (u64)-1;
447238c8a9a5SSteve French }
447338c8a9a5SSteve French }
447438c8a9a5SSteve French if (remaining_bytes > io_parms->length)
447538c8a9a5SSteve French req->RemainingBytes = cpu_to_le32(remaining_bytes);
447638c8a9a5SSteve French else
447738c8a9a5SSteve French req->RemainingBytes = 0;
447838c8a9a5SSteve French
447938c8a9a5SSteve French *buf = req;
448038c8a9a5SSteve French return rc;
448138c8a9a5SSteve French }
448238c8a9a5SSteve French
448338c8a9a5SSteve French static void
smb2_readv_callback(struct mid_q_entry * mid)448438c8a9a5SSteve French smb2_readv_callback(struct mid_q_entry *mid)
448538c8a9a5SSteve French {
448638c8a9a5SSteve French struct cifs_readdata *rdata = mid->callback_data;
448738c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
448838c8a9a5SSteve French struct TCP_Server_Info *server = rdata->server;
448938c8a9a5SSteve French struct smb2_hdr *shdr =
449038c8a9a5SSteve French (struct smb2_hdr *)rdata->iov[0].iov_base;
449138c8a9a5SSteve French struct cifs_credits credits = { .value = 0, .instance = 0 };
449238c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = &rdata->iov[1], .rq_nvec = 1 };
449338c8a9a5SSteve French
449438c8a9a5SSteve French if (rdata->got_bytes) {
449538c8a9a5SSteve French rqst.rq_iter = rdata->iter;
449638c8a9a5SSteve French rqst.rq_iter_size = iov_iter_count(&rdata->iter);
449738c8a9a5SSteve French }
449838c8a9a5SSteve French
449938c8a9a5SSteve French WARN_ONCE(rdata->server != mid->server,
450038c8a9a5SSteve French "rdata server %p != mid server %p",
450138c8a9a5SSteve French rdata->server, mid->server);
450238c8a9a5SSteve French
450338c8a9a5SSteve French cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
450438c8a9a5SSteve French __func__, mid->mid, mid->mid_state, rdata->result,
450538c8a9a5SSteve French rdata->bytes);
450638c8a9a5SSteve French
450738c8a9a5SSteve French switch (mid->mid_state) {
450838c8a9a5SSteve French case MID_RESPONSE_RECEIVED:
450938c8a9a5SSteve French credits.value = le16_to_cpu(shdr->CreditRequest);
451038c8a9a5SSteve French credits.instance = server->reconnect_instance;
451138c8a9a5SSteve French /* result already set, check signature */
451238c8a9a5SSteve French if (server->sign && !mid->decrypted) {
451338c8a9a5SSteve French int rc;
451438c8a9a5SSteve French
451538c8a9a5SSteve French iov_iter_revert(&rqst.rq_iter, rdata->got_bytes);
451638c8a9a5SSteve French iov_iter_truncate(&rqst.rq_iter, rdata->got_bytes);
451738c8a9a5SSteve French rc = smb2_verify_signature(&rqst, server);
451838c8a9a5SSteve French if (rc)
451938c8a9a5SSteve French cifs_tcon_dbg(VFS, "SMB signature verification returned error = %d\n",
452038c8a9a5SSteve French rc);
452138c8a9a5SSteve French }
452238c8a9a5SSteve French /* FIXME: should this be counted toward the initiating task? */
452338c8a9a5SSteve French task_io_account_read(rdata->got_bytes);
452438c8a9a5SSteve French cifs_stats_bytes_read(tcon, rdata->got_bytes);
452538c8a9a5SSteve French break;
452638c8a9a5SSteve French case MID_REQUEST_SUBMITTED:
452738c8a9a5SSteve French case MID_RETRY_NEEDED:
452838c8a9a5SSteve French rdata->result = -EAGAIN;
452938c8a9a5SSteve French if (server->sign && rdata->got_bytes)
453038c8a9a5SSteve French /* reset bytes number since we can not check a sign */
453138c8a9a5SSteve French rdata->got_bytes = 0;
453238c8a9a5SSteve French /* FIXME: should this be counted toward the initiating task? */
453338c8a9a5SSteve French task_io_account_read(rdata->got_bytes);
453438c8a9a5SSteve French cifs_stats_bytes_read(tcon, rdata->got_bytes);
453538c8a9a5SSteve French break;
453638c8a9a5SSteve French case MID_RESPONSE_MALFORMED:
453738c8a9a5SSteve French credits.value = le16_to_cpu(shdr->CreditRequest);
453838c8a9a5SSteve French credits.instance = server->reconnect_instance;
453938c8a9a5SSteve French fallthrough;
454038c8a9a5SSteve French default:
454138c8a9a5SSteve French rdata->result = -EIO;
454238c8a9a5SSteve French }
454338c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
454438c8a9a5SSteve French /*
454538c8a9a5SSteve French * If this rdata has a memmory registered, the MR can be freed
454638c8a9a5SSteve French * MR needs to be freed as soon as I/O finishes to prevent deadlock
454738c8a9a5SSteve French * because they have limited number and are used for future I/Os
454838c8a9a5SSteve French */
454938c8a9a5SSteve French if (rdata->mr) {
455038c8a9a5SSteve French smbd_deregister_mr(rdata->mr);
455138c8a9a5SSteve French rdata->mr = NULL;
455238c8a9a5SSteve French }
455338c8a9a5SSteve French #endif
455438c8a9a5SSteve French if (rdata->result && rdata->result != -ENODATA) {
455538c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_READ_HE);
455638c8a9a5SSteve French trace_smb3_read_err(0 /* xid */,
455738c8a9a5SSteve French rdata->cfile->fid.persistent_fid,
455838c8a9a5SSteve French tcon->tid, tcon->ses->Suid, rdata->offset,
455938c8a9a5SSteve French rdata->bytes, rdata->result);
456038c8a9a5SSteve French } else
456138c8a9a5SSteve French trace_smb3_read_done(0 /* xid */,
456238c8a9a5SSteve French rdata->cfile->fid.persistent_fid,
456338c8a9a5SSteve French tcon->tid, tcon->ses->Suid,
456438c8a9a5SSteve French rdata->offset, rdata->got_bytes);
456538c8a9a5SSteve French
456638c8a9a5SSteve French queue_work(cifsiod_wq, &rdata->work);
456738c8a9a5SSteve French release_mid(mid);
456838c8a9a5SSteve French add_credits(server, &credits, 0);
456938c8a9a5SSteve French }
457038c8a9a5SSteve French
457138c8a9a5SSteve French /* smb2_async_readv - send an async read, and set up mid to handle result */
457238c8a9a5SSteve French int
smb2_async_readv(struct cifs_readdata * rdata)457338c8a9a5SSteve French smb2_async_readv(struct cifs_readdata *rdata)
457438c8a9a5SSteve French {
457538c8a9a5SSteve French int rc, flags = 0;
457638c8a9a5SSteve French char *buf;
457738c8a9a5SSteve French struct smb2_hdr *shdr;
457838c8a9a5SSteve French struct cifs_io_parms io_parms;
457938c8a9a5SSteve French struct smb_rqst rqst = { .rq_iov = rdata->iov,
458038c8a9a5SSteve French .rq_nvec = 1 };
458138c8a9a5SSteve French struct TCP_Server_Info *server;
458238c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
458338c8a9a5SSteve French unsigned int total_len;
45845e90aa21SShyam Prasad N int credit_request;
458538c8a9a5SSteve French
458638c8a9a5SSteve French cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
458738c8a9a5SSteve French __func__, rdata->offset, rdata->bytes);
458838c8a9a5SSteve French
458938c8a9a5SSteve French if (!rdata->server)
459038c8a9a5SSteve French rdata->server = cifs_pick_channel(tcon->ses);
459138c8a9a5SSteve French
459238c8a9a5SSteve French io_parms.tcon = tlink_tcon(rdata->cfile->tlink);
459338c8a9a5SSteve French io_parms.server = server = rdata->server;
459438c8a9a5SSteve French io_parms.offset = rdata->offset;
459538c8a9a5SSteve French io_parms.length = rdata->bytes;
459638c8a9a5SSteve French io_parms.persistent_fid = rdata->cfile->fid.persistent_fid;
459738c8a9a5SSteve French io_parms.volatile_fid = rdata->cfile->fid.volatile_fid;
459838c8a9a5SSteve French io_parms.pid = rdata->pid;
459938c8a9a5SSteve French
460038c8a9a5SSteve French rc = smb2_new_read_req(
460138c8a9a5SSteve French (void **) &buf, &total_len, &io_parms, rdata, 0, 0);
460238c8a9a5SSteve French if (rc)
460338c8a9a5SSteve French return rc;
460438c8a9a5SSteve French
460538c8a9a5SSteve French if (smb3_encryption_required(io_parms.tcon))
460638c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
460738c8a9a5SSteve French
460838c8a9a5SSteve French rdata->iov[0].iov_base = buf;
460938c8a9a5SSteve French rdata->iov[0].iov_len = total_len;
461038c8a9a5SSteve French
461138c8a9a5SSteve French shdr = (struct smb2_hdr *)buf;
461238c8a9a5SSteve French
461338c8a9a5SSteve French if (rdata->credits.value > 0) {
461438c8a9a5SSteve French shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(rdata->bytes,
461538c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE));
46165e90aa21SShyam Prasad N credit_request = le16_to_cpu(shdr->CreditCharge) + 8;
46175e90aa21SShyam Prasad N if (server->credits >= server->max_credits)
46185e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(0);
46195e90aa21SShyam Prasad N else
46205e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(
46215e90aa21SShyam Prasad N min_t(int, server->max_credits -
46225e90aa21SShyam Prasad N server->credits, credit_request));
462338c8a9a5SSteve French
462438c8a9a5SSteve French rc = adjust_credits(server, &rdata->credits, rdata->bytes);
462538c8a9a5SSteve French if (rc)
462638c8a9a5SSteve French goto async_readv_out;
462738c8a9a5SSteve French
462838c8a9a5SSteve French flags |= CIFS_HAS_CREDITS;
462938c8a9a5SSteve French }
463038c8a9a5SSteve French
463138c8a9a5SSteve French kref_get(&rdata->refcount);
463238c8a9a5SSteve French rc = cifs_call_async(server, &rqst,
463338c8a9a5SSteve French cifs_readv_receive, smb2_readv_callback,
463438c8a9a5SSteve French smb3_handle_read_data, rdata, flags,
463538c8a9a5SSteve French &rdata->credits);
463638c8a9a5SSteve French if (rc) {
463738c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release);
463838c8a9a5SSteve French cifs_stats_fail_inc(io_parms.tcon, SMB2_READ_HE);
463938c8a9a5SSteve French trace_smb3_read_err(0 /* xid */, io_parms.persistent_fid,
464038c8a9a5SSteve French io_parms.tcon->tid,
464138c8a9a5SSteve French io_parms.tcon->ses->Suid,
464238c8a9a5SSteve French io_parms.offset, io_parms.length, rc);
464338c8a9a5SSteve French }
464438c8a9a5SSteve French
464538c8a9a5SSteve French async_readv_out:
464638c8a9a5SSteve French cifs_small_buf_release(buf);
464738c8a9a5SSteve French return rc;
464838c8a9a5SSteve French }
464938c8a9a5SSteve French
465038c8a9a5SSteve French int
SMB2_read(const unsigned int xid,struct cifs_io_parms * io_parms,unsigned int * nbytes,char ** buf,int * buf_type)465138c8a9a5SSteve French SMB2_read(const unsigned int xid, struct cifs_io_parms *io_parms,
465238c8a9a5SSteve French unsigned int *nbytes, char **buf, int *buf_type)
465338c8a9a5SSteve French {
465438c8a9a5SSteve French struct smb_rqst rqst;
465538c8a9a5SSteve French int resp_buftype, rc;
465638c8a9a5SSteve French struct smb2_read_req *req = NULL;
465738c8a9a5SSteve French struct smb2_read_rsp *rsp = NULL;
465838c8a9a5SSteve French struct kvec iov[1];
465938c8a9a5SSteve French struct kvec rsp_iov;
466038c8a9a5SSteve French unsigned int total_len;
466138c8a9a5SSteve French int flags = CIFS_LOG_ERROR;
466238c8a9a5SSteve French struct cifs_ses *ses = io_parms->tcon->ses;
466338c8a9a5SSteve French
466438c8a9a5SSteve French if (!io_parms->server)
466538c8a9a5SSteve French io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
466638c8a9a5SSteve French
466738c8a9a5SSteve French *nbytes = 0;
466838c8a9a5SSteve French rc = smb2_new_read_req((void **)&req, &total_len, io_parms, NULL, 0, 0);
466938c8a9a5SSteve French if (rc)
467038c8a9a5SSteve French return rc;
467138c8a9a5SSteve French
467238c8a9a5SSteve French if (smb3_encryption_required(io_parms->tcon))
467338c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
467438c8a9a5SSteve French
467538c8a9a5SSteve French iov[0].iov_base = (char *)req;
467638c8a9a5SSteve French iov[0].iov_len = total_len;
467738c8a9a5SSteve French
467838c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
467938c8a9a5SSteve French rqst.rq_iov = iov;
468038c8a9a5SSteve French rqst.rq_nvec = 1;
468138c8a9a5SSteve French
468238c8a9a5SSteve French rc = cifs_send_recv(xid, ses, io_parms->server,
468338c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
468438c8a9a5SSteve French rsp = (struct smb2_read_rsp *)rsp_iov.iov_base;
468538c8a9a5SSteve French
468638c8a9a5SSteve French if (rc) {
468738c8a9a5SSteve French if (rc != -ENODATA) {
468838c8a9a5SSteve French cifs_stats_fail_inc(io_parms->tcon, SMB2_READ_HE);
468938c8a9a5SSteve French cifs_dbg(VFS, "Send error in read = %d\n", rc);
469038c8a9a5SSteve French trace_smb3_read_err(xid,
469138c8a9a5SSteve French req->PersistentFileId,
469238c8a9a5SSteve French io_parms->tcon->tid, ses->Suid,
469338c8a9a5SSteve French io_parms->offset, io_parms->length,
469438c8a9a5SSteve French rc);
469538c8a9a5SSteve French } else
469638c8a9a5SSteve French trace_smb3_read_done(xid, req->PersistentFileId, io_parms->tcon->tid,
469738c8a9a5SSteve French ses->Suid, io_parms->offset, 0);
469838c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
469938c8a9a5SSteve French cifs_small_buf_release(req);
470038c8a9a5SSteve French return rc == -ENODATA ? 0 : rc;
470138c8a9a5SSteve French } else
470238c8a9a5SSteve French trace_smb3_read_done(xid,
470338c8a9a5SSteve French req->PersistentFileId,
470438c8a9a5SSteve French io_parms->tcon->tid, ses->Suid,
470538c8a9a5SSteve French io_parms->offset, io_parms->length);
470638c8a9a5SSteve French
470738c8a9a5SSteve French cifs_small_buf_release(req);
470838c8a9a5SSteve French
470938c8a9a5SSteve French *nbytes = le32_to_cpu(rsp->DataLength);
471038c8a9a5SSteve French if ((*nbytes > CIFS_MAX_MSGSIZE) ||
471138c8a9a5SSteve French (*nbytes > io_parms->length)) {
471238c8a9a5SSteve French cifs_dbg(FYI, "bad length %d for count %d\n",
471338c8a9a5SSteve French *nbytes, io_parms->length);
471438c8a9a5SSteve French rc = -EIO;
471538c8a9a5SSteve French *nbytes = 0;
471638c8a9a5SSteve French }
471738c8a9a5SSteve French
471838c8a9a5SSteve French if (*buf) {
471938c8a9a5SSteve French memcpy(*buf, (char *)rsp + rsp->DataOffset, *nbytes);
472038c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
472138c8a9a5SSteve French } else if (resp_buftype != CIFS_NO_BUFFER) {
472238c8a9a5SSteve French *buf = rsp_iov.iov_base;
472338c8a9a5SSteve French if (resp_buftype == CIFS_SMALL_BUFFER)
472438c8a9a5SSteve French *buf_type = CIFS_SMALL_BUFFER;
472538c8a9a5SSteve French else if (resp_buftype == CIFS_LARGE_BUFFER)
472638c8a9a5SSteve French *buf_type = CIFS_LARGE_BUFFER;
472738c8a9a5SSteve French }
472838c8a9a5SSteve French return rc;
472938c8a9a5SSteve French }
473038c8a9a5SSteve French
473138c8a9a5SSteve French /*
473238c8a9a5SSteve French * Check the mid_state and signature on received buffer (if any), and queue the
473338c8a9a5SSteve French * workqueue completion task.
473438c8a9a5SSteve French */
473538c8a9a5SSteve French static void
smb2_writev_callback(struct mid_q_entry * mid)473638c8a9a5SSteve French smb2_writev_callback(struct mid_q_entry *mid)
473738c8a9a5SSteve French {
473838c8a9a5SSteve French struct cifs_writedata *wdata = mid->callback_data;
473938c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
474038c8a9a5SSteve French struct TCP_Server_Info *server = wdata->server;
474138c8a9a5SSteve French unsigned int written;
474238c8a9a5SSteve French struct smb2_write_rsp *rsp = (struct smb2_write_rsp *)mid->resp_buf;
474338c8a9a5SSteve French struct cifs_credits credits = { .value = 0, .instance = 0 };
474438c8a9a5SSteve French
474538c8a9a5SSteve French WARN_ONCE(wdata->server != mid->server,
474638c8a9a5SSteve French "wdata server %p != mid server %p",
474738c8a9a5SSteve French wdata->server, mid->server);
474838c8a9a5SSteve French
474938c8a9a5SSteve French switch (mid->mid_state) {
475038c8a9a5SSteve French case MID_RESPONSE_RECEIVED:
475138c8a9a5SSteve French credits.value = le16_to_cpu(rsp->hdr.CreditRequest);
475238c8a9a5SSteve French credits.instance = server->reconnect_instance;
475338c8a9a5SSteve French wdata->result = smb2_check_receive(mid, server, 0);
475438c8a9a5SSteve French if (wdata->result != 0)
475538c8a9a5SSteve French break;
475638c8a9a5SSteve French
475738c8a9a5SSteve French written = le32_to_cpu(rsp->DataLength);
475838c8a9a5SSteve French /*
475938c8a9a5SSteve French * Mask off high 16 bits when bytes written as returned
476038c8a9a5SSteve French * by the server is greater than bytes requested by the
476138c8a9a5SSteve French * client. OS/2 servers are known to set incorrect
476238c8a9a5SSteve French * CountHigh values.
476338c8a9a5SSteve French */
476438c8a9a5SSteve French if (written > wdata->bytes)
476538c8a9a5SSteve French written &= 0xFFFF;
476638c8a9a5SSteve French
476738c8a9a5SSteve French if (written < wdata->bytes)
476838c8a9a5SSteve French wdata->result = -ENOSPC;
476938c8a9a5SSteve French else
477038c8a9a5SSteve French wdata->bytes = written;
477138c8a9a5SSteve French break;
477238c8a9a5SSteve French case MID_REQUEST_SUBMITTED:
477338c8a9a5SSteve French case MID_RETRY_NEEDED:
477438c8a9a5SSteve French wdata->result = -EAGAIN;
477538c8a9a5SSteve French break;
477638c8a9a5SSteve French case MID_RESPONSE_MALFORMED:
477738c8a9a5SSteve French credits.value = le16_to_cpu(rsp->hdr.CreditRequest);
477838c8a9a5SSteve French credits.instance = server->reconnect_instance;
477938c8a9a5SSteve French fallthrough;
478038c8a9a5SSteve French default:
478138c8a9a5SSteve French wdata->result = -EIO;
478238c8a9a5SSteve French break;
478338c8a9a5SSteve French }
478438c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
478538c8a9a5SSteve French /*
478638c8a9a5SSteve French * If this wdata has a memory registered, the MR can be freed
478738c8a9a5SSteve French * The number of MRs available is limited, it's important to recover
478838c8a9a5SSteve French * used MR as soon as I/O is finished. Hold MR longer in the later
478938c8a9a5SSteve French * I/O process can possibly result in I/O deadlock due to lack of MR
479038c8a9a5SSteve French * to send request on I/O retry
479138c8a9a5SSteve French */
479238c8a9a5SSteve French if (wdata->mr) {
479338c8a9a5SSteve French smbd_deregister_mr(wdata->mr);
479438c8a9a5SSteve French wdata->mr = NULL;
479538c8a9a5SSteve French }
479638c8a9a5SSteve French #endif
479738c8a9a5SSteve French if (wdata->result) {
479838c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_WRITE_HE);
479938c8a9a5SSteve French trace_smb3_write_err(0 /* no xid */,
480038c8a9a5SSteve French wdata->cfile->fid.persistent_fid,
480138c8a9a5SSteve French tcon->tid, tcon->ses->Suid, wdata->offset,
480238c8a9a5SSteve French wdata->bytes, wdata->result);
480338c8a9a5SSteve French if (wdata->result == -ENOSPC)
480438c8a9a5SSteve French pr_warn_once("Out of space writing to %s\n",
480538c8a9a5SSteve French tcon->tree_name);
480638c8a9a5SSteve French } else
480738c8a9a5SSteve French trace_smb3_write_done(0 /* no xid */,
480838c8a9a5SSteve French wdata->cfile->fid.persistent_fid,
480938c8a9a5SSteve French tcon->tid, tcon->ses->Suid,
481038c8a9a5SSteve French wdata->offset, wdata->bytes);
481138c8a9a5SSteve French
481238c8a9a5SSteve French queue_work(cifsiod_wq, &wdata->work);
481338c8a9a5SSteve French release_mid(mid);
481438c8a9a5SSteve French add_credits(server, &credits, 0);
481538c8a9a5SSteve French }
481638c8a9a5SSteve French
481738c8a9a5SSteve French /* smb2_async_writev - send an async write, and set up mid to handle result */
481838c8a9a5SSteve French int
smb2_async_writev(struct cifs_writedata * wdata,void (* release)(struct kref * kref))481938c8a9a5SSteve French smb2_async_writev(struct cifs_writedata *wdata,
482038c8a9a5SSteve French void (*release)(struct kref *kref))
482138c8a9a5SSteve French {
482238c8a9a5SSteve French int rc = -EACCES, flags = 0;
482338c8a9a5SSteve French struct smb2_write_req *req = NULL;
482438c8a9a5SSteve French struct smb2_hdr *shdr;
482538c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
482638c8a9a5SSteve French struct TCP_Server_Info *server = wdata->server;
482738c8a9a5SSteve French struct kvec iov[1];
482838c8a9a5SSteve French struct smb_rqst rqst = { };
482938c8a9a5SSteve French unsigned int total_len;
483038c8a9a5SSteve French struct cifs_io_parms _io_parms;
483138c8a9a5SSteve French struct cifs_io_parms *io_parms = NULL;
48325e90aa21SShyam Prasad N int credit_request;
483338c8a9a5SSteve French
4834cdd7870aSShyam Prasad N if (!wdata->server || wdata->replay)
483538c8a9a5SSteve French server = wdata->server = cifs_pick_channel(tcon->ses);
483638c8a9a5SSteve French
483738c8a9a5SSteve French /*
483838c8a9a5SSteve French * in future we may get cifs_io_parms passed in from the caller,
483938c8a9a5SSteve French * but for now we construct it here...
484038c8a9a5SSteve French */
484138c8a9a5SSteve French _io_parms = (struct cifs_io_parms) {
484238c8a9a5SSteve French .tcon = tcon,
484338c8a9a5SSteve French .server = server,
484438c8a9a5SSteve French .offset = wdata->offset,
484538c8a9a5SSteve French .length = wdata->bytes,
484638c8a9a5SSteve French .persistent_fid = wdata->cfile->fid.persistent_fid,
484738c8a9a5SSteve French .volatile_fid = wdata->cfile->fid.volatile_fid,
484838c8a9a5SSteve French .pid = wdata->pid,
484938c8a9a5SSteve French };
485038c8a9a5SSteve French io_parms = &_io_parms;
485138c8a9a5SSteve French
485238c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
485338c8a9a5SSteve French (void **) &req, &total_len);
485438c8a9a5SSteve French if (rc)
485538c8a9a5SSteve French return rc;
485638c8a9a5SSteve French
485738c8a9a5SSteve French if (smb3_encryption_required(tcon))
485838c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
485938c8a9a5SSteve French
486038c8a9a5SSteve French shdr = (struct smb2_hdr *)req;
486138c8a9a5SSteve French shdr->Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid);
486238c8a9a5SSteve French
486338c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid;
486438c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid;
486538c8a9a5SSteve French req->WriteChannelInfoOffset = 0;
486638c8a9a5SSteve French req->WriteChannelInfoLength = 0;
486738c8a9a5SSteve French req->Channel = SMB2_CHANNEL_NONE;
486838c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset);
486938c8a9a5SSteve French req->DataOffset = cpu_to_le16(
487038c8a9a5SSteve French offsetof(struct smb2_write_req, Buffer));
487138c8a9a5SSteve French req->RemainingBytes = 0;
487238c8a9a5SSteve French
487338c8a9a5SSteve French trace_smb3_write_enter(0 /* xid */,
487438c8a9a5SSteve French io_parms->persistent_fid,
487538c8a9a5SSteve French io_parms->tcon->tid,
487638c8a9a5SSteve French io_parms->tcon->ses->Suid,
487738c8a9a5SSteve French io_parms->offset,
487838c8a9a5SSteve French io_parms->length);
487938c8a9a5SSteve French
488038c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
488138c8a9a5SSteve French /*
488238c8a9a5SSteve French * If we want to do a server RDMA read, fill in and append
488338c8a9a5SSteve French * smbd_buffer_descriptor_v1 to the end of write request
488438c8a9a5SSteve French */
488538c8a9a5SSteve French if (smb3_use_rdma_offload(io_parms)) {
488638c8a9a5SSteve French struct smbd_buffer_descriptor_v1 *v1;
488738c8a9a5SSteve French size_t data_size = iov_iter_count(&wdata->iter);
488838c8a9a5SSteve French bool need_invalidate = server->dialect == SMB30_PROT_ID;
488938c8a9a5SSteve French
489038c8a9a5SSteve French wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->iter,
489138c8a9a5SSteve French false, need_invalidate);
489238c8a9a5SSteve French if (!wdata->mr) {
489338c8a9a5SSteve French rc = -EAGAIN;
489438c8a9a5SSteve French goto async_writev_out;
489538c8a9a5SSteve French }
489638c8a9a5SSteve French req->Length = 0;
489738c8a9a5SSteve French req->DataOffset = 0;
489838c8a9a5SSteve French req->RemainingBytes = cpu_to_le32(data_size);
489938c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1_INVALIDATE;
490038c8a9a5SSteve French if (need_invalidate)
490138c8a9a5SSteve French req->Channel = SMB2_CHANNEL_RDMA_V1;
490238c8a9a5SSteve French req->WriteChannelInfoOffset =
490338c8a9a5SSteve French cpu_to_le16(offsetof(struct smb2_write_req, Buffer));
490438c8a9a5SSteve French req->WriteChannelInfoLength =
490538c8a9a5SSteve French cpu_to_le16(sizeof(struct smbd_buffer_descriptor_v1));
490638c8a9a5SSteve French v1 = (struct smbd_buffer_descriptor_v1 *) &req->Buffer[0];
490738c8a9a5SSteve French v1->offset = cpu_to_le64(wdata->mr->mr->iova);
490838c8a9a5SSteve French v1->token = cpu_to_le32(wdata->mr->mr->rkey);
490938c8a9a5SSteve French v1->length = cpu_to_le32(wdata->mr->mr->length);
491038c8a9a5SSteve French }
491138c8a9a5SSteve French #endif
491238c8a9a5SSteve French iov[0].iov_len = total_len - 1;
491338c8a9a5SSteve French iov[0].iov_base = (char *)req;
491438c8a9a5SSteve French
491538c8a9a5SSteve French rqst.rq_iov = iov;
491638c8a9a5SSteve French rqst.rq_nvec = 1;
491738c8a9a5SSteve French rqst.rq_iter = wdata->iter;
491838c8a9a5SSteve French rqst.rq_iter_size = iov_iter_count(&rqst.rq_iter);
4919cdd7870aSShyam Prasad N if (wdata->replay)
4920cdd7870aSShyam Prasad N smb2_set_replay(server, &rqst);
492138c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
492238c8a9a5SSteve French if (wdata->mr)
492338c8a9a5SSteve French iov[0].iov_len += sizeof(struct smbd_buffer_descriptor_v1);
492438c8a9a5SSteve French #endif
492538c8a9a5SSteve French cifs_dbg(FYI, "async write at %llu %u bytes iter=%zx\n",
492638c8a9a5SSteve French io_parms->offset, io_parms->length, iov_iter_count(&rqst.rq_iter));
492738c8a9a5SSteve French
492838c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT
492938c8a9a5SSteve French /* For RDMA read, I/O size is in RemainingBytes not in Length */
493038c8a9a5SSteve French if (!wdata->mr)
493138c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length);
493238c8a9a5SSteve French #else
493338c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length);
493438c8a9a5SSteve French #endif
493538c8a9a5SSteve French
493638c8a9a5SSteve French if (wdata->credits.value > 0) {
493738c8a9a5SSteve French shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(wdata->bytes,
493838c8a9a5SSteve French SMB2_MAX_BUFFER_SIZE));
49395e90aa21SShyam Prasad N credit_request = le16_to_cpu(shdr->CreditCharge) + 8;
49405e90aa21SShyam Prasad N if (server->credits >= server->max_credits)
49415e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(0);
49425e90aa21SShyam Prasad N else
49435e90aa21SShyam Prasad N shdr->CreditRequest = cpu_to_le16(
49445e90aa21SShyam Prasad N min_t(int, server->max_credits -
49455e90aa21SShyam Prasad N server->credits, credit_request));
494638c8a9a5SSteve French
494738c8a9a5SSteve French rc = adjust_credits(server, &wdata->credits, io_parms->length);
494838c8a9a5SSteve French if (rc)
494938c8a9a5SSteve French goto async_writev_out;
495038c8a9a5SSteve French
495138c8a9a5SSteve French flags |= CIFS_HAS_CREDITS;
495238c8a9a5SSteve French }
495338c8a9a5SSteve French
495438c8a9a5SSteve French kref_get(&wdata->refcount);
495538c8a9a5SSteve French rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
495638c8a9a5SSteve French wdata, flags, &wdata->credits);
495738c8a9a5SSteve French
495838c8a9a5SSteve French if (rc) {
495938c8a9a5SSteve French trace_smb3_write_err(0 /* no xid */,
496038c8a9a5SSteve French io_parms->persistent_fid,
496138c8a9a5SSteve French io_parms->tcon->tid,
496238c8a9a5SSteve French io_parms->tcon->ses->Suid,
496338c8a9a5SSteve French io_parms->offset,
496438c8a9a5SSteve French io_parms->length,
496538c8a9a5SSteve French rc);
496638c8a9a5SSteve French kref_put(&wdata->refcount, release);
496738c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_WRITE_HE);
496838c8a9a5SSteve French }
496938c8a9a5SSteve French
497038c8a9a5SSteve French async_writev_out:
497138c8a9a5SSteve French cifs_small_buf_release(req);
497238c8a9a5SSteve French return rc;
497338c8a9a5SSteve French }
497438c8a9a5SSteve French
497538c8a9a5SSteve French /*
497638c8a9a5SSteve French * SMB2_write function gets iov pointer to kvec array with n_vec as a length.
497738c8a9a5SSteve French * The length field from io_parms must be at least 1 and indicates a number of
497838c8a9a5SSteve French * elements with data to write that begins with position 1 in iov array. All
497938c8a9a5SSteve French * data length is specified by count.
498038c8a9a5SSteve French */
498138c8a9a5SSteve French int
SMB2_write(const unsigned int xid,struct cifs_io_parms * io_parms,unsigned int * nbytes,struct kvec * iov,int n_vec)498238c8a9a5SSteve French SMB2_write(const unsigned int xid, struct cifs_io_parms *io_parms,
498338c8a9a5SSteve French unsigned int *nbytes, struct kvec *iov, int n_vec)
498438c8a9a5SSteve French {
498538c8a9a5SSteve French struct smb_rqst rqst;
498638c8a9a5SSteve French int rc = 0;
498738c8a9a5SSteve French struct smb2_write_req *req = NULL;
498838c8a9a5SSteve French struct smb2_write_rsp *rsp = NULL;
498938c8a9a5SSteve French int resp_buftype;
499038c8a9a5SSteve French struct kvec rsp_iov;
499138c8a9a5SSteve French int flags = 0;
499238c8a9a5SSteve French unsigned int total_len;
499338c8a9a5SSteve French struct TCP_Server_Info *server;
4994433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
499538c8a9a5SSteve French
4996433042a9SShyam Prasad N replay_again:
4997433042a9SShyam Prasad N /* reinitialize for possible replay */
4998433042a9SShyam Prasad N flags = 0;
499938c8a9a5SSteve French *nbytes = 0;
500038c8a9a5SSteve French if (!io_parms->server)
500138c8a9a5SSteve French io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
500238c8a9a5SSteve French server = io_parms->server;
500338c8a9a5SSteve French if (server == NULL)
500438c8a9a5SSteve French return -ECONNABORTED;
500538c8a9a5SSteve French
5006433042a9SShyam Prasad N if (n_vec < 1)
5007433042a9SShyam Prasad N return rc;
5008433042a9SShyam Prasad N
500938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
501038c8a9a5SSteve French (void **) &req, &total_len);
501138c8a9a5SSteve French if (rc)
501238c8a9a5SSteve French return rc;
501338c8a9a5SSteve French
501438c8a9a5SSteve French if (smb3_encryption_required(io_parms->tcon))
501538c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
501638c8a9a5SSteve French
501738c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(io_parms->pid);
501838c8a9a5SSteve French
501938c8a9a5SSteve French req->PersistentFileId = io_parms->persistent_fid;
502038c8a9a5SSteve French req->VolatileFileId = io_parms->volatile_fid;
502138c8a9a5SSteve French req->WriteChannelInfoOffset = 0;
502238c8a9a5SSteve French req->WriteChannelInfoLength = 0;
502338c8a9a5SSteve French req->Channel = 0;
502438c8a9a5SSteve French req->Length = cpu_to_le32(io_parms->length);
502538c8a9a5SSteve French req->Offset = cpu_to_le64(io_parms->offset);
502638c8a9a5SSteve French req->DataOffset = cpu_to_le16(
502738c8a9a5SSteve French offsetof(struct smb2_write_req, Buffer));
502838c8a9a5SSteve French req->RemainingBytes = 0;
502938c8a9a5SSteve French
503038c8a9a5SSteve French trace_smb3_write_enter(xid, io_parms->persistent_fid,
503138c8a9a5SSteve French io_parms->tcon->tid, io_parms->tcon->ses->Suid,
503238c8a9a5SSteve French io_parms->offset, io_parms->length);
503338c8a9a5SSteve French
503438c8a9a5SSteve French iov[0].iov_base = (char *)req;
503538c8a9a5SSteve French /* 1 for Buffer */
503638c8a9a5SSteve French iov[0].iov_len = total_len - 1;
503738c8a9a5SSteve French
503838c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
503938c8a9a5SSteve French rqst.rq_iov = iov;
504038c8a9a5SSteve French rqst.rq_nvec = n_vec + 1;
504138c8a9a5SSteve French
5042433042a9SShyam Prasad N if (retries)
5043433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5044433042a9SShyam Prasad N
504538c8a9a5SSteve French rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
504638c8a9a5SSteve French &rqst,
504738c8a9a5SSteve French &resp_buftype, flags, &rsp_iov);
504838c8a9a5SSteve French rsp = (struct smb2_write_rsp *)rsp_iov.iov_base;
504938c8a9a5SSteve French
505038c8a9a5SSteve French if (rc) {
505138c8a9a5SSteve French trace_smb3_write_err(xid,
505238c8a9a5SSteve French req->PersistentFileId,
505338c8a9a5SSteve French io_parms->tcon->tid,
505438c8a9a5SSteve French io_parms->tcon->ses->Suid,
505538c8a9a5SSteve French io_parms->offset, io_parms->length, rc);
505638c8a9a5SSteve French cifs_stats_fail_inc(io_parms->tcon, SMB2_WRITE_HE);
505738c8a9a5SSteve French cifs_dbg(VFS, "Send error in write = %d\n", rc);
505838c8a9a5SSteve French } else {
505938c8a9a5SSteve French *nbytes = le32_to_cpu(rsp->DataLength);
506038c8a9a5SSteve French trace_smb3_write_done(xid,
506138c8a9a5SSteve French req->PersistentFileId,
506238c8a9a5SSteve French io_parms->tcon->tid,
506338c8a9a5SSteve French io_parms->tcon->ses->Suid,
506438c8a9a5SSteve French io_parms->offset, *nbytes);
506538c8a9a5SSteve French }
506638c8a9a5SSteve French
506738c8a9a5SSteve French cifs_small_buf_release(req);
506838c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp);
5069433042a9SShyam Prasad N
5070433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5071433042a9SShyam Prasad N smb2_should_replay(io_parms->tcon, &retries, &cur_sleep))
5072433042a9SShyam Prasad N goto replay_again;
5073433042a9SShyam Prasad N
507438c8a9a5SSteve French return rc;
507538c8a9a5SSteve French }
507638c8a9a5SSteve French
posix_info_sid_size(const void * beg,const void * end)507738c8a9a5SSteve French int posix_info_sid_size(const void *beg, const void *end)
507838c8a9a5SSteve French {
507938c8a9a5SSteve French size_t subauth;
508038c8a9a5SSteve French int total;
508138c8a9a5SSteve French
508238c8a9a5SSteve French if (beg + 1 > end)
508338c8a9a5SSteve French return -1;
508438c8a9a5SSteve French
508538c8a9a5SSteve French subauth = *(u8 *)(beg+1);
508638c8a9a5SSteve French if (subauth < 1 || subauth > 15)
508738c8a9a5SSteve French return -1;
508838c8a9a5SSteve French
508938c8a9a5SSteve French total = 1 + 1 + 6 + 4*subauth;
509038c8a9a5SSteve French if (beg + total > end)
509138c8a9a5SSteve French return -1;
509238c8a9a5SSteve French
509338c8a9a5SSteve French return total;
509438c8a9a5SSteve French }
509538c8a9a5SSteve French
posix_info_parse(const void * beg,const void * end,struct smb2_posix_info_parsed * out)509638c8a9a5SSteve French int posix_info_parse(const void *beg, const void *end,
509738c8a9a5SSteve French struct smb2_posix_info_parsed *out)
509838c8a9a5SSteve French
509938c8a9a5SSteve French {
510038c8a9a5SSteve French int total_len = 0;
510138c8a9a5SSteve French int owner_len, group_len;
510238c8a9a5SSteve French int name_len;
510338c8a9a5SSteve French const void *owner_sid;
510438c8a9a5SSteve French const void *group_sid;
510538c8a9a5SSteve French const void *name;
510638c8a9a5SSteve French
510738c8a9a5SSteve French /* if no end bound given, assume payload to be correct */
510838c8a9a5SSteve French if (!end) {
510938c8a9a5SSteve French const struct smb2_posix_info *p = beg;
511038c8a9a5SSteve French
511138c8a9a5SSteve French end = beg + le32_to_cpu(p->NextEntryOffset);
511238c8a9a5SSteve French /* last element will have a 0 offset, pick a sensible bound */
511338c8a9a5SSteve French if (end == beg)
511438c8a9a5SSteve French end += 0xFFFF;
511538c8a9a5SSteve French }
511638c8a9a5SSteve French
511738c8a9a5SSteve French /* check base buf */
511838c8a9a5SSteve French if (beg + sizeof(struct smb2_posix_info) > end)
511938c8a9a5SSteve French return -1;
512038c8a9a5SSteve French total_len = sizeof(struct smb2_posix_info);
512138c8a9a5SSteve French
512238c8a9a5SSteve French /* check owner sid */
512338c8a9a5SSteve French owner_sid = beg + total_len;
512438c8a9a5SSteve French owner_len = posix_info_sid_size(owner_sid, end);
512538c8a9a5SSteve French if (owner_len < 0)
512638c8a9a5SSteve French return -1;
512738c8a9a5SSteve French total_len += owner_len;
512838c8a9a5SSteve French
512938c8a9a5SSteve French /* check group sid */
513038c8a9a5SSteve French group_sid = beg + total_len;
513138c8a9a5SSteve French group_len = posix_info_sid_size(group_sid, end);
513238c8a9a5SSteve French if (group_len < 0)
513338c8a9a5SSteve French return -1;
513438c8a9a5SSteve French total_len += group_len;
513538c8a9a5SSteve French
513638c8a9a5SSteve French /* check name len */
513738c8a9a5SSteve French if (beg + total_len + 4 > end)
513838c8a9a5SSteve French return -1;
513938c8a9a5SSteve French name_len = le32_to_cpu(*(__le32 *)(beg + total_len));
514038c8a9a5SSteve French if (name_len < 1 || name_len > 0xFFFF)
514138c8a9a5SSteve French return -1;
514238c8a9a5SSteve French total_len += 4;
514338c8a9a5SSteve French
514438c8a9a5SSteve French /* check name */
514538c8a9a5SSteve French name = beg + total_len;
514638c8a9a5SSteve French if (name + name_len > end)
514738c8a9a5SSteve French return -1;
514838c8a9a5SSteve French total_len += name_len;
514938c8a9a5SSteve French
515038c8a9a5SSteve French if (out) {
515138c8a9a5SSteve French out->base = beg;
515238c8a9a5SSteve French out->size = total_len;
515338c8a9a5SSteve French out->name_len = name_len;
515438c8a9a5SSteve French out->name = name;
515538c8a9a5SSteve French memcpy(&out->owner, owner_sid, owner_len);
515638c8a9a5SSteve French memcpy(&out->group, group_sid, group_len);
515738c8a9a5SSteve French }
515838c8a9a5SSteve French return total_len;
515938c8a9a5SSteve French }
516038c8a9a5SSteve French
posix_info_extra_size(const void * beg,const void * end)516138c8a9a5SSteve French static int posix_info_extra_size(const void *beg, const void *end)
516238c8a9a5SSteve French {
516338c8a9a5SSteve French int len = posix_info_parse(beg, end, NULL);
516438c8a9a5SSteve French
516538c8a9a5SSteve French if (len < 0)
516638c8a9a5SSteve French return -1;
516738c8a9a5SSteve French return len - sizeof(struct smb2_posix_info);
516838c8a9a5SSteve French }
516938c8a9a5SSteve French
517038c8a9a5SSteve French static unsigned int
num_entries(int infotype,char * bufstart,char * end_of_buf,char ** lastentry,size_t size)517138c8a9a5SSteve French num_entries(int infotype, char *bufstart, char *end_of_buf, char **lastentry,
517238c8a9a5SSteve French size_t size)
517338c8a9a5SSteve French {
517438c8a9a5SSteve French int len;
517538c8a9a5SSteve French unsigned int entrycount = 0;
517638c8a9a5SSteve French unsigned int next_offset = 0;
517738c8a9a5SSteve French char *entryptr;
517838c8a9a5SSteve French FILE_DIRECTORY_INFO *dir_info;
517938c8a9a5SSteve French
518038c8a9a5SSteve French if (bufstart == NULL)
518138c8a9a5SSteve French return 0;
518238c8a9a5SSteve French
518338c8a9a5SSteve French entryptr = bufstart;
518438c8a9a5SSteve French
518538c8a9a5SSteve French while (1) {
518638c8a9a5SSteve French if (entryptr + next_offset < entryptr ||
518738c8a9a5SSteve French entryptr + next_offset > end_of_buf ||
518838c8a9a5SSteve French entryptr + next_offset + size > end_of_buf) {
518938c8a9a5SSteve French cifs_dbg(VFS, "malformed search entry would overflow\n");
519038c8a9a5SSteve French break;
519138c8a9a5SSteve French }
519238c8a9a5SSteve French
519338c8a9a5SSteve French entryptr = entryptr + next_offset;
519438c8a9a5SSteve French dir_info = (FILE_DIRECTORY_INFO *)entryptr;
519538c8a9a5SSteve French
519638c8a9a5SSteve French if (infotype == SMB_FIND_FILE_POSIX_INFO)
519738c8a9a5SSteve French len = posix_info_extra_size(entryptr, end_of_buf);
519838c8a9a5SSteve French else
519938c8a9a5SSteve French len = le32_to_cpu(dir_info->FileNameLength);
520038c8a9a5SSteve French
520138c8a9a5SSteve French if (len < 0 ||
520238c8a9a5SSteve French entryptr + len < entryptr ||
520338c8a9a5SSteve French entryptr + len > end_of_buf ||
520438c8a9a5SSteve French entryptr + len + size > end_of_buf) {
520538c8a9a5SSteve French cifs_dbg(VFS, "directory entry name would overflow frame end of buf %p\n",
520638c8a9a5SSteve French end_of_buf);
520738c8a9a5SSteve French break;
520838c8a9a5SSteve French }
520938c8a9a5SSteve French
521038c8a9a5SSteve French *lastentry = entryptr;
521138c8a9a5SSteve French entrycount++;
521238c8a9a5SSteve French
521338c8a9a5SSteve French next_offset = le32_to_cpu(dir_info->NextEntryOffset);
521438c8a9a5SSteve French if (!next_offset)
521538c8a9a5SSteve French break;
521638c8a9a5SSteve French }
521738c8a9a5SSteve French
521838c8a9a5SSteve French return entrycount;
521938c8a9a5SSteve French }
522038c8a9a5SSteve French
522138c8a9a5SSteve French /*
522238c8a9a5SSteve French * Readdir/FindFirst
522338c8a9a5SSteve French */
SMB2_query_directory_init(const unsigned int xid,struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,u64 persistent_fid,u64 volatile_fid,int index,int info_level)522438c8a9a5SSteve French int SMB2_query_directory_init(const unsigned int xid,
522538c8a9a5SSteve French struct cifs_tcon *tcon,
522638c8a9a5SSteve French struct TCP_Server_Info *server,
522738c8a9a5SSteve French struct smb_rqst *rqst,
522838c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid,
522938c8a9a5SSteve French int index, int info_level)
523038c8a9a5SSteve French {
523138c8a9a5SSteve French struct smb2_query_directory_req *req;
523238c8a9a5SSteve French unsigned char *bufptr;
523338c8a9a5SSteve French __le16 asteriks = cpu_to_le16('*');
523438c8a9a5SSteve French unsigned int output_size = CIFSMaxBufSize -
523538c8a9a5SSteve French MAX_SMB2_CREATE_RESPONSE_SIZE -
523638c8a9a5SSteve French MAX_SMB2_CLOSE_RESPONSE_SIZE;
523738c8a9a5SSteve French unsigned int total_len;
523838c8a9a5SSteve French struct kvec *iov = rqst->rq_iov;
523938c8a9a5SSteve French int len, rc;
524038c8a9a5SSteve French
524138c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
524238c8a9a5SSteve French (void **) &req, &total_len);
524338c8a9a5SSteve French if (rc)
524438c8a9a5SSteve French return rc;
524538c8a9a5SSteve French
524638c8a9a5SSteve French switch (info_level) {
524738c8a9a5SSteve French case SMB_FIND_FILE_DIRECTORY_INFO:
524838c8a9a5SSteve French req->FileInformationClass = FILE_DIRECTORY_INFORMATION;
524938c8a9a5SSteve French break;
525038c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO:
525138c8a9a5SSteve French req->FileInformationClass = FILEID_FULL_DIRECTORY_INFORMATION;
525238c8a9a5SSteve French break;
525338c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO:
525438c8a9a5SSteve French req->FileInformationClass = SMB_FIND_FILE_POSIX_INFO;
525538c8a9a5SSteve French break;
5256cacc0a9cSPaulo Alcantara case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
5257cacc0a9cSPaulo Alcantara req->FileInformationClass = FILE_FULL_DIRECTORY_INFORMATION;
5258cacc0a9cSPaulo Alcantara break;
525938c8a9a5SSteve French default:
526038c8a9a5SSteve French cifs_tcon_dbg(VFS, "info level %u isn't supported\n",
526138c8a9a5SSteve French info_level);
526238c8a9a5SSteve French return -EINVAL;
526338c8a9a5SSteve French }
526438c8a9a5SSteve French
526538c8a9a5SSteve French req->FileIndex = cpu_to_le32(index);
526638c8a9a5SSteve French req->PersistentFileId = persistent_fid;
526738c8a9a5SSteve French req->VolatileFileId = volatile_fid;
526838c8a9a5SSteve French
526938c8a9a5SSteve French len = 0x2;
527038c8a9a5SSteve French bufptr = req->Buffer;
527138c8a9a5SSteve French memcpy(bufptr, &asteriks, len);
527238c8a9a5SSteve French
527338c8a9a5SSteve French req->FileNameOffset =
527438c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_query_directory_req));
527538c8a9a5SSteve French req->FileNameLength = cpu_to_le16(len);
527638c8a9a5SSteve French /*
527738c8a9a5SSteve French * BB could be 30 bytes or so longer if we used SMB2 specific
527838c8a9a5SSteve French * buffer lengths, but this is safe and close enough.
527938c8a9a5SSteve French */
528038c8a9a5SSteve French output_size = min_t(unsigned int, output_size, server->maxBuf);
528138c8a9a5SSteve French output_size = min_t(unsigned int, output_size, 2 << 15);
528238c8a9a5SSteve French req->OutputBufferLength = cpu_to_le32(output_size);
528338c8a9a5SSteve French
528438c8a9a5SSteve French iov[0].iov_base = (char *)req;
528538c8a9a5SSteve French /* 1 for Buffer */
528638c8a9a5SSteve French iov[0].iov_len = total_len - 1;
528738c8a9a5SSteve French
528838c8a9a5SSteve French iov[1].iov_base = (char *)(req->Buffer);
528938c8a9a5SSteve French iov[1].iov_len = len;
529038c8a9a5SSteve French
529138c8a9a5SSteve French trace_smb3_query_dir_enter(xid, persistent_fid, tcon->tid,
529238c8a9a5SSteve French tcon->ses->Suid, index, output_size);
529338c8a9a5SSteve French
529438c8a9a5SSteve French return 0;
529538c8a9a5SSteve French }
529638c8a9a5SSteve French
SMB2_query_directory_free(struct smb_rqst * rqst)529738c8a9a5SSteve French void SMB2_query_directory_free(struct smb_rqst *rqst)
529838c8a9a5SSteve French {
529938c8a9a5SSteve French if (rqst && rqst->rq_iov) {
530038c8a9a5SSteve French cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */
530138c8a9a5SSteve French }
530238c8a9a5SSteve French }
530338c8a9a5SSteve French
530438c8a9a5SSteve French int
smb2_parse_query_directory(struct cifs_tcon * tcon,struct kvec * rsp_iov,int resp_buftype,struct cifs_search_info * srch_inf)530538c8a9a5SSteve French smb2_parse_query_directory(struct cifs_tcon *tcon,
530638c8a9a5SSteve French struct kvec *rsp_iov,
530738c8a9a5SSteve French int resp_buftype,
530838c8a9a5SSteve French struct cifs_search_info *srch_inf)
530938c8a9a5SSteve French {
531038c8a9a5SSteve French struct smb2_query_directory_rsp *rsp;
531138c8a9a5SSteve French size_t info_buf_size;
531238c8a9a5SSteve French char *end_of_smb;
531338c8a9a5SSteve French int rc;
531438c8a9a5SSteve French
531538c8a9a5SSteve French rsp = (struct smb2_query_directory_rsp *)rsp_iov->iov_base;
531638c8a9a5SSteve French
531738c8a9a5SSteve French switch (srch_inf->info_level) {
531838c8a9a5SSteve French case SMB_FIND_FILE_DIRECTORY_INFO:
531938c8a9a5SSteve French info_buf_size = sizeof(FILE_DIRECTORY_INFO);
532038c8a9a5SSteve French break;
532138c8a9a5SSteve French case SMB_FIND_FILE_ID_FULL_DIR_INFO:
532238c8a9a5SSteve French info_buf_size = sizeof(SEARCH_ID_FULL_DIR_INFO);
532338c8a9a5SSteve French break;
532438c8a9a5SSteve French case SMB_FIND_FILE_POSIX_INFO:
532538c8a9a5SSteve French /* note that posix payload are variable size */
532638c8a9a5SSteve French info_buf_size = sizeof(struct smb2_posix_info);
532738c8a9a5SSteve French break;
5328cacc0a9cSPaulo Alcantara case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
5329cacc0a9cSPaulo Alcantara info_buf_size = sizeof(FILE_FULL_DIRECTORY_INFO);
5330cacc0a9cSPaulo Alcantara break;
533138c8a9a5SSteve French default:
533238c8a9a5SSteve French cifs_tcon_dbg(VFS, "info level %u isn't supported\n",
533338c8a9a5SSteve French srch_inf->info_level);
533438c8a9a5SSteve French return -EINVAL;
533538c8a9a5SSteve French }
533638c8a9a5SSteve French
533738c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
533838c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), rsp_iov,
533938c8a9a5SSteve French info_buf_size);
534038c8a9a5SSteve French if (rc) {
534138c8a9a5SSteve French cifs_tcon_dbg(VFS, "bad info payload");
534238c8a9a5SSteve French return rc;
534338c8a9a5SSteve French }
534438c8a9a5SSteve French
534538c8a9a5SSteve French srch_inf->unicode = true;
534638c8a9a5SSteve French
534738c8a9a5SSteve French if (srch_inf->ntwrk_buf_start) {
534838c8a9a5SSteve French if (srch_inf->smallBuf)
534938c8a9a5SSteve French cifs_small_buf_release(srch_inf->ntwrk_buf_start);
535038c8a9a5SSteve French else
535138c8a9a5SSteve French cifs_buf_release(srch_inf->ntwrk_buf_start);
535238c8a9a5SSteve French }
535338c8a9a5SSteve French srch_inf->ntwrk_buf_start = (char *)rsp;
535438c8a9a5SSteve French srch_inf->srch_entries_start = srch_inf->last_entry =
535538c8a9a5SSteve French (char *)rsp + le16_to_cpu(rsp->OutputBufferOffset);
535638c8a9a5SSteve French end_of_smb = rsp_iov->iov_len + (char *)rsp;
535738c8a9a5SSteve French
535838c8a9a5SSteve French srch_inf->entries_in_buffer = num_entries(
535938c8a9a5SSteve French srch_inf->info_level,
536038c8a9a5SSteve French srch_inf->srch_entries_start,
536138c8a9a5SSteve French end_of_smb,
536238c8a9a5SSteve French &srch_inf->last_entry,
536338c8a9a5SSteve French info_buf_size);
536438c8a9a5SSteve French
536538c8a9a5SSteve French srch_inf->index_of_last_entry += srch_inf->entries_in_buffer;
536638c8a9a5SSteve French cifs_dbg(FYI, "num entries %d last_index %lld srch start %p srch end %p\n",
536738c8a9a5SSteve French srch_inf->entries_in_buffer, srch_inf->index_of_last_entry,
536838c8a9a5SSteve French srch_inf->srch_entries_start, srch_inf->last_entry);
536938c8a9a5SSteve French if (resp_buftype == CIFS_LARGE_BUFFER)
537038c8a9a5SSteve French srch_inf->smallBuf = false;
537138c8a9a5SSteve French else if (resp_buftype == CIFS_SMALL_BUFFER)
537238c8a9a5SSteve French srch_inf->smallBuf = true;
537338c8a9a5SSteve French else
537438c8a9a5SSteve French cifs_tcon_dbg(VFS, "Invalid search buffer type\n");
537538c8a9a5SSteve French
537638c8a9a5SSteve French return 0;
537738c8a9a5SSteve French }
537838c8a9a5SSteve French
537938c8a9a5SSteve French int
SMB2_query_directory(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,int index,struct cifs_search_info * srch_inf)538038c8a9a5SSteve French SMB2_query_directory(const unsigned int xid, struct cifs_tcon *tcon,
538138c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, int index,
538238c8a9a5SSteve French struct cifs_search_info *srch_inf)
538338c8a9a5SSteve French {
538438c8a9a5SSteve French struct smb_rqst rqst;
538538c8a9a5SSteve French struct kvec iov[SMB2_QUERY_DIRECTORY_IOV_SIZE];
538638c8a9a5SSteve French struct smb2_query_directory_rsp *rsp = NULL;
538738c8a9a5SSteve French int resp_buftype = CIFS_NO_BUFFER;
538838c8a9a5SSteve French struct kvec rsp_iov;
538938c8a9a5SSteve French int rc = 0;
539038c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5391433042a9SShyam Prasad N struct TCP_Server_Info *server;
539238c8a9a5SSteve French int flags = 0;
5393433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5394433042a9SShyam Prasad N
5395433042a9SShyam Prasad N replay_again:
5396433042a9SShyam Prasad N /* reinitialize for possible replay */
5397433042a9SShyam Prasad N flags = 0;
5398433042a9SShyam Prasad N server = cifs_pick_channel(ses);
539938c8a9a5SSteve French
540038c8a9a5SSteve French if (!ses || !(ses->server))
540138c8a9a5SSteve French return -EIO;
540238c8a9a5SSteve French
540338c8a9a5SSteve French if (smb3_encryption_required(tcon))
540438c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
540538c8a9a5SSteve French
540638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
540738c8a9a5SSteve French memset(&iov, 0, sizeof(iov));
540838c8a9a5SSteve French rqst.rq_iov = iov;
540938c8a9a5SSteve French rqst.rq_nvec = SMB2_QUERY_DIRECTORY_IOV_SIZE;
541038c8a9a5SSteve French
541138c8a9a5SSteve French rc = SMB2_query_directory_init(xid, tcon, server,
541238c8a9a5SSteve French &rqst, persistent_fid,
541338c8a9a5SSteve French volatile_fid, index,
541438c8a9a5SSteve French srch_inf->info_level);
541538c8a9a5SSteve French if (rc)
541638c8a9a5SSteve French goto qdir_exit;
541738c8a9a5SSteve French
5418433042a9SShyam Prasad N if (retries)
5419433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5420433042a9SShyam Prasad N
542138c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
542238c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
542338c8a9a5SSteve French rsp = (struct smb2_query_directory_rsp *)rsp_iov.iov_base;
542438c8a9a5SSteve French
542538c8a9a5SSteve French if (rc) {
542638c8a9a5SSteve French if (rc == -ENODATA &&
542738c8a9a5SSteve French rsp->hdr.Status == STATUS_NO_MORE_FILES) {
542838c8a9a5SSteve French trace_smb3_query_dir_done(xid, persistent_fid,
542938c8a9a5SSteve French tcon->tid, tcon->ses->Suid, index, 0);
543038c8a9a5SSteve French srch_inf->endOfSearch = true;
543138c8a9a5SSteve French rc = 0;
543238c8a9a5SSteve French } else {
543338c8a9a5SSteve French trace_smb3_query_dir_err(xid, persistent_fid, tcon->tid,
543438c8a9a5SSteve French tcon->ses->Suid, index, 0, rc);
543538c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_DIRECTORY_HE);
543638c8a9a5SSteve French }
543738c8a9a5SSteve French goto qdir_exit;
543838c8a9a5SSteve French }
543938c8a9a5SSteve French
544038c8a9a5SSteve French rc = smb2_parse_query_directory(tcon, &rsp_iov, resp_buftype,
544138c8a9a5SSteve French srch_inf);
544238c8a9a5SSteve French if (rc) {
544338c8a9a5SSteve French trace_smb3_query_dir_err(xid, persistent_fid, tcon->tid,
544438c8a9a5SSteve French tcon->ses->Suid, index, 0, rc);
544538c8a9a5SSteve French goto qdir_exit;
544638c8a9a5SSteve French }
544738c8a9a5SSteve French resp_buftype = CIFS_NO_BUFFER;
544838c8a9a5SSteve French
544938c8a9a5SSteve French trace_smb3_query_dir_done(xid, persistent_fid, tcon->tid,
545038c8a9a5SSteve French tcon->ses->Suid, index, srch_inf->entries_in_buffer);
545138c8a9a5SSteve French
545238c8a9a5SSteve French qdir_exit:
545338c8a9a5SSteve French SMB2_query_directory_free(&rqst);
545438c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp);
5455433042a9SShyam Prasad N
5456433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5457433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5458433042a9SShyam Prasad N goto replay_again;
5459433042a9SShyam Prasad N
546038c8a9a5SSteve French return rc;
546138c8a9a5SSteve French }
546238c8a9a5SSteve French
546338c8a9a5SSteve French int
SMB2_set_info_init(struct cifs_tcon * tcon,struct TCP_Server_Info * server,struct smb_rqst * rqst,u64 persistent_fid,u64 volatile_fid,u32 pid,u8 info_class,u8 info_type,u32 additional_info,void ** data,unsigned int * size)546438c8a9a5SSteve French SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
546538c8a9a5SSteve French struct smb_rqst *rqst,
546638c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u32 pid,
546738c8a9a5SSteve French u8 info_class, u8 info_type, u32 additional_info,
546838c8a9a5SSteve French void **data, unsigned int *size)
546938c8a9a5SSteve French {
547038c8a9a5SSteve French struct smb2_set_info_req *req;
547138c8a9a5SSteve French struct kvec *iov = rqst->rq_iov;
547238c8a9a5SSteve French unsigned int i, total_len;
547338c8a9a5SSteve French int rc;
547438c8a9a5SSteve French
547538c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
547638c8a9a5SSteve French (void **) &req, &total_len);
547738c8a9a5SSteve French if (rc)
547838c8a9a5SSteve French return rc;
547938c8a9a5SSteve French
548038c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(pid);
548138c8a9a5SSteve French req->InfoType = info_type;
548238c8a9a5SSteve French req->FileInfoClass = info_class;
548338c8a9a5SSteve French req->PersistentFileId = persistent_fid;
548438c8a9a5SSteve French req->VolatileFileId = volatile_fid;
548538c8a9a5SSteve French req->AdditionalInformation = cpu_to_le32(additional_info);
548638c8a9a5SSteve French
548738c8a9a5SSteve French req->BufferOffset = cpu_to_le16(sizeof(struct smb2_set_info_req));
548838c8a9a5SSteve French req->BufferLength = cpu_to_le32(*size);
548938c8a9a5SSteve French
549038c8a9a5SSteve French memcpy(req->Buffer, *data, *size);
549138c8a9a5SSteve French total_len += *size;
549238c8a9a5SSteve French
549338c8a9a5SSteve French iov[0].iov_base = (char *)req;
549438c8a9a5SSteve French /* 1 for Buffer */
549538c8a9a5SSteve French iov[0].iov_len = total_len - 1;
549638c8a9a5SSteve French
549738c8a9a5SSteve French for (i = 1; i < rqst->rq_nvec; i++) {
549838c8a9a5SSteve French le32_add_cpu(&req->BufferLength, size[i]);
549938c8a9a5SSteve French iov[i].iov_base = (char *)data[i];
550038c8a9a5SSteve French iov[i].iov_len = size[i];
550138c8a9a5SSteve French }
550238c8a9a5SSteve French
550338c8a9a5SSteve French return 0;
550438c8a9a5SSteve French }
550538c8a9a5SSteve French
550638c8a9a5SSteve French void
SMB2_set_info_free(struct smb_rqst * rqst)550738c8a9a5SSteve French SMB2_set_info_free(struct smb_rqst *rqst)
550838c8a9a5SSteve French {
550938c8a9a5SSteve French if (rqst && rqst->rq_iov)
551038c8a9a5SSteve French cifs_buf_release(rqst->rq_iov[0].iov_base); /* request */
551138c8a9a5SSteve French }
551238c8a9a5SSteve French
551338c8a9a5SSteve French static int
send_set_info(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,u32 pid,u8 info_class,u8 info_type,u32 additional_info,unsigned int num,void ** data,unsigned int * size)551438c8a9a5SSteve French send_set_info(const unsigned int xid, struct cifs_tcon *tcon,
551538c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, u32 pid, u8 info_class,
551638c8a9a5SSteve French u8 info_type, u32 additional_info, unsigned int num,
551738c8a9a5SSteve French void **data, unsigned int *size)
551838c8a9a5SSteve French {
551938c8a9a5SSteve French struct smb_rqst rqst;
552038c8a9a5SSteve French struct smb2_set_info_rsp *rsp = NULL;
552138c8a9a5SSteve French struct kvec *iov;
552238c8a9a5SSteve French struct kvec rsp_iov;
552338c8a9a5SSteve French int rc = 0;
552438c8a9a5SSteve French int resp_buftype;
552538c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5526433042a9SShyam Prasad N struct TCP_Server_Info *server;
552738c8a9a5SSteve French int flags = 0;
5528433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5529433042a9SShyam Prasad N
5530433042a9SShyam Prasad N replay_again:
5531433042a9SShyam Prasad N /* reinitialize for possible replay */
5532433042a9SShyam Prasad N flags = 0;
5533433042a9SShyam Prasad N server = cifs_pick_channel(ses);
553438c8a9a5SSteve French
553538c8a9a5SSteve French if (!ses || !server)
553638c8a9a5SSteve French return -EIO;
553738c8a9a5SSteve French
553838c8a9a5SSteve French if (!num)
553938c8a9a5SSteve French return -EINVAL;
554038c8a9a5SSteve French
554138c8a9a5SSteve French if (smb3_encryption_required(tcon))
554238c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
554338c8a9a5SSteve French
554438c8a9a5SSteve French iov = kmalloc_array(num, sizeof(struct kvec), GFP_KERNEL);
554538c8a9a5SSteve French if (!iov)
554638c8a9a5SSteve French return -ENOMEM;
554738c8a9a5SSteve French
554838c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
554938c8a9a5SSteve French rqst.rq_iov = iov;
555038c8a9a5SSteve French rqst.rq_nvec = num;
555138c8a9a5SSteve French
555238c8a9a5SSteve French rc = SMB2_set_info_init(tcon, server,
555338c8a9a5SSteve French &rqst, persistent_fid, volatile_fid, pid,
555438c8a9a5SSteve French info_class, info_type, additional_info,
555538c8a9a5SSteve French data, size);
555638c8a9a5SSteve French if (rc) {
555738c8a9a5SSteve French kfree(iov);
555838c8a9a5SSteve French return rc;
555938c8a9a5SSteve French }
556038c8a9a5SSteve French
5561433042a9SShyam Prasad N if (retries)
5562433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
556338c8a9a5SSteve French
556438c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
556538c8a9a5SSteve French &rqst, &resp_buftype, flags,
556638c8a9a5SSteve French &rsp_iov);
556738c8a9a5SSteve French SMB2_set_info_free(&rqst);
556838c8a9a5SSteve French rsp = (struct smb2_set_info_rsp *)rsp_iov.iov_base;
556938c8a9a5SSteve French
557038c8a9a5SSteve French if (rc != 0) {
557138c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_SET_INFO_HE);
557238c8a9a5SSteve French trace_smb3_set_info_err(xid, persistent_fid, tcon->tid,
557338c8a9a5SSteve French ses->Suid, info_class, (__u32)info_type, rc);
557438c8a9a5SSteve French }
557538c8a9a5SSteve French
557638c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp);
557738c8a9a5SSteve French kfree(iov);
5578433042a9SShyam Prasad N
5579433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5580433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5581433042a9SShyam Prasad N goto replay_again;
5582433042a9SShyam Prasad N
558338c8a9a5SSteve French return rc;
558438c8a9a5SSteve French }
558538c8a9a5SSteve French
558638c8a9a5SSteve French int
SMB2_set_eof(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,u32 pid,loff_t new_eof)558738c8a9a5SSteve French SMB2_set_eof(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid,
5588774c6452SDavid Howells u64 volatile_fid, u32 pid, loff_t new_eof)
558938c8a9a5SSteve French {
559038c8a9a5SSteve French struct smb2_file_eof_info info;
559138c8a9a5SSteve French void *data;
559238c8a9a5SSteve French unsigned int size;
559338c8a9a5SSteve French
5594774c6452SDavid Howells info.EndOfFile = cpu_to_le64(new_eof);
559538c8a9a5SSteve French
559638c8a9a5SSteve French data = &info;
559738c8a9a5SSteve French size = sizeof(struct smb2_file_eof_info);
559838c8a9a5SSteve French
5599774c6452SDavid Howells trace_smb3_set_eof(xid, persistent_fid, tcon->tid, tcon->ses->Suid, new_eof);
560038c8a9a5SSteve French
560138c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid,
560238c8a9a5SSteve French pid, FILE_END_OF_FILE_INFORMATION, SMB2_O_INFO_FILE,
560338c8a9a5SSteve French 0, 1, &data, &size);
560438c8a9a5SSteve French }
560538c8a9a5SSteve French
560638c8a9a5SSteve French int
SMB2_set_acl(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct cifs_ntsd * pnntsd,int pacllen,int aclflag)560738c8a9a5SSteve French SMB2_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
560838c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid,
560938c8a9a5SSteve French struct cifs_ntsd *pnntsd, int pacllen, int aclflag)
561038c8a9a5SSteve French {
561138c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid,
561238c8a9a5SSteve French current->tgid, 0, SMB2_O_INFO_SECURITY, aclflag,
561338c8a9a5SSteve French 1, (void **)&pnntsd, &pacllen);
561438c8a9a5SSteve French }
561538c8a9a5SSteve French
561638c8a9a5SSteve French int
SMB2_set_ea(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct smb2_file_full_ea_info * buf,int len)561738c8a9a5SSteve French SMB2_set_ea(const unsigned int xid, struct cifs_tcon *tcon,
561838c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid,
561938c8a9a5SSteve French struct smb2_file_full_ea_info *buf, int len)
562038c8a9a5SSteve French {
562138c8a9a5SSteve French return send_set_info(xid, tcon, persistent_fid, volatile_fid,
562238c8a9a5SSteve French current->tgid, FILE_FULL_EA_INFORMATION, SMB2_O_INFO_FILE,
562338c8a9a5SSteve French 0, 1, (void **)&buf, &len);
562438c8a9a5SSteve French }
562538c8a9a5SSteve French
562638c8a9a5SSteve French int
SMB2_oplock_break(const unsigned int xid,struct cifs_tcon * tcon,const u64 persistent_fid,const u64 volatile_fid,__u8 oplock_level)562738c8a9a5SSteve French SMB2_oplock_break(const unsigned int xid, struct cifs_tcon *tcon,
562838c8a9a5SSteve French const u64 persistent_fid, const u64 volatile_fid,
562938c8a9a5SSteve French __u8 oplock_level)
563038c8a9a5SSteve French {
563138c8a9a5SSteve French struct smb_rqst rqst;
563238c8a9a5SSteve French int rc;
563338c8a9a5SSteve French struct smb2_oplock_break *req = NULL;
563438c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5635433042a9SShyam Prasad N struct TCP_Server_Info *server;
563638c8a9a5SSteve French int flags = CIFS_OBREAK_OP;
563738c8a9a5SSteve French unsigned int total_len;
563838c8a9a5SSteve French struct kvec iov[1];
563938c8a9a5SSteve French struct kvec rsp_iov;
564038c8a9a5SSteve French int resp_buf_type;
5641433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5642433042a9SShyam Prasad N
5643433042a9SShyam Prasad N replay_again:
5644433042a9SShyam Prasad N /* reinitialize for possible replay */
5645433042a9SShyam Prasad N flags = CIFS_OBREAK_OP;
5646433042a9SShyam Prasad N server = cifs_pick_channel(ses);
564738c8a9a5SSteve French
564838c8a9a5SSteve French cifs_dbg(FYI, "SMB2_oplock_break\n");
564938c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
565038c8a9a5SSteve French (void **) &req, &total_len);
565138c8a9a5SSteve French if (rc)
565238c8a9a5SSteve French return rc;
565338c8a9a5SSteve French
565438c8a9a5SSteve French if (smb3_encryption_required(tcon))
565538c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
565638c8a9a5SSteve French
565738c8a9a5SSteve French req->VolatileFid = volatile_fid;
565838c8a9a5SSteve French req->PersistentFid = persistent_fid;
565938c8a9a5SSteve French req->OplockLevel = oplock_level;
566038c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1);
566138c8a9a5SSteve French
566238c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF;
566338c8a9a5SSteve French
566438c8a9a5SSteve French iov[0].iov_base = (char *)req;
566538c8a9a5SSteve French iov[0].iov_len = total_len;
566638c8a9a5SSteve French
566738c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
566838c8a9a5SSteve French rqst.rq_iov = iov;
566938c8a9a5SSteve French rqst.rq_nvec = 1;
567038c8a9a5SSteve French
5671433042a9SShyam Prasad N if (retries)
5672433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5673433042a9SShyam Prasad N
567438c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
567538c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov);
567638c8a9a5SSteve French cifs_small_buf_release(req);
567738c8a9a5SSteve French if (rc) {
567838c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE);
567938c8a9a5SSteve French cifs_dbg(FYI, "Send error in Oplock Break = %d\n", rc);
568038c8a9a5SSteve French }
568138c8a9a5SSteve French
5682433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5683433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5684433042a9SShyam Prasad N goto replay_again;
5685433042a9SShyam Prasad N
568638c8a9a5SSteve French return rc;
568738c8a9a5SSteve French }
568838c8a9a5SSteve French
568938c8a9a5SSteve French void
smb2_copy_fs_info_to_kstatfs(struct smb2_fs_full_size_info * pfs_inf,struct kstatfs * kst)569038c8a9a5SSteve French smb2_copy_fs_info_to_kstatfs(struct smb2_fs_full_size_info *pfs_inf,
569138c8a9a5SSteve French struct kstatfs *kst)
569238c8a9a5SSteve French {
569338c8a9a5SSteve French kst->f_bsize = le32_to_cpu(pfs_inf->BytesPerSector) *
569438c8a9a5SSteve French le32_to_cpu(pfs_inf->SectorsPerAllocationUnit);
569538c8a9a5SSteve French kst->f_blocks = le64_to_cpu(pfs_inf->TotalAllocationUnits);
569638c8a9a5SSteve French kst->f_bfree = kst->f_bavail =
569738c8a9a5SSteve French le64_to_cpu(pfs_inf->CallerAvailableAllocationUnits);
569838c8a9a5SSteve French return;
569938c8a9a5SSteve French }
570038c8a9a5SSteve French
570138c8a9a5SSteve French static void
copy_posix_fs_info_to_kstatfs(FILE_SYSTEM_POSIX_INFO * response_data,struct kstatfs * kst)570238c8a9a5SSteve French copy_posix_fs_info_to_kstatfs(FILE_SYSTEM_POSIX_INFO *response_data,
570338c8a9a5SSteve French struct kstatfs *kst)
570438c8a9a5SSteve French {
570538c8a9a5SSteve French kst->f_bsize = le32_to_cpu(response_data->BlockSize);
570638c8a9a5SSteve French kst->f_blocks = le64_to_cpu(response_data->TotalBlocks);
570738c8a9a5SSteve French kst->f_bfree = le64_to_cpu(response_data->BlocksAvail);
570838c8a9a5SSteve French if (response_data->UserBlocksAvail == cpu_to_le64(-1))
570938c8a9a5SSteve French kst->f_bavail = kst->f_bfree;
571038c8a9a5SSteve French else
571138c8a9a5SSteve French kst->f_bavail = le64_to_cpu(response_data->UserBlocksAvail);
571238c8a9a5SSteve French if (response_data->TotalFileNodes != cpu_to_le64(-1))
571338c8a9a5SSteve French kst->f_files = le64_to_cpu(response_data->TotalFileNodes);
571438c8a9a5SSteve French if (response_data->FreeFileNodes != cpu_to_le64(-1))
571538c8a9a5SSteve French kst->f_ffree = le64_to_cpu(response_data->FreeFileNodes);
571638c8a9a5SSteve French
571738c8a9a5SSteve French return;
571838c8a9a5SSteve French }
571938c8a9a5SSteve French
572038c8a9a5SSteve French static int
build_qfs_info_req(struct kvec * iov,struct cifs_tcon * tcon,struct TCP_Server_Info * server,int level,int outbuf_len,u64 persistent_fid,u64 volatile_fid)572138c8a9a5SSteve French build_qfs_info_req(struct kvec *iov, struct cifs_tcon *tcon,
572238c8a9a5SSteve French struct TCP_Server_Info *server,
572338c8a9a5SSteve French int level, int outbuf_len, u64 persistent_fid,
572438c8a9a5SSteve French u64 volatile_fid)
572538c8a9a5SSteve French {
572638c8a9a5SSteve French int rc;
572738c8a9a5SSteve French struct smb2_query_info_req *req;
572838c8a9a5SSteve French unsigned int total_len;
572938c8a9a5SSteve French
573038c8a9a5SSteve French cifs_dbg(FYI, "Query FSInfo level %d\n", level);
573138c8a9a5SSteve French
573238c8a9a5SSteve French if ((tcon->ses == NULL) || server == NULL)
573338c8a9a5SSteve French return -EIO;
573438c8a9a5SSteve French
573538c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
573638c8a9a5SSteve French (void **) &req, &total_len);
573738c8a9a5SSteve French if (rc)
573838c8a9a5SSteve French return rc;
573938c8a9a5SSteve French
574038c8a9a5SSteve French req->InfoType = SMB2_O_INFO_FILESYSTEM;
574138c8a9a5SSteve French req->FileInfoClass = level;
574238c8a9a5SSteve French req->PersistentFileId = persistent_fid;
574338c8a9a5SSteve French req->VolatileFileId = volatile_fid;
574438c8a9a5SSteve French /* 1 for pad */
574538c8a9a5SSteve French req->InputBufferOffset =
574638c8a9a5SSteve French cpu_to_le16(sizeof(struct smb2_query_info_req));
574738c8a9a5SSteve French req->OutputBufferLength = cpu_to_le32(
574838c8a9a5SSteve French outbuf_len + sizeof(struct smb2_query_info_rsp));
574938c8a9a5SSteve French
575038c8a9a5SSteve French iov->iov_base = (char *)req;
575138c8a9a5SSteve French iov->iov_len = total_len;
575238c8a9a5SSteve French return 0;
575338c8a9a5SSteve French }
575438c8a9a5SSteve French
free_qfs_info_req(struct kvec * iov)57553b5f0d0aSPaulo Alcantara static inline void free_qfs_info_req(struct kvec *iov)
57563b5f0d0aSPaulo Alcantara {
57573b5f0d0aSPaulo Alcantara cifs_buf_release(iov->iov_base);
57583b5f0d0aSPaulo Alcantara }
57593b5f0d0aSPaulo Alcantara
576038c8a9a5SSteve French int
SMB311_posix_qfs_info(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct kstatfs * fsdata)576138c8a9a5SSteve French SMB311_posix_qfs_info(const unsigned int xid, struct cifs_tcon *tcon,
576238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata)
576338c8a9a5SSteve French {
576438c8a9a5SSteve French struct smb_rqst rqst;
576538c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL;
576638c8a9a5SSteve French struct kvec iov;
576738c8a9a5SSteve French struct kvec rsp_iov;
576838c8a9a5SSteve French int rc = 0;
576938c8a9a5SSteve French int resp_buftype;
577038c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5771433042a9SShyam Prasad N struct TCP_Server_Info *server;
577238c8a9a5SSteve French FILE_SYSTEM_POSIX_INFO *info = NULL;
577338c8a9a5SSteve French int flags = 0;
5774433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5775433042a9SShyam Prasad N
5776433042a9SShyam Prasad N replay_again:
5777433042a9SShyam Prasad N /* reinitialize for possible replay */
5778433042a9SShyam Prasad N flags = 0;
5779433042a9SShyam Prasad N server = cifs_pick_channel(ses);
578038c8a9a5SSteve French
578138c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server,
578238c8a9a5SSteve French FS_POSIX_INFORMATION,
578338c8a9a5SSteve French sizeof(FILE_SYSTEM_POSIX_INFO),
578438c8a9a5SSteve French persistent_fid, volatile_fid);
578538c8a9a5SSteve French if (rc)
578638c8a9a5SSteve French return rc;
578738c8a9a5SSteve French
578838c8a9a5SSteve French if (smb3_encryption_required(tcon))
578938c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
579038c8a9a5SSteve French
579138c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
579238c8a9a5SSteve French rqst.rq_iov = &iov;
579338c8a9a5SSteve French rqst.rq_nvec = 1;
579438c8a9a5SSteve French
5795433042a9SShyam Prasad N if (retries)
5796433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5797433042a9SShyam Prasad N
579838c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
579938c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
58003b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov);
580138c8a9a5SSteve French if (rc) {
580238c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
580338c8a9a5SSteve French goto posix_qfsinf_exit;
580438c8a9a5SSteve French }
580538c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
580638c8a9a5SSteve French
580738c8a9a5SSteve French info = (FILE_SYSTEM_POSIX_INFO *)(
580838c8a9a5SSteve French le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp);
580938c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
581038c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), &rsp_iov,
581138c8a9a5SSteve French sizeof(FILE_SYSTEM_POSIX_INFO));
581238c8a9a5SSteve French if (!rc)
581338c8a9a5SSteve French copy_posix_fs_info_to_kstatfs(info, fsdata);
581438c8a9a5SSteve French
581538c8a9a5SSteve French posix_qfsinf_exit:
581638c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
5817433042a9SShyam Prasad N
5818433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5819433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5820433042a9SShyam Prasad N goto replay_again;
5821433042a9SShyam Prasad N
582238c8a9a5SSteve French return rc;
582338c8a9a5SSteve French }
582438c8a9a5SSteve French
582538c8a9a5SSteve French int
SMB2_QFS_info(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,struct kstatfs * fsdata)582638c8a9a5SSteve French SMB2_QFS_info(const unsigned int xid, struct cifs_tcon *tcon,
582738c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, struct kstatfs *fsdata)
582838c8a9a5SSteve French {
582938c8a9a5SSteve French struct smb_rqst rqst;
583038c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL;
583138c8a9a5SSteve French struct kvec iov;
583238c8a9a5SSteve French struct kvec rsp_iov;
583338c8a9a5SSteve French int rc = 0;
583438c8a9a5SSteve French int resp_buftype;
583538c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5836433042a9SShyam Prasad N struct TCP_Server_Info *server;
583738c8a9a5SSteve French struct smb2_fs_full_size_info *info = NULL;
583838c8a9a5SSteve French int flags = 0;
5839433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5840433042a9SShyam Prasad N
5841433042a9SShyam Prasad N replay_again:
5842433042a9SShyam Prasad N /* reinitialize for possible replay */
5843433042a9SShyam Prasad N flags = 0;
5844433042a9SShyam Prasad N server = cifs_pick_channel(ses);
584538c8a9a5SSteve French
584638c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server,
584738c8a9a5SSteve French FS_FULL_SIZE_INFORMATION,
584838c8a9a5SSteve French sizeof(struct smb2_fs_full_size_info),
584938c8a9a5SSteve French persistent_fid, volatile_fid);
585038c8a9a5SSteve French if (rc)
585138c8a9a5SSteve French return rc;
585238c8a9a5SSteve French
585338c8a9a5SSteve French if (smb3_encryption_required(tcon))
585438c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
585538c8a9a5SSteve French
585638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
585738c8a9a5SSteve French rqst.rq_iov = &iov;
585838c8a9a5SSteve French rqst.rq_nvec = 1;
585938c8a9a5SSteve French
5860433042a9SShyam Prasad N if (retries)
5861433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5862433042a9SShyam Prasad N
586338c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
586438c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
58653b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov);
586638c8a9a5SSteve French if (rc) {
586738c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
586838c8a9a5SSteve French goto qfsinf_exit;
586938c8a9a5SSteve French }
587038c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
587138c8a9a5SSteve French
587238c8a9a5SSteve French info = (struct smb2_fs_full_size_info *)(
587338c8a9a5SSteve French le16_to_cpu(rsp->OutputBufferOffset) + (char *)rsp);
587438c8a9a5SSteve French rc = smb2_validate_iov(le16_to_cpu(rsp->OutputBufferOffset),
587538c8a9a5SSteve French le32_to_cpu(rsp->OutputBufferLength), &rsp_iov,
587638c8a9a5SSteve French sizeof(struct smb2_fs_full_size_info));
587738c8a9a5SSteve French if (!rc)
587838c8a9a5SSteve French smb2_copy_fs_info_to_kstatfs(info, fsdata);
587938c8a9a5SSteve French
588038c8a9a5SSteve French qfsinf_exit:
588138c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
5882433042a9SShyam Prasad N
5883433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5884433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5885433042a9SShyam Prasad N goto replay_again;
5886433042a9SShyam Prasad N
588738c8a9a5SSteve French return rc;
588838c8a9a5SSteve French }
588938c8a9a5SSteve French
589038c8a9a5SSteve French int
SMB2_QFS_attr(const unsigned int xid,struct cifs_tcon * tcon,u64 persistent_fid,u64 volatile_fid,int level)589138c8a9a5SSteve French SMB2_QFS_attr(const unsigned int xid, struct cifs_tcon *tcon,
589238c8a9a5SSteve French u64 persistent_fid, u64 volatile_fid, int level)
589338c8a9a5SSteve French {
589438c8a9a5SSteve French struct smb_rqst rqst;
589538c8a9a5SSteve French struct smb2_query_info_rsp *rsp = NULL;
589638c8a9a5SSteve French struct kvec iov;
589738c8a9a5SSteve French struct kvec rsp_iov;
589838c8a9a5SSteve French int rc = 0;
589938c8a9a5SSteve French int resp_buftype, max_len, min_len;
590038c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
5901433042a9SShyam Prasad N struct TCP_Server_Info *server;
590238c8a9a5SSteve French unsigned int rsp_len, offset;
590338c8a9a5SSteve French int flags = 0;
5904433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
5905433042a9SShyam Prasad N
5906433042a9SShyam Prasad N replay_again:
5907433042a9SShyam Prasad N /* reinitialize for possible replay */
5908433042a9SShyam Prasad N flags = 0;
5909433042a9SShyam Prasad N server = cifs_pick_channel(ses);
591038c8a9a5SSteve French
591138c8a9a5SSteve French if (level == FS_DEVICE_INFORMATION) {
591238c8a9a5SSteve French max_len = sizeof(FILE_SYSTEM_DEVICE_INFO);
591338c8a9a5SSteve French min_len = sizeof(FILE_SYSTEM_DEVICE_INFO);
591438c8a9a5SSteve French } else if (level == FS_ATTRIBUTE_INFORMATION) {
591538c8a9a5SSteve French max_len = sizeof(FILE_SYSTEM_ATTRIBUTE_INFO);
591638c8a9a5SSteve French min_len = MIN_FS_ATTR_INFO_SIZE;
591738c8a9a5SSteve French } else if (level == FS_SECTOR_SIZE_INFORMATION) {
591838c8a9a5SSteve French max_len = sizeof(struct smb3_fs_ss_info);
591938c8a9a5SSteve French min_len = sizeof(struct smb3_fs_ss_info);
592038c8a9a5SSteve French } else if (level == FS_VOLUME_INFORMATION) {
592138c8a9a5SSteve French max_len = sizeof(struct smb3_fs_vol_info) + MAX_VOL_LABEL_LEN;
592238c8a9a5SSteve French min_len = sizeof(struct smb3_fs_vol_info);
592338c8a9a5SSteve French } else {
592438c8a9a5SSteve French cifs_dbg(FYI, "Invalid qfsinfo level %d\n", level);
592538c8a9a5SSteve French return -EINVAL;
592638c8a9a5SSteve French }
592738c8a9a5SSteve French
592838c8a9a5SSteve French rc = build_qfs_info_req(&iov, tcon, server,
592938c8a9a5SSteve French level, max_len,
593038c8a9a5SSteve French persistent_fid, volatile_fid);
593138c8a9a5SSteve French if (rc)
593238c8a9a5SSteve French return rc;
593338c8a9a5SSteve French
593438c8a9a5SSteve French if (smb3_encryption_required(tcon))
593538c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
593638c8a9a5SSteve French
593738c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
593838c8a9a5SSteve French rqst.rq_iov = &iov;
593938c8a9a5SSteve French rqst.rq_nvec = 1;
594038c8a9a5SSteve French
5941433042a9SShyam Prasad N if (retries)
5942433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
5943433042a9SShyam Prasad N
594438c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
594538c8a9a5SSteve French &rqst, &resp_buftype, flags, &rsp_iov);
59463b5f0d0aSPaulo Alcantara free_qfs_info_req(&iov);
594738c8a9a5SSteve French if (rc) {
594838c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_QUERY_INFO_HE);
594938c8a9a5SSteve French goto qfsattr_exit;
595038c8a9a5SSteve French }
595138c8a9a5SSteve French rsp = (struct smb2_query_info_rsp *)rsp_iov.iov_base;
595238c8a9a5SSteve French
595338c8a9a5SSteve French rsp_len = le32_to_cpu(rsp->OutputBufferLength);
595438c8a9a5SSteve French offset = le16_to_cpu(rsp->OutputBufferOffset);
595538c8a9a5SSteve French rc = smb2_validate_iov(offset, rsp_len, &rsp_iov, min_len);
595638c8a9a5SSteve French if (rc)
595738c8a9a5SSteve French goto qfsattr_exit;
595838c8a9a5SSteve French
595938c8a9a5SSteve French if (level == FS_ATTRIBUTE_INFORMATION)
596038c8a9a5SSteve French memcpy(&tcon->fsAttrInfo, offset
596138c8a9a5SSteve French + (char *)rsp, min_t(unsigned int,
596238c8a9a5SSteve French rsp_len, max_len));
596338c8a9a5SSteve French else if (level == FS_DEVICE_INFORMATION)
596438c8a9a5SSteve French memcpy(&tcon->fsDevInfo, offset
596538c8a9a5SSteve French + (char *)rsp, sizeof(FILE_SYSTEM_DEVICE_INFO));
596638c8a9a5SSteve French else if (level == FS_SECTOR_SIZE_INFORMATION) {
596738c8a9a5SSteve French struct smb3_fs_ss_info *ss_info = (struct smb3_fs_ss_info *)
596838c8a9a5SSteve French (offset + (char *)rsp);
596938c8a9a5SSteve French tcon->ss_flags = le32_to_cpu(ss_info->Flags);
597038c8a9a5SSteve French tcon->perf_sector_size =
597138c8a9a5SSteve French le32_to_cpu(ss_info->PhysicalBytesPerSectorForPerf);
597238c8a9a5SSteve French } else if (level == FS_VOLUME_INFORMATION) {
597338c8a9a5SSteve French struct smb3_fs_vol_info *vol_info = (struct smb3_fs_vol_info *)
597438c8a9a5SSteve French (offset + (char *)rsp);
597538c8a9a5SSteve French tcon->vol_serial_number = vol_info->VolumeSerialNumber;
597638c8a9a5SSteve French tcon->vol_create_time = vol_info->VolumeCreationTime;
597738c8a9a5SSteve French }
597838c8a9a5SSteve French
597938c8a9a5SSteve French qfsattr_exit:
598038c8a9a5SSteve French free_rsp_buf(resp_buftype, rsp_iov.iov_base);
5981433042a9SShyam Prasad N
5982433042a9SShyam Prasad N if (is_replayable_error(rc) &&
5983433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
5984433042a9SShyam Prasad N goto replay_again;
5985433042a9SShyam Prasad N
598638c8a9a5SSteve French return rc;
598738c8a9a5SSteve French }
598838c8a9a5SSteve French
598938c8a9a5SSteve French int
smb2_lockv(const unsigned int xid,struct cifs_tcon * tcon,const __u64 persist_fid,const __u64 volatile_fid,const __u32 pid,const __u32 num_lock,struct smb2_lock_element * buf)599038c8a9a5SSteve French smb2_lockv(const unsigned int xid, struct cifs_tcon *tcon,
599138c8a9a5SSteve French const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid,
599238c8a9a5SSteve French const __u32 num_lock, struct smb2_lock_element *buf)
599338c8a9a5SSteve French {
599438c8a9a5SSteve French struct smb_rqst rqst;
599538c8a9a5SSteve French int rc = 0;
599638c8a9a5SSteve French struct smb2_lock_req *req = NULL;
599738c8a9a5SSteve French struct kvec iov[2];
599838c8a9a5SSteve French struct kvec rsp_iov;
599938c8a9a5SSteve French int resp_buf_type;
600038c8a9a5SSteve French unsigned int count;
600138c8a9a5SSteve French int flags = CIFS_NO_RSP_BUF;
600238c8a9a5SSteve French unsigned int total_len;
6003433042a9SShyam Prasad N struct TCP_Server_Info *server;
6004433042a9SShyam Prasad N int retries = 0, cur_sleep = 1;
6005433042a9SShyam Prasad N
6006433042a9SShyam Prasad N replay_again:
6007433042a9SShyam Prasad N /* reinitialize for possible replay */
6008433042a9SShyam Prasad N flags = CIFS_NO_RSP_BUF;
6009433042a9SShyam Prasad N server = cifs_pick_channel(tcon->ses);
601038c8a9a5SSteve French
601138c8a9a5SSteve French cifs_dbg(FYI, "smb2_lockv num lock %d\n", num_lock);
601238c8a9a5SSteve French
601338c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
601438c8a9a5SSteve French (void **) &req, &total_len);
601538c8a9a5SSteve French if (rc)
601638c8a9a5SSteve French return rc;
601738c8a9a5SSteve French
601838c8a9a5SSteve French if (smb3_encryption_required(tcon))
601938c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
602038c8a9a5SSteve French
602138c8a9a5SSteve French req->hdr.Id.SyncId.ProcessId = cpu_to_le32(pid);
602238c8a9a5SSteve French req->LockCount = cpu_to_le16(num_lock);
602338c8a9a5SSteve French
602438c8a9a5SSteve French req->PersistentFileId = persist_fid;
602538c8a9a5SSteve French req->VolatileFileId = volatile_fid;
602638c8a9a5SSteve French
602738c8a9a5SSteve French count = num_lock * sizeof(struct smb2_lock_element);
602838c8a9a5SSteve French
602938c8a9a5SSteve French iov[0].iov_base = (char *)req;
603038c8a9a5SSteve French iov[0].iov_len = total_len - sizeof(struct smb2_lock_element);
603138c8a9a5SSteve French iov[1].iov_base = (char *)buf;
603238c8a9a5SSteve French iov[1].iov_len = count;
603338c8a9a5SSteve French
603438c8a9a5SSteve French cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
603538c8a9a5SSteve French
603638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
603738c8a9a5SSteve French rqst.rq_iov = iov;
603838c8a9a5SSteve French rqst.rq_nvec = 2;
603938c8a9a5SSteve French
6040433042a9SShyam Prasad N if (retries)
6041433042a9SShyam Prasad N smb2_set_replay(server, &rqst);
6042433042a9SShyam Prasad N
604338c8a9a5SSteve French rc = cifs_send_recv(xid, tcon->ses, server,
604438c8a9a5SSteve French &rqst, &resp_buf_type, flags,
604538c8a9a5SSteve French &rsp_iov);
604638c8a9a5SSteve French cifs_small_buf_release(req);
604738c8a9a5SSteve French if (rc) {
604838c8a9a5SSteve French cifs_dbg(FYI, "Send error in smb2_lockv = %d\n", rc);
604938c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_LOCK_HE);
605038c8a9a5SSteve French trace_smb3_lock_err(xid, persist_fid, tcon->tid,
605138c8a9a5SSteve French tcon->ses->Suid, rc);
605238c8a9a5SSteve French }
605338c8a9a5SSteve French
6054433042a9SShyam Prasad N if (is_replayable_error(rc) &&
6055433042a9SShyam Prasad N smb2_should_replay(tcon, &retries, &cur_sleep))
6056433042a9SShyam Prasad N goto replay_again;
6057433042a9SShyam Prasad N
605838c8a9a5SSteve French return rc;
605938c8a9a5SSteve French }
606038c8a9a5SSteve French
606138c8a9a5SSteve French int
SMB2_lock(const unsigned int xid,struct cifs_tcon * tcon,const __u64 persist_fid,const __u64 volatile_fid,const __u32 pid,const __u64 length,const __u64 offset,const __u32 lock_flags,const bool wait)606238c8a9a5SSteve French SMB2_lock(const unsigned int xid, struct cifs_tcon *tcon,
606338c8a9a5SSteve French const __u64 persist_fid, const __u64 volatile_fid, const __u32 pid,
606438c8a9a5SSteve French const __u64 length, const __u64 offset, const __u32 lock_flags,
606538c8a9a5SSteve French const bool wait)
606638c8a9a5SSteve French {
606738c8a9a5SSteve French struct smb2_lock_element lock;
606838c8a9a5SSteve French
606938c8a9a5SSteve French lock.Offset = cpu_to_le64(offset);
607038c8a9a5SSteve French lock.Length = cpu_to_le64(length);
607138c8a9a5SSteve French lock.Flags = cpu_to_le32(lock_flags);
607238c8a9a5SSteve French if (!wait && lock_flags != SMB2_LOCKFLAG_UNLOCK)
607338c8a9a5SSteve French lock.Flags |= cpu_to_le32(SMB2_LOCKFLAG_FAIL_IMMEDIATELY);
607438c8a9a5SSteve French
607538c8a9a5SSteve French return smb2_lockv(xid, tcon, persist_fid, volatile_fid, pid, 1, &lock);
607638c8a9a5SSteve French }
607738c8a9a5SSteve French
607838c8a9a5SSteve French int
SMB2_lease_break(const unsigned int xid,struct cifs_tcon * tcon,__u8 * lease_key,const __le32 lease_state)607938c8a9a5SSteve French SMB2_lease_break(const unsigned int xid, struct cifs_tcon *tcon,
608038c8a9a5SSteve French __u8 *lease_key, const __le32 lease_state)
608138c8a9a5SSteve French {
608238c8a9a5SSteve French struct smb_rqst rqst;
608338c8a9a5SSteve French int rc;
608438c8a9a5SSteve French struct smb2_lease_ack *req = NULL;
608538c8a9a5SSteve French struct cifs_ses *ses = tcon->ses;
608638c8a9a5SSteve French int flags = CIFS_OBREAK_OP;
608738c8a9a5SSteve French unsigned int total_len;
608838c8a9a5SSteve French struct kvec iov[1];
608938c8a9a5SSteve French struct kvec rsp_iov;
609038c8a9a5SSteve French int resp_buf_type;
609138c8a9a5SSteve French __u64 *please_key_high;
609238c8a9a5SSteve French __u64 *please_key_low;
609338c8a9a5SSteve French struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
609438c8a9a5SSteve French
609538c8a9a5SSteve French cifs_dbg(FYI, "SMB2_lease_break\n");
609638c8a9a5SSteve French rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
609738c8a9a5SSteve French (void **) &req, &total_len);
609838c8a9a5SSteve French if (rc)
609938c8a9a5SSteve French return rc;
610038c8a9a5SSteve French
610138c8a9a5SSteve French if (smb3_encryption_required(tcon))
610238c8a9a5SSteve French flags |= CIFS_TRANSFORM_REQ;
610338c8a9a5SSteve French
610438c8a9a5SSteve French req->hdr.CreditRequest = cpu_to_le16(1);
610538c8a9a5SSteve French req->StructureSize = cpu_to_le16(36);
610638c8a9a5SSteve French total_len += 12;
610738c8a9a5SSteve French
610838c8a9a5SSteve French memcpy(req->LeaseKey, lease_key, 16);
610938c8a9a5SSteve French req->LeaseState = lease_state;
611038c8a9a5SSteve French
611138c8a9a5SSteve French flags |= CIFS_NO_RSP_BUF;
611238c8a9a5SSteve French
611338c8a9a5SSteve French iov[0].iov_base = (char *)req;
611438c8a9a5SSteve French iov[0].iov_len = total_len;
611538c8a9a5SSteve French
611638c8a9a5SSteve French memset(&rqst, 0, sizeof(struct smb_rqst));
611738c8a9a5SSteve French rqst.rq_iov = iov;
611838c8a9a5SSteve French rqst.rq_nvec = 1;
611938c8a9a5SSteve French
612038c8a9a5SSteve French rc = cifs_send_recv(xid, ses, server,
612138c8a9a5SSteve French &rqst, &resp_buf_type, flags, &rsp_iov);
612238c8a9a5SSteve French cifs_small_buf_release(req);
612338c8a9a5SSteve French
612438c8a9a5SSteve French please_key_low = (__u64 *)lease_key;
612538c8a9a5SSteve French please_key_high = (__u64 *)(lease_key+8);
612638c8a9a5SSteve French if (rc) {
612738c8a9a5SSteve French cifs_stats_fail_inc(tcon, SMB2_OPLOCK_BREAK_HE);
612838c8a9a5SSteve French trace_smb3_lease_err(le32_to_cpu(lease_state), tcon->tid,
612938c8a9a5SSteve French ses->Suid, *please_key_low, *please_key_high, rc);
613038c8a9a5SSteve French cifs_dbg(FYI, "Send error in Lease Break = %d\n", rc);
613138c8a9a5SSteve French } else
613238c8a9a5SSteve French trace_smb3_lease_done(le32_to_cpu(lease_state), tcon->tid,
613338c8a9a5SSteve French ses->Suid, *please_key_low, *please_key_high);
613438c8a9a5SSteve French
613538c8a9a5SSteve French return rc;
613638c8a9a5SSteve French }
6137