Lines Matching defs:server
81 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
84 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
92 struct TCP_Server_Info *server)
100 if (server) {
102 if (server->dialect >= SMB30_PROT_ID) {
108 if (SERVER_IS_CHAN(server))
110 cpu_to_le16(server->primary_server->channel_sequence_num);
113 cpu_to_le16(server->channel_sequence_num);
115 spin_lock(&server->req_lock);
117 if (server->credits >= server->max_credits)
121 min_t(int, server->max_credits -
122 server->credits, 10));
123 spin_unlock(&server->req_lock);
134 if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
145 * to pass the path on the Open SMB prefixed by \\server\share.
148 * illegal to send an empty path name (without \\server\share prefix)
156 if (server && server->sign && !smb3_encryption_required(tcon))
165 struct TCP_Server_Info *server,
171 if (SERVER_IS_CHAN(server)) {
173 "server %s does not support multichannel anymore. Skip secondary channel\n",
174 ses->server->hostname);
177 chan_index = cifs_ses_get_chan_index(ses, server);
183 ses->chans[chan_index].server = NULL;
184 server->terminate = true;
188 * the above reference of server by channel
193 cifs_put_tcp_session(server, from_reconnect);
195 cifs_signal_cifsd_for_reconnect(server, false);
197 /* mark primary server as needing reconnect */
198 pserver = server->primary_server;
205 "server does not support multichannel anymore. Disable all other channels\n");
214 struct TCP_Server_Info *server, bool from_reconnect)
259 if (!ses->server || !server)
262 spin_lock(&server->srv_lock);
263 if (server->tcpStatus == CifsNeedReconnect) {
276 spin_unlock(&server->srv_lock);
281 /* if server is marked for termination, cifsd will cleanup */
282 if (server->terminate) {
283 spin_unlock(&server->srv_lock);
286 spin_unlock(&server->srv_lock);
289 rc = cifs_wait_for_server_reconnect(server, tcon->retry);
294 if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {
309 spin_lock(&server->srv_lock);
310 if (server->tcpStatus == CifsExiting) {
311 spin_unlock(&server->srv_lock);
319 * and the server never sends an answer the socket will be closed
322 if (server->tcpStatus == CifsNeedReconnect) {
323 spin_unlock(&server->srv_lock);
332 spin_unlock(&server->srv_lock);
342 if (!cifs_chan_needs_reconnect(ses, server) &&
356 rc = cifs_negotiate_protocol(0, ses, server);
359 * if server stopped supporting multichannel
363 !(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
364 rc = cifs_chan_skip_or_disable(ses, server,
372 rc = cifs_setup_session(0, ses, server, nls_codepage);
376 * could be enabled on the server e.g.) if an alternate
426 (server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL) &&
427 server->ops->query_server_interfaces) {
431 * query server network interfaces, in case they change
434 rc = server->ops->query_server_interfaces(xid, tcon, false);
439 * some servers like Azure SMB server do not advertise
440 * that multichannel has been disabled with server
442 * treat this as server not supporting multichannel
445 rc = cifs_chan_skip_or_disable(ses, server,
449 cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
454 !SERVER_IS_CHAN(server)) {
473 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
482 * BB Is flush done by server on drop of tcp session? Should we special
502 struct TCP_Server_Info *server,
516 smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server);
528 struct TCP_Server_Info *server,
546 fill_small_buf(smb2_command, tcon, server,
560 struct TCP_Server_Info *server,
565 rc = smb2_reconnect(smb2_command, tcon, server, false);
569 return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,
574 struct TCP_Server_Info *server,
579 return __smb2_plain_req_init(SMB2_IOCTL, tcon, server,
582 return smb2_plain_req_init(SMB2_IOCTL, tcon, server,
663 /* copy up to max of first 100 bytes of server name to NetName field */
695 struct TCP_Server_Info *server, unsigned int *total_len)
731 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
749 if (server->compression.requested) {
781 pr_warn_once("server sent bad preauth context\n");
784 pr_warn_once("server sent invalid SaltLength\n");
793 static void decode_compress_ctx(struct TCP_Server_Info *server,
799 server->compression.enabled = false;
807 pr_warn_once("server sent bad compression cntxt\n");
824 server->compression.alg = alg;
825 server->compression.enabled = true;
828 static int decode_encrypt_ctx(struct TCP_Server_Info *server,
840 pr_warn_once("server sent bad crypto ctxt len\n");
856 * e.g. if server only supported AES256_CCM (very unlikely)
857 * or server supported no encryption types or had all disabled.
861 * seal not requested by client, since server is allowed to
864 server->cipher_type = 0;
865 server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION;
871 /* server returned a cipher we didn't ask for */
875 server->cipher_type = ctxt->Ciphers[0];
876 server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;
880 static void decode_signing_ctx(struct TCP_Server_Info *server,
891 pr_warn_once("server sent bad signing negcontext\n");
903 server->signing_negotiated = true;
904 server->signing_algorithm = le16_to_cpu(pctxt->SigningAlgorithms[0]);
906 server->signing_algorithm);
911 struct TCP_Server_Info *server,
951 rc = decode_encrypt_ctx(server,
954 decode_compress_ctx(server,
957 server->posix_ext_supported = true;
959 decode_signing_ctx(server,
1046 struct TCP_Server_Info *server)
1062 if (!server) {
1063 WARN(1, "%s: server is NULL!\n", __func__);
1067 rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server,
1074 memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE);
1077 if (strcmp(server->vals->version_string,
1084 } else if (strcmp(server->vals->version_string,
1094 req->Dialects[0] = cpu_to_le16(server->vals->protocol_id);
1107 req->Capabilities = cpu_to_le32(server->vals->req_capabilities);
1112 if (server->vals->protocol_id == SMB20_PROT_ID)
1115 memcpy(req->ClientGUID, server->client_guid,
1117 if ((server->vals->protocol_id == SMB311_PROT_ID) ||
1118 (strcmp(server->vals->version_string,
1120 (strcmp(server->vals->version_string,
1122 assemble_neg_contexts(req, server, &total_len);
1131 rc = cifs_send_recv(xid, ses, server,
1140 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");
1146 if (strcmp(server->vals->version_string,
1158 server->ops = &smb311_operations;
1159 server->vals = &smb311_values;
1161 } else if (strcmp(server->vals->version_string,
1169 server->ops = &smb21_operations;
1170 server->vals = &smb21_values;
1172 server->ops = &smb311_operations;
1173 server->vals = &smb311_values;
1176 server->vals->protocol_id) {
1196 cifs_server_dbg(VFS, "Invalid dialect returned by server 0x%x\n",
1202 server->dialect = le16_to_cpu(rsp->DialectRevision);
1207 * server.
1209 memcpy(server->preauth_sha_hash, ses->preauth_sha_hash,
1213 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
1215 server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
1217 server->max_read = le32_to_cpu(rsp->MaxReadSize);
1218 server->max_write = le32_to_cpu(rsp->MaxWriteSize);
1219 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
1220 if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode)
1222 server->sec_mode);
1223 server->capabilities = le32_to_cpu(rsp->Capabilities);
1225 server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;
1231 if ((server->dialect == SMB30_PROT_ID ||
1232 server->dialect == SMB302_PROT_ID) &&
1233 (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
1234 server->cipher_type = SMB2_ENCRYPTION_AES128_CCM;
1243 * We just found a server which sets blob length to zero expecting raw.
1247 server->sec_ntlmssp = true;
1250 rc = cifs_enable_signing(server, ses->sign);
1254 rc = decode_negTokenInit(security_blob, blob_length, server);
1263 rc = smb311_decode_neg_context(rsp, server,
1269 if (server->cipher_type && !rc) {
1270 rc = smb3_crypto_aead_allocate(server);
1286 struct TCP_Server_Info *server = tcon->ses->server;
1291 if (server->dialect == SMB311_PROT_ID)
1310 cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n");
1317 cpu_to_le32(server->vals->req_capabilities);
1321 memcpy(pneg_inbuf->Guid, server->client_guid,
1334 if (strcmp(server->vals->version_string,
1343 } else if (strcmp(server->vals->version_string,
1355 cpu_to_le16(server->vals->protocol_id);
1368 * Old Windows versions or Netapp SMB server can return
1392 if (pneg_rsp->Dialect != cpu_to_le16(server->dialect))
1395 if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode))
1398 /* do not validate server guid because not saved at negprot time yet */
1401 SMB2_LARGE_FILES) != server->capabilities)
1419 smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1428 if (server->sec_ntlmssp &&
1431 if ((server->sec_kerberos || server->sec_mskerberos || server->sec_iakerb) &&
1443 struct TCP_Server_Info *server;
1465 struct TCP_Server_Info *server = sess_data->server;
1470 rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,
1500 if (server->credits >= server->max_credits)
1504 min_t(int, server->max_credits -
1505 server->credits, 130));
1508 if (server->sign)
1567 sess_data->server,
1587 struct TCP_Server_Info *server = sess_data->server;
1589 cifs_server_lock(server);
1590 if (server->ops->generate_signingkey) {
1591 rc = server->ops->generate_signingkey(ses, server);
1595 cifs_server_unlock(server);
1599 if (!server->session_estab) {
1600 server->sequence_number = 0x2;
1601 server->session_estab = true;
1603 cifs_server_unlock(server);
1615 struct TCP_Server_Info *server = sess_data->server;
1625 spnego_key = cifs_get_spnego_key(ses, server);
1710 struct TCP_Server_Info *server = sess_data->server;
1733 &blob_length, ses, server,
1802 struct TCP_Server_Info *server = sess_data->server;
1818 ses, server,
1852 if (ses->server->dialect < SMB30_PROT_ID) {
1880 struct TCP_Server_Info *server = sess_data->server;
1882 type = smb2_select_sectype(server, ses->sectype);
1906 struct TCP_Server_Info *server,
1914 if (!server) {
1915 WARN(1, "%s: server is NULL!\n", __func__);
1925 sess_data->server = server;
1935 * Initialize the session hash with the server one.
1937 memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,
1957 struct TCP_Server_Info *server;
1966 if (ses && (ses->server))
1967 server = ses->server;
1979 rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,
1989 else if (server->sign)
2001 rc = cifs_send_recv(xid, ses, ses->server,
2018 #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
2043 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2047 if (!server || !tree)
2064 rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,
2089 if ((server->dialect == SMB311_PROT_ID) &&
2101 if (server->credits >= server->max_credits)
2105 min_t(int, server->max_credits -
2106 server->credits, 64));
2108 rc = cifs_send_recv(xid, ses, server,
2148 !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
2152 if (server->ops->validate_negotiate)
2153 rc = server->ops->validate_negotiate(xid, tcon);
2156 server->nosharesock = true;
2176 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2185 if (!ses || !(ses->server))
2199 rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, server,
2217 rc = cifs_send_recv(xid, ses, server,
2323 int smb2_parse_contexts(struct TCP_Server_Info *server,
2369 *oplock = server->ops->parse_lease_buf(cc, epoch,
2403 add_lease_context(struct TCP_Server_Info *server,
2410 iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock);
2413 iov[num].iov_len = server->vals->create_lease_size;
2437 * NB: Handle timeout defaults to 0, which allows server to choose
2835 struct TCP_Server_Info *server;
2842 server = cifs_pick_channel(ses);
2851 if (!ses || !server) {
2857 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2948 smb2_set_replay(server, &rqst);
2951 rc = cifs_send_recv(xid, ses, server,
2996 SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3010 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
3071 if ((!server->oplocks) || (tcon->no_lease))
3074 if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
3077 else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&
3081 rc = add_lease_context(server, req, iov, &n_iov,
3188 struct TCP_Server_Info *server;
3199 server = cifs_pick_channel(ses);
3203 if (!ses || !server)
3214 rc = SMB2_open_init(tcon, server,
3223 smb2_set_replay(server, &rqst);
3225 rc = cifs_send_recv(xid, ses, server,
3241 pr_warn_once("server share %s deleted\n",
3273 rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch,
3287 SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3299 rc = smb2_ioctl_req_init(opcode, tcon, server,
3359 * ioctls it may be useful to allow server to send more. No point
3360 * limiting what the server can send as long as fits in one credit
3410 struct TCP_Server_Info *server;
3428 server = cifs_pick_channel(ses);
3430 if (!server)
3450 rc = SMB2_ioctl_init(tcon, server,
3457 smb2_set_replay(server, &rqst);
3459 rc = cifs_send_recv(xid, ses, server,
3502 goto ioctl_exit; /* server returned no data */
3563 SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3572 rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,
3604 struct TCP_Server_Info *server;
3617 server = cifs_pick_channel(ses);
3621 if (!ses || !server)
3632 /* check if need to ask server to return timestamps in close response */
3637 rc = SMB2_close_init(tcon, server,
3644 smb2_set_replay(server, &rqst);
3646 rc = cifs_send_recv(xid, ses, server,
3718 cifs_dbg(VFS, "Invalid server response, bad offset to data\n");
3750 SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3766 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
3811 struct TCP_Server_Info *server;
3825 server = cifs_pick_channel(ses);
3827 if (!server)
3838 rc = SMB2_query_info_init(tcon, server,
3849 smb2_set_replay(server, &rqst);
3851 rc = cifs_send_recv(xid, ses, server,
3960 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3969 rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server,
3998 struct TCP_Server_Info *server;
4011 server = cifs_pick_channel(ses);
4014 if (!ses || !server)
4028 rc = SMB2_notify_init(xid, &rqst, tcon, server,
4038 smb2_set_replay(server, &rqst);
4040 rc = cifs_send_recv(xid, ses, server,
4086 * rather in the fact that the server sent one and that server->lstrp
4094 struct TCP_Server_Info *server = mid->callback_data;
4101 credits.instance = server->reconnect_instance;
4105 add_credits(server, &credits, CIFS_ECHO_OP);
4110 struct TCP_Server_Info *server = container_of(work,
4123 if (!server->srv_count) {
4127 server->srv_count++;
4130 /* If server is a channel, select the primary channel */
4131 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
4136 /* if the server is marked for termination, drop the ref count here */
4137 if (server->terminate) {
4138 cifs_put_tcp_session(server, true);
4182 if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {
4192 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4225 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4236 queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
4240 cifs_put_tcp_session(server, true);
4244 SMB2_echo(struct TCP_Server_Info *server)
4253 cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);
4255 spin_lock(&server->srv_lock);
4256 if (server->ops->need_neg &&
4257 server->ops->need_neg(server)) {
4258 spin_unlock(&server->srv_lock);
4260 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
4263 spin_unlock(&server->srv_lock);
4265 rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
4275 rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
4276 server, CIFS_ECHO_OP, NULL);
4293 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
4301 rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
4323 struct TCP_Server_Info *server;
4332 server = cifs_pick_channel(ses);
4335 if (!ses || !(ses->server))
4346 rc = SMB2_flush_init(xid, &rqst, tcon, server,
4354 smb2_set_replay(server, &rqst);
4356 rc = cifs_send_recv(xid, ses, server,
4381 struct TCP_Server_Info *server = io_parms->server;
4385 if (!server || !tcon)
4389 if (!server->rdma || !server->smbd_conn)
4393 if (server->sign)
4401 if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
4420 struct TCP_Server_Info *server = io_parms->server;
4422 rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
4427 if (server == NULL)
4453 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4455 rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->iter,
4508 struct TCP_Server_Info *server = rdata->server;
4519 WARN_ONCE(rdata->server != mid->server,
4520 "rdata server %p != mid server %p",
4521 rdata->server, mid->server);
4530 credits.instance = server->reconnect_instance;
4532 if (server->sign && !mid->decrypted) {
4537 rc = smb2_verify_signature(&rqst, server);
4549 if (server->sign && rdata->got_bytes)
4558 credits.instance = server->reconnect_instance;
4588 add_credits(server, &credits, 0);
4601 struct TCP_Server_Info *server;
4609 if (!rdata->server)
4610 rdata->server = cifs_pick_channel(tcon->ses);
4613 io_parms.server = server = rdata->server;
4637 if (server->credits >= server->max_credits)
4641 min_t(int, server->max_credits -
4642 server->credits, credit_request));
4644 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4652 rc = cifs_call_async(server, &rqst,
4684 if (!io_parms->server)
4685 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4702 rc = cifs_send_recv(xid, ses, io_parms->server,
4760 struct TCP_Server_Info *server = wdata->server;
4765 WARN_ONCE(wdata->server != mid->server,
4766 "wdata server %p != mid server %p",
4767 wdata->server, mid->server);
4772 credits.instance = server->reconnect_instance;
4773 wdata->result = smb2_check_receive(mid, server, 0);
4780 * by the server is greater than bytes requested by the
4798 credits.instance = server->reconnect_instance;
4834 add_credits(server, &credits, 0);
4846 struct TCP_Server_Info *server = wdata->server;
4854 if (!wdata->server || wdata->replay)
4855 server = wdata->server = cifs_pick_channel(tcon->ses);
4863 .server = server,
4872 rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
4902 * If we want to do a server RDMA read, fill in and append
4908 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4910 wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->iter,
4940 smb2_set_replay(server, &rqst);
4960 if (server->credits >= server->max_credits)
4964 min_t(int, server->max_credits -
4965 server->credits, credit_request));
4967 rc = adjust_credits(server, &wdata->credits, io_parms->length);
4975 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
5013 struct TCP_Server_Info *server;
5020 if (!io_parms->server)
5021 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
5022 server = io_parms->server;
5023 if (server == NULL)
5029 rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
5063 smb2_set_replay(server, &rqst);
5065 rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
5246 struct TCP_Server_Info *server,
5261 rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
5300 output_size = min_t(unsigned int, output_size, server->maxBuf);
5411 struct TCP_Server_Info *server;
5418 server = cifs_pick_channel(ses);
5420 if (!ses || !(ses->server))
5431 rc = SMB2_query_directory_init(xid, tcon, server,
5439 smb2_set_replay(server, &rqst);
5441 rc = cifs_send_recv(xid, ses, server,
5484 SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
5495 rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
5546 struct TCP_Server_Info *server;
5553 server = cifs_pick_channel(ses);
5555 if (!ses || !server)
5572 rc = SMB2_set_info_init(tcon, server,
5582 smb2_set_replay(server, &rqst);
5584 rc = cifs_send_recv(xid, ses, server,
5655 struct TCP_Server_Info *server;
5666 server = cifs_pick_channel(ses);
5669 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5692 smb2_set_replay(server, &rqst);
5694 rc = cifs_send_recv(xid, ses, server,
5742 struct TCP_Server_Info *server,
5752 if ((tcon->ses == NULL) || server == NULL)
5755 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
5791 struct TCP_Server_Info *server;
5799 server = cifs_pick_channel(ses);
5801 rc = build_qfs_info_req(&iov, tcon, server,
5816 smb2_set_replay(server, &rqst);
5818 rc = cifs_send_recv(xid, ses, server,
5856 struct TCP_Server_Info *server;
5864 server = cifs_pick_channel(ses);
5866 rc = build_qfs_info_req(&iov, tcon, server,
5881 smb2_set_replay(server, &rqst);
5883 rc = cifs_send_recv(xid, ses, server,
5921 struct TCP_Server_Info *server;
5929 server = cifs_pick_channel(ses);
5948 rc = build_qfs_info_req(&iov, tcon, server,
5962 smb2_set_replay(server, &rqst);
5964 rc = cifs_send_recv(xid, ses, server,
6023 struct TCP_Server_Info *server;
6029 server = cifs_pick_channel(tcon->ses);
6033 rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
6061 smb2_set_replay(server, &rqst);
6063 rc = cifs_send_recv(xid, tcon->ses, server,
6113 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
6116 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
6140 rc = cifs_send_recv(xid, ses, server,