Lines Matching refs:server
86 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
89 (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
97 struct TCP_Server_Info *server)
105 if (server) {
107 if (server->dialect >= SMB30_PROT_ID) {
113 if (SERVER_IS_CHAN(server))
115 cpu_to_le16(server->primary_server->channel_sequence_num);
118 cpu_to_le16(server->channel_sequence_num);
120 spin_lock(&server->req_lock);
122 if (server->credits >= server->max_credits)
126 min_t(int, server->max_credits -
127 server->credits, 10));
128 spin_unlock(&server->req_lock);
139 if (server && (server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
150 * to pass the path on the Open SMB prefixed by \\server\share.
153 * illegal to send an empty path name (without \\server\share prefix)
161 if (server && server->sign && !smb3_encryption_required(tcon))
170 struct TCP_Server_Info *server,
176 if (SERVER_IS_CHAN(server)) {
178 "server %s does not support multichannel anymore. Skip secondary channel\n",
179 ses->server->hostname);
182 chan_index = cifs_ses_get_chan_index(ses, server);
188 ses->chans[chan_index].server = NULL;
189 server->terminate = true;
193 * the above reference of server by channel
198 cifs_put_tcp_session(server, from_reconnect);
200 cifs_signal_cifsd_for_reconnect(server, false);
202 /* mark primary server as needing reconnect */
203 pserver = server->primary_server;
210 "server does not support multichannel anymore. Disable all other channels\n");
219 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) {
308 spin_lock(&server->srv_lock);
309 switch (server->tcpStatus) {
311 spin_unlock(&server->srv_lock);
315 spin_unlock(&server->srv_lock);
323 spin_unlock(&server->srv_lock);
331 if (!cifs_chan_needs_reconnect(ses, server) &&
345 rc = cifs_negotiate_protocol(0, ses, server);
353 * if server stopped supporting multichannel
357 !(server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
358 rc = cifs_chan_skip_or_disable(ses, server,
366 rc = cifs_setup_session(0, ses, server, ses->local_nls);
370 * could be enabled on the server e.g.) if an alternate
413 (server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL) &&
414 server->ops->query_server_interfaces) {
416 * query server network interfaces, in case they change.
423 rc = server->ops->query_server_interfaces(xid, tcon, false);
435 * some servers like Azure SMB server do not advertise
436 * that multichannel has been disabled with server
438 * treat this as server not supporting multichannel
441 rc = cifs_chan_skip_or_disable(ses, server,
445 cifs_dbg(FYI, "%s: failed to query server interfaces: %d\n",
450 !SERVER_IS_CHAN(server)) {
466 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
475 * BB Is flush done by server on drop of tcp session? Should we special
495 struct TCP_Server_Info *server,
509 smb2_hdr_assemble(&spdu->hdr, smb2_command, tcon, server);
521 struct TCP_Server_Info *server,
539 fill_small_buf(smb2_command, tcon, server,
553 struct TCP_Server_Info *server,
558 rc = smb2_reconnect(smb2_command, tcon, server, false);
562 return __smb2_plain_req_init(smb2_command, tcon, server, request_buf,
567 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);
1283 struct TCP_Server_Info *server = tcon->ses->server;
1288 if (server->dialect == SMB311_PROT_ID)
1307 cifs_tcon_dbg(VFS, "Unexpected null user (anonymous) auth flag sent by server\n");
1314 cpu_to_le32(server->vals->req_capabilities);
1318 memcpy(pneg_inbuf->Guid, server->client_guid,
1331 if (strcmp(server->vals->version_string,
1340 } else if (strcmp(server->vals->version_string,
1352 cpu_to_le16(server->vals->protocol_id);
1365 * Old Windows versions or Netapp SMB server can return
1389 if (pneg_rsp->Dialect != cpu_to_le16(server->dialect))
1392 if (pneg_rsp->SecurityMode != cpu_to_le16(server->sec_mode))
1395 /* do not validate server guid because not saved at negprot time yet */
1398 SMB2_LARGE_FILES) != server->capabilities)
1416 smb2_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1425 if (server->sec_ntlmssp &&
1428 if ((server->sec_kerberos || server->sec_mskerberos || server->sec_iakerb) &&
1440 struct TCP_Server_Info *server;
1462 struct TCP_Server_Info *server = sess_data->server;
1467 rc = smb2_plain_req_init(SMB2_SESSION_SETUP, NULL, server,
1497 if (server->credits >= server->max_credits)
1501 min_t(int, server->max_credits -
1502 server->credits, 130));
1505 if (server->sign)
1564 sess_data->server,
1573 trace_smb3_key_expired(sess_data->server->hostname,
1575 sess_data->server->conn_id,
1576 &sess_data->server->dstaddr, rc);
1590 struct TCP_Server_Info *server = sess_data->server;
1592 cifs_server_lock(server);
1593 if (server->ops->generate_signingkey) {
1594 rc = server->ops->generate_signingkey(ses, server);
1598 cifs_server_unlock(server);
1602 if (!server->session_estab) {
1603 server->sequence_number = 0x2;
1604 server->session_estab = true;
1606 cifs_server_unlock(server);
1618 struct TCP_Server_Info *server = sess_data->server;
1628 spnego_key = cifs_get_spnego_key(ses, server);
1713 struct TCP_Server_Info *server = sess_data->server;
1736 &blob_length, ses, server,
1805 struct TCP_Server_Info *server = sess_data->server;
1821 ses, server,
1855 if (ses->server->dialect < SMB30_PROT_ID) {
1883 struct TCP_Server_Info *server = sess_data->server;
1885 type = smb2_select_sectype(server, ses->sectype);
1909 struct TCP_Server_Info *server,
1917 if (!server) {
1918 WARN(1, "%s: server is NULL!\n", __func__);
1928 sess_data->server = server;
1938 * Initialize the session hash with the server one.
1940 memcpy(ses->preauth_sha_hash, server->preauth_sha_hash,
1960 struct TCP_Server_Info *server;
1969 if (ses && (ses->server))
1970 server = ses->server;
1982 rc = smb2_plain_req_init(SMB2_LOGOFF, NULL, ses->server,
1992 else if (server->sign)
2004 rc = cifs_send_recv(xid, ses, ses->server,
2021 #define MAX_SHARENAME_LENGTH (255 /* server */ + 80 /* share */ + 1 /* NULL */)
2046 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2050 if (!server || !tree)
2067 rc = smb2_plain_req_init(SMB2_TREE_CONNECT, tcon, server,
2092 if ((server->dialect == SMB311_PROT_ID) &&
2104 if (server->credits >= server->max_credits)
2108 min_t(int, server->max_credits -
2109 server->credits, 64));
2111 rc = cifs_send_recv(xid, ses, server,
2151 !(server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION))
2155 if (server->ops->validate_negotiate)
2156 rc = server->ops->validate_negotiate(xid, tcon);
2159 server->nosharesock = true;
2179 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2188 if (!ses || !(ses->server))
2202 rc = smb2_plain_req_init(SMB2_TREE_DISCONNECT, tcon, server,
2220 rc = cifs_send_recv(xid, ses, server,
2326 int smb2_parse_contexts(struct TCP_Server_Info *server,
2372 *oplock = server->ops->parse_lease_buf(cc, epoch,
2406 add_lease_context(struct TCP_Server_Info *server,
2417 iov[num].iov_base = server->ops->create_lease_buf(lease_key, *oplock,
2421 iov[num].iov_len = server->vals->create_lease_size;
2445 * NB: Handle timeout defaults to 0, which allows server to choose
2843 struct TCP_Server_Info *server;
2850 server = cifs_pick_channel(ses);
2859 if (!ses || !server) {
2865 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
2957 smb2_set_replay(server, &rqst);
2960 rc = cifs_send_recv(xid, ses, server,
3005 SMB2_open_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3019 rc = smb2_plain_req_init(SMB2_CREATE, tcon, server,
3080 if ((!server->oplocks) || (tcon->no_lease))
3083 if (!(server->capabilities & SMB2_GLOBAL_CAP_LEASING) ||
3086 else if (!(server->capabilities & SMB2_GLOBAL_CAP_DIRECTORY_LEASING) &&
3090 rc = add_lease_context(server, req, iov, &n_iov,
3199 struct TCP_Server_Info *server;
3210 server = cifs_pick_channel(ses);
3214 if (!ses || !server)
3225 rc = SMB2_open_init(tcon, server,
3234 smb2_set_replay(server, &rqst);
3236 rc = cifs_send_recv(xid, ses, server,
3252 pr_warn_once("server share %s deleted\n",
3284 rc = smb2_parse_contexts(server, &rsp_iov, &oparms->fid->epoch,
3298 SMB2_ioctl_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3310 rc = smb2_ioctl_req_init(opcode, tcon, server,
3361 * ioctls it may be useful to allow server to send more. No point
3362 * limiting what the server can send as long as fits in one credit
3412 struct TCP_Server_Info *server;
3430 server = cifs_pick_channel(ses);
3432 if (!server)
3452 rc = SMB2_ioctl_init(tcon, server,
3459 smb2_set_replay(server, &rqst);
3461 rc = cifs_send_recv(xid, ses, server,
3504 goto ioctl_exit; /* server returned no data */
3565 SMB2_close_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3574 rc = smb2_plain_req_init(SMB2_CLOSE, tcon, server,
3606 struct TCP_Server_Info *server;
3619 server = cifs_pick_channel(ses);
3623 if (!ses || !server)
3634 /* check if need to ask server to return timestamps in close response */
3639 rc = SMB2_close_init(tcon, server,
3646 smb2_set_replay(server, &rqst);
3648 rc = cifs_send_recv(xid, ses, server,
3720 cifs_dbg(VFS, "Invalid server response, bad offset to data\n");
3752 SMB2_query_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
3768 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
3813 struct TCP_Server_Info *server;
3827 server = cifs_pick_channel(ses);
3829 if (!server)
3840 rc = SMB2_query_info_init(tcon, server,
3851 smb2_set_replay(server, &rqst);
3853 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);
4108 static void cifs_renegotiate_iosize(struct TCP_Server_Info *server,
4113 if (server == NULL || tcon == NULL)
4118 cifs_negotiate_iosize(server, cifs_sb->ctx, tcon);
4124 struct TCP_Server_Info *server = container_of(work,
4137 if (!server->srv_count) {
4141 server->srv_count++;
4144 /* If server is a channel, select the primary channel */
4145 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
4150 /* if the server is marked for termination, drop the ref count here */
4151 if (server->terminate) {
4152 cifs_put_tcp_session(server, true);
4196 if (!tcon_selected && cifs_chan_needs_reconnect(ses, server)) {
4206 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4208 cifs_renegotiate_iosize(server, tcon);
4238 rc = smb2_reconnect(SMB2_INTERNAL_CMD, tcon, server, true);
4249 queue_delayed_work(cifsiod_wq, &server->reconnect, 2 * HZ);
4253 cifs_put_tcp_session(server, true);
4257 SMB2_echo(struct TCP_Server_Info *server)
4266 cifs_dbg(FYI, "In echo request for conn_id %lld\n", server->conn_id);
4268 spin_lock(&server->srv_lock);
4269 if (server->ops->need_neg &&
4270 server->ops->need_neg(server)) {
4271 spin_unlock(&server->srv_lock);
4273 mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
4276 spin_unlock(&server->srv_lock);
4278 rc = smb2_plain_req_init(SMB2_ECHO, NULL, server,
4288 rc = cifs_call_async(server, &rqst, NULL, smb2_echo_callback, NULL,
4289 server, CIFS_ECHO_OP, NULL);
4306 struct cifs_tcon *tcon, struct TCP_Server_Info *server,
4314 rc = smb2_plain_req_init(SMB2_FLUSH, tcon, server,
4336 struct TCP_Server_Info *server;
4345 server = cifs_pick_channel(ses);
4348 if (!ses || !(ses->server))
4359 rc = SMB2_flush_init(xid, &rqst, tcon, server,
4367 smb2_set_replay(server, &rqst);
4369 rc = cifs_send_recv(xid, ses, server,
4394 struct TCP_Server_Info *server = io_parms->server;
4398 if (!server || !tcon)
4402 if (!server->rdma || !server->smbd_conn)
4406 if (server->sign)
4414 if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
4433 struct TCP_Server_Info *server = io_parms->server;
4435 rc = smb2_plain_req_init(SMB2_READ, io_parms->tcon, server,
4440 if (server == NULL)
4468 bool need_invalidate = server->dialect == SMB30_PROT_ID;
4470 rdata->mr = smbd_register_mr(server->smbd_conn, &rdata->subreq.io_iter,
4524 struct TCP_Server_Info *server = rdata->server;
4541 WARN_ONCE(rdata->server != mid->server,
4542 "rdata server %p != mid server %p",
4543 rdata->server, mid->server);
4552 credits.instance = server->reconnect_instance;
4554 if (server->sign && !mid->decrypted) {
4558 rc = smb2_verify_signature(&rqst, server);
4575 if (server->sign && rdata->got_bytes)
4585 credits.instance = server->reconnect_instance;
4637 server->credits, server->in_flight,
4646 server->credits, server->in_flight,
4648 add_credits(server, &credits, 0);
4662 struct TCP_Server_Info *server;
4670 if (!rdata->server)
4671 rdata->server = cifs_pick_channel(tcon->ses);
4674 io_parms.server = server = rdata->server;
4700 if (server->credits >= server->max_credits)
4704 min_t(int, server->max_credits -
4705 server->credits, credit_request));
4707 rc = adjust_credits(server, rdata, cifs_trace_rw_credits_call_readv_adjust);
4714 rc = cifs_call_async(server, &rqst,
4748 if (!io_parms->server)
4749 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
4766 rc = cifs_send_recv(xid, ses, io_parms->server,
4825 struct TCP_Server_Info *server = wdata->server;
4838 WARN_ONCE(wdata->server != mid->server,
4839 "wdata server %p != mid server %p",
4840 wdata->server, mid->server);
4846 credits.instance = server->reconnect_instance;
4847 result = smb2_check_receive(mid, server, 0);
4856 * by the server is greater than bytes requested by the
4885 credits.instance = server->reconnect_instance;
4926 server->credits, server->in_flight,
4932 server->credits, server->in_flight,
4934 add_credits(server, &credits, 0);
4945 struct TCP_Server_Info *server = wdata->server;
4959 .server = server,
4968 rc = smb2_plain_req_init(SMB2_WRITE, tcon, server,
5008 * If we want to do a server RDMA read, fill in and append
5013 bool need_invalidate = server->dialect == SMB30_PROT_ID;
5015 wdata->mr = smbd_register_mr(server->smbd_conn, &wdata->subreq.io_iter,
5048 smb2_set_replay(server, &rqst);
5057 if (server->credits >= server->max_credits)
5061 min_t(int, server->max_credits -
5062 server->credits, credit_request));
5064 rc = adjust_credits(server, wdata, cifs_trace_rw_credits_call_writev_adjust);
5075 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL,
5098 server->credits, server->in_flight,
5101 add_credits_and_wake_if(wdata->server, &wdata->credits, 0);
5124 struct TCP_Server_Info *server;
5131 if (!io_parms->server)
5132 io_parms->server = cifs_pick_channel(io_parms->tcon->ses);
5133 server = io_parms->server;
5134 if (server == NULL)
5140 rc = smb2_plain_req_init(SMB2_WRITE, io_parms->tcon, server,
5174 smb2_set_replay(server, &rqst);
5176 rc = cifs_send_recv(xid, io_parms->tcon->ses, server,
5358 struct TCP_Server_Info *server,
5373 rc = smb2_plain_req_init(SMB2_QUERY_DIRECTORY, tcon, server,
5412 output_size = min_t(unsigned int, output_size, server->maxBuf);
5523 struct TCP_Server_Info *server;
5530 server = cifs_pick_channel(ses);
5532 if (!ses || !(ses->server))
5543 rc = SMB2_query_directory_init(xid, tcon, server,
5551 smb2_set_replay(server, &rqst);
5553 rc = cifs_send_recv(xid, ses, server,
5596 SMB2_set_info_init(struct cifs_tcon *tcon, struct TCP_Server_Info *server,
5607 rc = smb2_plain_req_init(SMB2_SET_INFO, tcon, server,
5658 struct TCP_Server_Info *server;
5665 server = cifs_pick_channel(ses);
5667 if (!ses || !server)
5684 rc = SMB2_set_info_init(tcon, server,
5694 smb2_set_replay(server, &rqst);
5696 rc = cifs_send_recv(xid, ses, server,
5767 struct TCP_Server_Info *server;
5778 server = cifs_pick_channel(ses);
5781 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
5804 smb2_set_replay(server, &rqst);
5806 rc = cifs_send_recv(xid, ses, server,
5854 struct TCP_Server_Info *server,
5864 if ((tcon->ses == NULL) || server == NULL)
5867 rc = smb2_plain_req_init(SMB2_QUERY_INFO, tcon, server,
5903 struct TCP_Server_Info *server;
5911 server = cifs_pick_channel(ses);
5913 rc = build_qfs_info_req(&iov, tcon, server,
5928 smb2_set_replay(server, &rqst);
5930 rc = cifs_send_recv(xid, ses, server,
5968 struct TCP_Server_Info *server;
5976 server = cifs_pick_channel(ses);
5995 rc = build_qfs_info_req(&iov, tcon, server,
6009 smb2_set_replay(server, &rqst);
6011 rc = cifs_send_recv(xid, ses, server,
6070 struct TCP_Server_Info *server;
6076 server = cifs_pick_channel(tcon->ses);
6080 rc = smb2_plain_req_init(SMB2_LOCK, tcon, server,
6108 smb2_set_replay(server, &rqst);
6110 rc = cifs_send_recv(xid, tcon->ses, server,
6160 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
6163 rc = smb2_plain_req_init(SMB2_OPLOCK_BREAK, tcon, server,
6187 rc = cifs_send_recv(xid, ses, server,