Lines Matching refs:server
54 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
58 if (server == NULL) {
73 temp->server = server;
94 __le16 command = midEntry->server->vals->lock_cmd;
99 struct TCP_Server_Info *server = midEntry->server;
103 server->ops->handle_cancelled_mid)
104 server->ops->handle_cancelled_mid(midEntry, server);
119 if (atomic_read(&server->num_cmds[smb_cmd]) == 0) {
120 server->slowest_cmd[smb_cmd] = roundtrip_time;
121 server->fastest_cmd[smb_cmd] = roundtrip_time;
123 if (server->slowest_cmd[smb_cmd] < roundtrip_time)
124 server->slowest_cmd[smb_cmd] = roundtrip_time;
125 else if (server->fastest_cmd[smb_cmd] > roundtrip_time)
126 server->fastest_cmd[smb_cmd] = roundtrip_time;
128 cifs_stats_inc(&server->num_cmds[smb_cmd]);
129 server->time_per_cmd[smb_cmd] += roundtrip_time;
134 * busy server. Note that this calc is unlikely or impossible to wrap
149 cifs_stats_inc(&server->smb2slowcmd[smb_cmd]);
194 * smb_send_kvec - send an array of kvecs to the server
195 * @server: Server to send the data to
199 * Our basic "send data to server" function. Should be called with srv_mutex
203 smb_send_kvec(struct TCP_Server_Info *server, struct msghdr *smb_msg,
208 struct socket *ssocket = server->ssocket;
212 if (server->noblocksnd)
225 * the server in SendReceive[2] for the server to send
240 (!server->noblocksnd && (retries > 2))) {
268 smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst)
275 if (server->vals->header_preamble_size == 0 &&
312 __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
322 struct socket *ssocket = server->ssocket;
326 cifs_in_send_inc(server);
327 if (cifs_rdma_enabled(server)) {
330 if (server->smbd_conn)
331 rc = smbd_send(server, num_rqst, rqst);
350 send_length += smb_rqst_len(server, &rqst[j]);
356 * latency of system calls and overload a server with unnecessary
364 if (server->vals->header_preamble_size == 0) {
370 rc = smb_send_kvec(server, &smb_msg, &sent);
392 rc = smb_send_kvec(server, &smb_msg, &sent);
408 rc = smb_send_kvec(server, &smb_msg, &sent);
421 * the server we need to return success status to allow a corresponding
423 * to handle responses from the server by the client.
427 * won't be any response from the server to handle.
444 * socket so the server throws away the partial SMB
446 server->tcpStatus = CifsNeedReconnect;
447 trace_smb3_partial_send_reconnect(server->CurrentMid,
448 server->hostname);
452 cifs_server_dbg(VFS, "Error %d sending data on socket to server\n",
457 cifs_in_send_dec(server);
462 smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
471 return __smb_send_rqst(server, num_rqst, rqst);
476 if (!server->ops->init_transform_rq) {
494 rc = server->ops->init_transform_rq(server, num_rqst + 1,
499 rc = __smb_send_rqst(server, num_rqst + 1, &cur_rqst[0]);
507 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
519 return __smb_send_rqst(server, 1, &rqst);
523 wait_for_free_credits(struct TCP_Server_Info *server, const int num_credits,
541 credits = server->ops->get_credits_field(server, optype);
546 spin_lock(&server->req_lock);
549 server->in_flight++;
550 if (server->in_flight > server->max_in_flight)
551 server->max_in_flight = server->in_flight;
553 *instance = server->reconnect_instance;
554 spin_unlock(&server->req_lock);
560 spin_unlock(&server->req_lock);
561 cifs_num_waiters_inc(server);
562 rc = wait_event_killable_timeout(server->request_q,
563 has_credits(server, credits, num_credits), t);
564 cifs_num_waiters_dec(server);
566 trace_smb3_credit_timeout(server->CurrentMid,
567 server->hostname, num_credits, 0);
574 spin_lock(&server->req_lock);
576 if (server->tcpStatus == CifsExiting) {
577 spin_unlock(&server->req_lock);
595 server->in_flight > 2 * MAX_COMPOUND &&
597 spin_unlock(&server->req_lock);
598 cifs_num_waiters_inc(server);
600 server->request_q,
601 has_credits(server, credits,
604 cifs_num_waiters_dec(server);
607 server->CurrentMid,
608 server->hostname, num_credits,
616 spin_lock(&server->req_lock);
622 * as they are allowed to block on server.
625 /* update # of requests on the wire to server */
628 server->in_flight += num_credits;
629 if (server->in_flight > server->max_in_flight)
630 server->max_in_flight = server->in_flight;
631 *instance = server->reconnect_instance;
633 spin_unlock(&server->req_lock);
641 wait_for_free_request(struct TCP_Server_Info *server, const int flags,
644 return wait_for_free_credits(server, 1, -1, flags,
649 wait_for_compound_request(struct TCP_Server_Info *server, int num,
654 credits = server->ops->get_credits_field(server, flags & CIFS_OP_MASK);
656 spin_lock(&server->req_lock);
659 * If the server is tight on resources or just gives us less
661 * order and the server delays granting more credits until it
668 * server will return enough credits to satisfy this compound
674 if (server->in_flight == 0) {
675 spin_unlock(&server->req_lock);
679 spin_unlock(&server->req_lock);
681 return wait_for_free_credits(server, num, 60000, flags,
686 cifs_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
691 credits->instance = server->reconnect_instance;
698 if (ses->server->tcpStatus == CifsExiting) {
702 if (ses->server->tcpStatus == CifsNeedReconnect) {
721 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
725 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
731 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
735 error = wait_event_freezekillable_unsafe(server->response_q,
744 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
754 /* enable signing if server requires it */
755 if (server->sign)
758 mid = AllocMidQEntry(hdr, server);
762 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
776 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
790 rc = wait_for_free_request(server, flags, &instance);
798 mutex_lock(&server->srv_mutex);
805 if (instance != server->reconnect_instance) {
806 mutex_unlock(&server->srv_mutex);
807 add_credits_and_wake_if(server, &credits, optype);
811 mid = server->ops->setup_async_request(server, rqst);
813 mutex_unlock(&server->srv_mutex);
814 add_credits_and_wake_if(server, &credits, optype);
826 list_add_tail(&mid->qhead, &server->pending_mid_q);
834 rc = smb_send_rqst(server, 1, rqst, flags);
837 revert_current_mid(server, mid->credits);
838 server->sequence_number -= 2;
842 mutex_unlock(&server->srv_mutex);
847 add_credits_and_wake_if(server, &credits, optype);
879 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
916 send_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst,
919 return server->ops->send_cancel ?
920 server->ops->send_cancel(server, rqst, mid) : 0;
924 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
932 if (server->sign) {
943 rc = cifs_verify_signature(&rqst, server,
969 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
980 struct TCP_Server_Info *server = mid->server;
983 credits.value = server->ops->get_credits(mid);
984 credits.instance = server->reconnect_instance;
986 add_credits(server, &credits, mid->optype);
1023 return ses->chans[index].server;
1031 struct TCP_Server_Info *server,
1049 if (!ses || !ses->server || !server) {
1054 if (server->tcpStatus == CifsExiting)
1060 * credits if the server doesn't grant credits to the outstanding
1065 rc = wait_for_compound_request(server, num_rqst, flags,
1081 mutex_lock(&server->srv_mutex);
1090 if (instance != server->reconnect_instance) {
1091 mutex_unlock(&server->srv_mutex);
1093 add_credits(server, &credits[j], optype);
1098 midQ[i] = server->ops->setup_request(ses, server, &rqst[i]);
1100 revert_current_mid(server, i);
1103 mutex_unlock(&server->srv_mutex);
1105 /* Update # of requests on wire to server */
1107 add_credits(server, &credits[j], optype);
1123 rc = smb_send_rqst(server, num_rqst, rqst, flags);
1129 revert_current_mid(server, num_rqst);
1130 server->sequence_number -= 2;
1133 mutex_unlock(&server->srv_mutex);
1141 add_credits(server, &credits[i], optype);
1147 * that any credits taken from the server structure on the client have
1149 * we will collect credits granted by the server in the mid callbacks
1150 * and add those credits to the server structure.
1157 mutex_lock(&server->srv_mutex);
1160 mutex_unlock(&server->srv_mutex);
1164 rc = wait_for_response(server, midQ[i]);
1172 send_cancel(server, &rqst[i], midQ[i]);
1188 rc = cifs_sync_mid_result(midQ[i], server);
1205 server->vals->header_preamble_size;
1212 rc = server->ops->check_receive(midQ[i], server,
1229 mutex_lock(&server->srv_mutex);
1231 mutex_unlock(&server->srv_mutex);
1251 struct TCP_Server_Info *server,
1255 return compound_send_recv(xid, ses, server, flags, 1,
1291 rc = cifs_send_recv(xid, ses, ses->server,
1309 struct TCP_Server_Info *server;
1315 server = ses->server;
1316 if (server == NULL) {
1321 if (server->tcpStatus == CifsExiting)
1325 to the same server. We may make this configurable later or
1334 rc = wait_for_free_request(server, flags, &credits.instance);
1342 mutex_lock(&server->srv_mutex);
1346 mutex_unlock(&server->srv_mutex);
1347 /* Update # of requests on wire to server */
1348 add_credits(server, &credits, 0);
1352 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1354 mutex_unlock(&server->srv_mutex);
1360 rc = smb_send(server, in_buf, len);
1364 server->sequence_number -= 2;
1366 mutex_unlock(&server->srv_mutex);
1371 rc = wait_for_response(server, midQ);
1373 send_cancel(server, &rqst, midQ);
1379 add_credits(server, &credits, 0);
1385 rc = cifs_sync_mid_result(midQ, server);
1387 add_credits(server, &credits, 0);
1400 rc = cifs_check_receive(midQ, server, 0);
1403 add_credits(server, &credits, 0);
1427 pSMB->hdr.Mid = get_next_mid(ses->server);
1446 struct TCP_Server_Info *server;
1453 server = ses->server;
1455 if (server == NULL) {
1460 if (server->tcpStatus == CifsExiting)
1464 to the same server. We may make this configurable later or
1473 rc = wait_for_free_request(server, CIFS_BLOCKING_OP, &instance);
1481 mutex_lock(&server->srv_mutex);
1485 mutex_unlock(&server->srv_mutex);
1489 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number);
1492 mutex_unlock(&server->srv_mutex);
1497 rc = smb_send(server, in_buf, len);
1501 server->sequence_number -= 2;
1503 mutex_unlock(&server->srv_mutex);
1511 rc = wait_event_interruptible(server->response_q,
1513 ((server->tcpStatus != CifsGood) &&
1514 (server->tcpStatus != CifsNew)));
1519 ((server->tcpStatus == CifsGood) ||
1520 (server->tcpStatus == CifsNew))) {
1525 rc = send_cancel(server, &rqst, midQ);
1544 rc = wait_for_response(server, midQ);
1546 send_cancel(server, &rqst, midQ);
1561 rc = cifs_sync_mid_result(midQ, server);
1574 rc = cifs_check_receive(midQ, server, 0);