Lines Matching defs:server
83 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
91 struct TCP_Server_Info *server)
99 if (server) {
101 if (server->dialect >= SMB30_PROT_ID) {
107 if (SERVER_IS_CHAN(server))
109 cpu_to_le16(server->primary_server->channel_sequence_num);
112 cpu_to_le16(server->channel_sequence_num);
114 spin_lock(&server->req_lock);
116 if (server->credits >= server->max_credits)
120 min_t(int, server->max_credits -
121 server->credits, 10));
122 spin_unlock(&server->req_lock);
133 if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
144 * to pass the path on the Open SMB prefixed by \\server\share.
147 * illegal to send an empty path name (without \\server\share prefix)
155 if (server && server->sign && !smb3_encryption_required(tcon))
164 struct TCP_Server_Info *server,
170 if (SERVER_IS_CHAN(server)) {
172 "server %s does not support multichannel anymore. Skip secondary channel\n",
173 ses->server->hostname);
176 chan_index = cifs_ses_get_chan_index(ses, server);
182 ses->chans[chan_index].server = NULL;
183 server->terminate = true;
187 * the above reference of server by channel
192 cifs_put_tcp_session(server, from_reconnect);
194 cifs_signal_cifsd_for_reconnect(server, false);
196 /* mark primary server as needing reconnect */
197 pserver = server->primary_server;
204 "server does not support multichannel anymore. Disable all other channels\n");
213 struct TCP_Server_Info *server, bool from_reconnect)
258 if (!ses->server || !server)
261 spin_lock(&server->srv_lock);
262 if (server->tcpStatus == CifsNeedReconnect) {
275 spin_unlock(&server->srv_lock);
280 /* if server is marked for termination, cifsd will cleanup */
281 if (server->terminate) {
282 spin_unlock(&server->srv_lock);
285 spin_unlock(&server->srv_lock);
288 rc = cifs_wait_for_server_reconnect(server, tcon->retry);
293 if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {
308 spin_lock(&server->srv_lock);
309 if (server->tcpStatus == CifsExiting) {
310 spin_unlock(&server->srv_lock);
318 * and the server never sends an answer the socket will be closed
321 if (server->tcpStatus == CifsNeedReconnect) {
322 spin_unlock(&server->srv_lock);
331 spin_unlock(&server->srv_lock);
341 if (!cifs_chan_needs_reconnect(ses, server) &&
355 rc = cifs_negotiate_protocol(0, ses, server);
358 * if server stopped supporting multichannel
362 !(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
363 rc = cifs_chan_skip_or_disable(ses, server,
371 rc = cifs_setup_session(0, ses, server, nls_codepage);
375 * could be enabled on the server e.g.) if an alternate
425 (server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL) &&
426 server->ops->query_server_interfaces) {
430 * query server network interfaces, in case they change
433 rc = server->ops->query_server_interfaces(xid, tcon, false);
438 * some servers like Azure SMB server do not advertise
439 * that multichannel has been disabled with server
441 * treat this as server not supporting multichannel
444 rc = cifs_chan_skip_or_disable(ses, server,
448 cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
453 !SERVER_IS_CHAN(server)) {
472 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
481 * BB Is flush done by server on drop of tcp session? Should we special
501 struct TCP_Server_Info *server,
515 smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server);
527 struct TCP_Server_Info *server,
545 fill_small_buf(smb2_command, tcon, server,
559 struct TCP_Server_Info *server,
564 rc = smb2_reconnect(smb2_command, tcon, server, false);
568 return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,
573 struct TCP_Server_Info *server,
578 return __smb2_plain_req_init(SMB2_IOCTL, tcon, server,
581 return smb2_plain_req_init(SMB2_IOCTL, tcon, server,
662 /* copy up to max of first 100 bytes of server name to NetName field */
694 struct TCP_Server_Info *server, unsigned int *total_len)
730 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
748 if (server->compression.requested) {
780 pr_warn_once("server sent bad preauth context\n");
783 pr_warn_once("server sent invalid SaltLength\n");
792 static void decode_compress_ctx(struct TCP_Server_Info *server,
798 server->compression.enabled = false;
806 pr_warn_once("server sent bad compression cntxt\n");
823 server->compression.alg = alg;
824 server->compression.enabled = true;
827 static int decode_encrypt_ctx(struct TCP_Server_Info *server,
839 pr_warn_once("server sent bad crypto ctxt len\n");
855 * e.g. if server only supported AES256_CCM (very unlikely)
856 * or server supported no encryption types or had all disabled.
860 * seal not requested by client, since server is allowed to
863 server->cipher_type = 0;
864 server->capabilities &= ~SMB2_GLOBAL_CAP_ENCRYPTION;
870 /* server returned a cipher we didn't ask for */
874 server->cipher_type = ctxt->Ciphers[0];
875 server->capabilities |= SMB2_GLOBAL_CAP_ENCRYPTION;
879 static void decode_signing_ctx(struct TCP_Server_Info *server,
890 pr_warn_once("server sent bad signing negcontext\n");
902 server->signing_negotiated = true;
903 server->signing_algorithm = le16_to_cpu(pctxt->SigningAlgorithms[0]);
905 server->signing_algorithm);
910 struct TCP_Server_Info *server,
950 rc = decode_encrypt_ctx(server,
953 decode_compress_ctx(server,
956 server->posix_ext_supported = true;
958 decode_signing_ctx(server,
1045 struct TCP_Server_Info *server)
1061 if (!server) {
1062 WARN(1, "%s: server is NULL!\n", __func__);
1066 rc = smb2_plain_req_init(SMB2_NEGOTIATE, NULL, server,
1073 memset(server->preauth_sha_hash, 0, SMB2_PREAUTH_HASH_SIZE);
1076 if (strcmp(server->vals->version_string,
1083 } else if (strcmp(server->vals->version_string,
1093 req->Dialects[0] = cpu_to_le16(server->vals->protocol_id);
1106 req->Capabilities = cpu_to_le32(server->vals->req_capabilities);
1111 if (server->vals->protocol_id == SMB20_PROT_ID)
1114 memcpy(req->ClientGUID, server->client_guid,
1116 if ((server->vals->protocol_id == SMB311_PROT_ID) ||
1117 (strcmp(server->vals->version_string,
1119 (strcmp(server->vals->version_string,
1121 assemble_neg_contexts(req, server, &total_len);
1130 rc = cifs_send_recv(xid, ses, server,
1139 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");
1145 if (strcmp(server->vals->version_string,
1157 server->ops = &smb311_operations;
1158 server->vals = &smb311_values;
1160 } else if (strcmp(server->vals->version_string,
1168 server->ops = &smb21_operations;
1169 server->vals = &smb21_values;
1171 server->ops = &smb311_operations;
1172 server->vals = &smb311_values;
1175 server->vals->protocol_id) {
1195 cifs_server_dbg(VFS, "Invalid dialect returned by server 0x%x\n",
1201 server->dialect = le16_to_cpu(rsp->DialectRevision);
1206 * server.
1208 memcpy(server->preauth_sha_hash, ses->preauth_sha_hash,
1212 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
1214 server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
1216 server->max_read = le32_to_cpu(rsp->MaxReadSize);
1217 server->max_write = le32_to_cpu(rsp->MaxWriteSize);
1218 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
1219 if ((server->sec_mode & SMB2_SEC_MODE_FLAGS_ALL) != server->sec_mode)
1221 server->sec_mode);
1222 server->capabilities = le32_to_cpu(rsp->Capabilities);
1224 server->capabilities |= SMB2_NT_FIND | SMB2_LARGE_FILES;
1230 if (server->dialect == SMB30_PROT_ID && (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
1231 server->cipher_type = SMB2_ENCRYPTION_AES128_CCM;
1240 * We just found a server which sets blob length to zero expecting raw.
1244 server->sec_ntlmssp = true;
1247 rc = cifs_enable_signing(server, ses->sign);
1251 rc = decode_negTokenInit(security_blob, blob_length, server);
1260 rc = smb311_decode_neg_context(rsp, server,
1277 struct TCP_Server_Info *server = tcon->ses->server;
1282 if (server->dialect == SMB311_PROT_ID)
1301 cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n");
1308 cpu_to_le32(server->vals->req_capabilities);
1312 memcpy(pneg_inbuf->Guid, server->client_guid,
1325 if (strcmp(server->vals->version_string,
1334 } else if (strcmp(server->vals->version_string,
1346 cpu_to_le16(server->vals->protocol_id);
1359 * Old Windows versions or Netapp SMB server can return
1383 if (pneg_rsp->Dialect != cpu_to_le16(server->dialect))
1386 if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode))
1389 /* do not validate server guid because not saved at negprot time yet */
1392 SMB2_LARGE_FILES) != server->capabilities)
1410 smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1419 if (server->sec_ntlmssp &&
1422 if ((server->sec_kerberos || server->sec_mskerberos) &&
1434 struct TCP_Server_Info *server;
1456 struct TCP_Server_Info *server = sess_data->server;
1461 rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,
1491 if (server->credits >= server->max_credits)
1495 min_t(int, server->max_credits -
1496 server->credits, 130));
1499 if (server->sign)
1558 sess_data->server,
1578 struct TCP_Server_Info *server = sess_data->server;
1580 cifs_server_lock(server);
1581 if (server->ops->generate_signingkey) {
1582 rc = server->ops->generate_signingkey(ses, server);
1586 cifs_server_unlock(server);
1590 if (!server->session_estab) {
1591 server->sequence_number = 0x2;
1592 server->session_estab = true;
1594 cifs_server_unlock(server);
1606 struct TCP_Server_Info *server = sess_data->server;
1616 spnego_key = cifs_get_spnego_key(ses, server);
1701 struct TCP_Server_Info *server = sess_data->server;
1724 &blob_length, ses, server,
1793 struct TCP_Server_Info *server = sess_data->server;
1809 ses, server,
1843 if (ses->server->dialect < SMB30_PROT_ID) {
1871 struct TCP_Server_Info *server = sess_data->server;
1873 type = smb2_select_sectype(server, ses->sectype);
1897 struct TCP_Server_Info *server,
1905 if (!server) {
1906 WARN(1, "%s: server is NULL!\n", __func__);
1916 sess_data->server = server;
1926 * Initialize the session hash with the server one.
1928 memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,
1948 struct TCP_Server_Info *server;
1957 if (ses && (ses->server))
1958 server = ses->server;
1970 rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,
1980 else if (server->sign)
1992 rc = cifs_send_recv(xid, ses, ses->server,
2009 #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
2034 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2038 if (!server || !tree)
2055 rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,
2080 if ((server->dialect == SMB311_PROT_ID) &&
2092 if (server->credits >= server->max_credits)
2096 min_t(int, server->max_credits -
2097 server->credits, 64));
2099 rc = cifs_send_recv(xid, ses, server,
2139 !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
2143 if (server->ops->validate_negotiate)
2144 rc = server->ops->validate_negotiate(xid, tcon);
2147 server->nosharesock = true;
2167 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2176 if (!ses || !(ses->server))
2190 rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, server,
2208 rc = cifs_send_recv(xid, ses, server,
2314 int smb2_parse_contexts(struct TCP_Server_Info *server,
2360 *oplock = server->ops->parse_lease_buf(cc, epoch,
2394 add_lease_context(struct TCP_Server_Info *server,
2401 iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock);
2404 iov[num].iov_len = server->vals->create_lease_size;
2428 * NB: Handle timeout defaults to 0, which allows server to choose
2826 struct TCP_Server_Info *server;
2833 server = cifs_pick_channel(ses);
2842 if (!ses || !server) {
2848 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2939 smb2_set_replay(server, &rqst);
2942 rc = cifs_send_recv(xid, ses, server,
2987 SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3001 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
3062 if ((!server->oplocks) || (tcon->no_lease))
3065 if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
3068 else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&
3072 rc = add_lease_context(server, req, iov, &n_iov,
3179 struct TCP_Server_Info *server;
3190 server = cifs_pick_channel(ses);
3194 if (!ses || !server)
3205 rc = SMB2_open_init(tcon, server,
3214 smb2_set_replay(server, &rqst);
3216 rc = cifs_send_recv(xid, ses, server,
3232 pr_warn_once("server share %s deleted\n",
3264 rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch,
3278 SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3290 rc = smb2_ioctl_req_init(opcode, tcon, server,
3341 * ioctls it may be useful to allow server to send more. No point
3342 * limiting what the server can send as long as fits in one credit
3392 struct TCP_Server_Info *server;
3410 server = cifs_pick_channel(ses);
3412 if (!server)
3432 rc = SMB2_ioctl_init(tcon, server,
3439 smb2_set_replay(server, &rqst);
3441 rc = cifs_send_recv(xid, ses, server,
3484 goto ioctl_exit; /* server returned no data */
3545 SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3554 rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,
3586 struct TCP_Server_Info *server;
3599 server = cifs_pick_channel(ses);
3603 if (!ses || !server)
3614 /* check if need to ask server to return timestamps in close response */
3619 rc = SMB2_close_init(tcon, server,
3626 smb2_set_replay(server, &rqst);
3628 rc = cifs_send_recv(xid, ses, server,
3700 cifs_dbg(VFS, "Invalid server response, bad offset to data\n");
3732 SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3748 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
3793 struct TCP_Server_Info *server;
3807 server = cifs_pick_channel(ses);
3809 if (!server)
3820 rc = SMB2_query_info_init(tcon, server,
3831 smb2_set_replay(server, &rqst);
3833 rc = cifs_send_recv(xid, ses, server,
3942 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3951 rc = smb2_plain_req_init(SMB2_CHANGE_NOTIFY, tcon, server,
3980 struct TCP_Server_Info *server;
3993 server = cifs_pick_channel(ses);
3996 if (!ses || !server)
4010 rc = SMB2_notify_init(xid, &rqst, tcon, server,
4020 smb2_set_replay(server, &rqst);
4022 rc = cifs_send_recv(xid, ses, server,
4068 * rather in the fact that the server sent one and that server->lstrp
4076 struct TCP_Server_Info *server = mid->callback_data;
4083 credits.instance = server->reconnect_instance;
4087 add_credits(server, &credits, CIFS_ECHO_OP);
4092 struct TCP_Server_Info *server = container_of(work,
4105 if (!server->srv_count) {
4109 server->srv_count++;
4112 /* If server is a channel, select the primary channel */
4113 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
4118 /* if the server is marked for termination, drop the ref count here */
4119 if (server->terminate) {
4120 cifs_put_tcp_session(server, true);
4164 if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {
4174 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4207 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4218 queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
4222 cifs_put_tcp_session(server, true);
4226 SMB2_echo(struct TCP_Server_Info *server)
4235 cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);
4237 spin_lock(&server->srv_lock);
4238 if (server->ops->need_neg &&
4239 server->ops->need_neg(server)) {
4240 spin_unlock(&server->srv_lock);
4242 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
4245 spin_unlock(&server->srv_lock);
4247 rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
4257 rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
4258 server, CIFS_ECHO_OP, NULL);
4275 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
4283 rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
4305 struct TCP_Server_Info *server;
4314 server = cifs_pick_channel(ses);
4317 if (!ses || !(ses->server))
4328 rc = SMB2_flush_init(xid, &rqst, tcon, server,
4336 smb2_set_replay(server, &rqst);
4338 rc = cifs_send_recv(xid, ses, server,
4363 struct TCP_Server_Info *server = io_parms->server;
4367 if (!server || !tcon)
4371 if (!server->rdma || !server->smbd_conn)
4375 if (server->sign)
4383 if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
4402 struct TCP_Server_Info *server = io_parms->server;
4404 rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
4409 if (server == NULL)
4437 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4439 rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->subreq.io_iter,
4492 struct TCP_Server_Info *server = rdata->server;
4503 WARN_ONCE(rdata->server != mid->server,
4504 "rdata server %p != mid server %p",
4505 rdata->server, mid->server);
4514 credits.instance = server->reconnect_instance;
4516 if (server->sign && !mid->decrypted) {
4520 rc = smb2_verify_signature(&rqst, server);
4532 if (server->sign && rdata->got_bytes)
4541 credits.instance = server->reconnect_instance;
4587 add_credits(server, &credits, 0);
4600 struct TCP_Server_Info *server;
4608 if (!rdata->server)
4609 rdata->server = cifs_pick_channel(tcon->ses);
4612 io_parms.server = server = rdata->server;
4636 if (server->credits >= server->max_credits)
4640 min_t(int, server->max_credits -
4641 server->credits, credit_request));
4643 rc = adjust_credits(server, &rdata->credits, rdata->subreq.len);
4650 rc = cifs_call_async(server, &rqst,
4683 if (!io_parms->server)
4684 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4701 rc = cifs_send_recv(xid, ses, io_parms->server,
4760 struct TCP_Server_Info *server = wdata->server;
4766 WARN_ONCE(wdata->server != mid->server,
4767 "wdata server %p != mid server %p",
4768 wdata->server, mid->server);
4773 credits.instance = server->reconnect_instance;
4774 result = smb2_check_receive(mid, server, 0);
4781 * by the server is greater than bytes requested by the
4800 credits.instance = server->reconnect_instance;
4837 add_credits(server, &credits, 0);
4848 struct TCP_Server_Info *server = wdata->server;
4856 if (!wdata->server || test_bit(NETFS_SREQ_RETRYING, &wdata->subreq.flags))
4857 server = wdata->server = cifs_pick_channel(tcon->ses);
4865 .server = server,
4874 rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
4904 * If we want to do a server RDMA read, fill in and append
4910 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4912 wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->subreq.io_iter,
4942 smb2_set_replay(server, &rqst);
4962 if (server->credits >= server->max_credits)
4966 min_t(int, server->max_credits -
4967 server->credits, credit_request));
4969 rc = adjust_credits(server, &wdata->credits, io_parms->length);
4976 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
4994 add_credits_and_wake_if(wdata->server, &wdata->credits, 0);
5017 struct TCP_Server_Info *server;
5024 if (!io_parms->server)
5025 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
5026 server = io_parms->server;
5027 if (server == NULL)
5033 rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
5067 smb2_set_replay(server, &rqst);
5069 rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
5250 struct TCP_Server_Info *server,
5265 rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
5304 output_size = min_t(unsigned int, output_size, server->maxBuf);
5415 struct TCP_Server_Info *server;
5422 server = cifs_pick_channel(ses);
5424 if (!ses || !(ses->server))
5435 rc = SMB2_query_directory_init(xid, tcon, server,
5443 smb2_set_replay(server, &rqst);
5445 rc = cifs_send_recv(xid, ses, server,
5488 SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
5499 rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
5550 struct TCP_Server_Info *server;
5557 server = cifs_pick_channel(ses);
5559 if (!ses || !server)
5576 rc = SMB2_set_info_init(tcon, server,
5586 smb2_set_replay(server, &rqst);
5588 rc = cifs_send_recv(xid, ses, server,
5659 struct TCP_Server_Info *server;
5670 server = cifs_pick_channel(ses);
5673 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5696 smb2_set_replay(server, &rqst);
5698 rc = cifs_send_recv(xid, ses, server,
5746 struct TCP_Server_Info *server,
5756 if ((tcon->ses == NULL) || server == NULL)
5759 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
5795 struct TCP_Server_Info *server;
5803 server = cifs_pick_channel(ses);
5805 rc = build_qfs_info_req(&iov, tcon, server,
5820 smb2_set_replay(server, &rqst);
5822 rc = cifs_send_recv(xid, ses, server,
5860 struct TCP_Server_Info *server;
5868 server = cifs_pick_channel(ses);
5870 rc = build_qfs_info_req(&iov, tcon, server,
5885 smb2_set_replay(server, &rqst);
5887 rc = cifs_send_recv(xid, ses, server,
5925 struct TCP_Server_Info *server;
5933 server = cifs_pick_channel(ses);
5952 rc = build_qfs_info_req(&iov, tcon, server,
5966 smb2_set_replay(server, &rqst);
5968 rc = cifs_send_recv(xid, ses, server,
6027 struct TCP_Server_Info *server;
6033 server = cifs_pick_channel(tcon->ses);
6037 rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
6065 smb2_set_replay(server, &rqst);
6067 rc = cifs_send_recv(xid, tcon->ses, server,
6117 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
6120 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
6144 rc = cifs_send_recv(xid, ses, server,