Lines Matching full:server
54 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server) in AllocMidQEntry() argument
58 if (server == NULL) { in AllocMidQEntry()
73 temp->server = server; in AllocMidQEntry()
94 __le16 command = midEntry->server->vals->lock_cmd; in _cifs_mid_q_entry_release()
99 struct TCP_Server_Info *server = midEntry->server; in _cifs_mid_q_entry_release() local
103 server->ops->handle_cancelled_mid) in _cifs_mid_q_entry_release()
104 server->ops->handle_cancelled_mid(midEntry, server); in _cifs_mid_q_entry_release()
119 if (atomic_read(&server->num_cmds[smb_cmd]) == 0) { in _cifs_mid_q_entry_release()
120 server->slowest_cmd[smb_cmd] = roundtrip_time; in _cifs_mid_q_entry_release()
121 server->fastest_cmd[smb_cmd] = roundtrip_time; in _cifs_mid_q_entry_release()
123 if (server->slowest_cmd[smb_cmd] < roundtrip_time) in _cifs_mid_q_entry_release()
124 server->slowest_cmd[smb_cmd] = roundtrip_time; in _cifs_mid_q_entry_release()
125 else if (server->fastest_cmd[smb_cmd] > roundtrip_time) in _cifs_mid_q_entry_release()
126 server->fastest_cmd[smb_cmd] = roundtrip_time; in _cifs_mid_q_entry_release()
128 cifs_stats_inc(&server->num_cmds[smb_cmd]); in _cifs_mid_q_entry_release()
129 server->time_per_cmd[smb_cmd] += roundtrip_time; in _cifs_mid_q_entry_release()
134 * busy server. Note that this calc is unlikely or impossible to wrap in _cifs_mid_q_entry_release()
149 cifs_stats_inc(&server->smb2slowcmd[smb_cmd]); in _cifs_mid_q_entry_release()
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, in smb_send_kvec() argument
208 struct socket *ssocket = server->ssocket; in smb_send_kvec()
212 if (server->noblocksnd) in smb_send_kvec()
225 * the server in SendReceive[2] for the server to send in smb_send_kvec()
240 (!server->noblocksnd && (retries > 2))) { in smb_send_kvec()
268 smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst) in smb_rqst_len() argument
275 if (server->vals->header_preamble_size == 0 && in smb_rqst_len()
312 __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst, in __smb_send_rqst() argument
322 struct socket *ssocket = server->ssocket; in __smb_send_rqst()
326 if (cifs_rdma_enabled(server)) { in __smb_send_rqst()
329 if (server->smbd_conn) in __smb_send_rqst()
330 rc = smbd_send(server, num_rqst, rqst); in __smb_send_rqst()
346 send_length += smb_rqst_len(server, &rqst[j]); in __smb_send_rqst()
352 * latency of system calls and overload a server with unnecessary in __smb_send_rqst()
360 if (server->vals->header_preamble_size == 0) { in __smb_send_rqst()
366 rc = smb_send_kvec(server, &smb_msg, &sent); in __smb_send_rqst()
388 rc = smb_send_kvec(server, &smb_msg, &sent); in __smb_send_rqst()
404 rc = smb_send_kvec(server, &smb_msg, &sent); in __smb_send_rqst()
417 * the server we need to return success status to allow a corresponding in __smb_send_rqst()
419 * to handle responses from the server by the client. in __smb_send_rqst()
423 * won't be any response from the server to handle. in __smb_send_rqst()
440 * socket so the server throws away the partial SMB in __smb_send_rqst()
442 server->tcpStatus = CifsNeedReconnect; in __smb_send_rqst()
443 trace_smb3_partial_send_reconnect(server->CurrentMid, in __smb_send_rqst()
444 server->hostname); in __smb_send_rqst()
448 cifs_server_dbg(VFS, "Error %d sending data on socket to server\n", in __smb_send_rqst()
457 smb_send_rqst(struct TCP_Server_Info *server, int num_rqst, in smb_send_rqst() argument
466 return __smb_send_rqst(server, num_rqst, rqst); in smb_send_rqst()
471 if (!server->ops->init_transform_rq) { in smb_send_rqst()
489 rc = server->ops->init_transform_rq(server, num_rqst + 1, in smb_send_rqst()
494 rc = __smb_send_rqst(server, num_rqst + 1, &cur_rqst[0]); in smb_send_rqst()
502 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer, in smb_send() argument
514 return __smb_send_rqst(server, 1, &rqst); in smb_send()
518 wait_for_free_credits(struct TCP_Server_Info *server, const int num_credits, in wait_for_free_credits() argument
536 credits = server->ops->get_credits_field(server, optype); in wait_for_free_credits()
541 spin_lock(&server->req_lock); in wait_for_free_credits()
544 server->in_flight++; in wait_for_free_credits()
545 if (server->in_flight > server->max_in_flight) in wait_for_free_credits()
546 server->max_in_flight = server->in_flight; in wait_for_free_credits()
548 *instance = server->reconnect_instance; in wait_for_free_credits()
549 spin_unlock(&server->req_lock); in wait_for_free_credits()
555 spin_unlock(&server->req_lock); in wait_for_free_credits()
556 cifs_num_waiters_inc(server); in wait_for_free_credits()
557 rc = wait_event_killable_timeout(server->request_q, in wait_for_free_credits()
558 has_credits(server, credits, num_credits), t); in wait_for_free_credits()
559 cifs_num_waiters_dec(server); in wait_for_free_credits()
561 trace_smb3_credit_timeout(server->CurrentMid, in wait_for_free_credits()
562 server->hostname, num_credits, 0); in wait_for_free_credits()
569 spin_lock(&server->req_lock); in wait_for_free_credits()
571 if (server->tcpStatus == CifsExiting) { in wait_for_free_credits()
572 spin_unlock(&server->req_lock); in wait_for_free_credits()
590 server->in_flight > 2 * MAX_COMPOUND && in wait_for_free_credits()
592 spin_unlock(&server->req_lock); in wait_for_free_credits()
593 cifs_num_waiters_inc(server); in wait_for_free_credits()
595 server->request_q, in wait_for_free_credits()
596 has_credits(server, credits, in wait_for_free_credits()
599 cifs_num_waiters_dec(server); in wait_for_free_credits()
602 server->CurrentMid, in wait_for_free_credits()
603 server->hostname, num_credits, in wait_for_free_credits()
611 spin_lock(&server->req_lock); in wait_for_free_credits()
617 * as they are allowed to block on server. in wait_for_free_credits()
620 /* update # of requests on the wire to server */ in wait_for_free_credits()
623 server->in_flight += num_credits; in wait_for_free_credits()
624 if (server->in_flight > server->max_in_flight) in wait_for_free_credits()
625 server->max_in_flight = server->in_flight; in wait_for_free_credits()
626 *instance = server->reconnect_instance; in wait_for_free_credits()
628 spin_unlock(&server->req_lock); in wait_for_free_credits()
636 wait_for_free_request(struct TCP_Server_Info *server, const int flags, in wait_for_free_request() argument
639 return wait_for_free_credits(server, 1, -1, flags, in wait_for_free_request()
644 wait_for_compound_request(struct TCP_Server_Info *server, int num, in wait_for_compound_request() argument
649 credits = server->ops->get_credits_field(server, flags & CIFS_OP_MASK); in wait_for_compound_request()
651 spin_lock(&server->req_lock); in wait_for_compound_request()
654 * If the server is tight on resources or just gives us less in wait_for_compound_request()
656 * order and the server delays granting more credits until it in wait_for_compound_request()
663 * server will return enough credits to satisfy this compound in wait_for_compound_request()
669 if (server->in_flight == 0) { in wait_for_compound_request()
670 spin_unlock(&server->req_lock); in wait_for_compound_request()
674 spin_unlock(&server->req_lock); in wait_for_compound_request()
676 return wait_for_free_credits(server, num, 60000, flags, in wait_for_compound_request()
681 cifs_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size, in cifs_wait_mtu_credits() argument
686 credits->instance = server->reconnect_instance; in cifs_wait_mtu_credits()
693 if (ses->server->tcpStatus == CifsExiting) { in allocate_mid()
697 if (ses->server->tcpStatus == CifsNeedReconnect) { in allocate_mid()
716 *ppmidQ = AllocMidQEntry(in_buf, ses->server); in allocate_mid()
720 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q); in allocate_mid()
726 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ) in wait_for_response() argument
730 error = wait_event_freezekillable_unsafe(server->response_q, in wait_for_response()
739 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst) in cifs_setup_async_request() argument
749 /* enable signing if server requires it */ in cifs_setup_async_request()
750 if (server->sign) in cifs_setup_async_request()
753 mid = AllocMidQEntry(hdr, server); in cifs_setup_async_request()
757 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number); in cifs_setup_async_request()
771 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst, in cifs_call_async() argument
785 rc = wait_for_free_request(server, flags, &instance); in cifs_call_async()
793 mutex_lock(&server->srv_mutex); in cifs_call_async()
800 if (instance != server->reconnect_instance) { in cifs_call_async()
801 mutex_unlock(&server->srv_mutex); in cifs_call_async()
802 add_credits_and_wake_if(server, &credits, optype); in cifs_call_async()
806 mid = server->ops->setup_async_request(server, rqst); in cifs_call_async()
808 mutex_unlock(&server->srv_mutex); in cifs_call_async()
809 add_credits_and_wake_if(server, &credits, optype); in cifs_call_async()
821 list_add_tail(&mid->qhead, &server->pending_mid_q); in cifs_call_async()
829 cifs_in_send_inc(server); in cifs_call_async()
830 rc = smb_send_rqst(server, 1, rqst, flags); in cifs_call_async()
831 cifs_in_send_dec(server); in cifs_call_async()
834 revert_current_mid(server, mid->credits); in cifs_call_async()
835 server->sequence_number -= 2; in cifs_call_async()
839 mutex_unlock(&server->srv_mutex); in cifs_call_async()
844 add_credits_and_wake_if(server, &credits, optype); in cifs_call_async()
876 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server) in cifs_sync_mid_result() argument
913 send_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst, in send_cancel() argument
916 return server->ops->send_cancel ? in send_cancel()
917 server->ops->send_cancel(server, rqst, mid) : 0; in send_cancel()
921 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server, in cifs_check_receive() argument
929 if (server->sign) { in cifs_check_receive()
940 rc = cifs_verify_signature(&rqst, server, in cifs_check_receive()
966 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number); in cifs_setup_request()
977 struct TCP_Server_Info *server = mid->server; in cifs_compound_callback() local
980 credits.value = server->ops->get_credits(mid); in cifs_compound_callback()
981 credits.instance = server->reconnect_instance; in cifs_compound_callback()
983 add_credits(server, &credits, mid->optype); in cifs_compound_callback()
1020 return ses->chans[index].server; in cifs_pick_channel()
1028 struct TCP_Server_Info *server, in compound_send_recv() argument
1046 if (!ses || !ses->server || !server) { in compound_send_recv()
1051 if (server->tcpStatus == CifsExiting) in compound_send_recv()
1057 * credits if the server doesn't grant credits to the outstanding in compound_send_recv()
1062 rc = wait_for_compound_request(server, num_rqst, flags, in compound_send_recv()
1078 mutex_lock(&server->srv_mutex); in compound_send_recv()
1087 if (instance != server->reconnect_instance) { in compound_send_recv()
1088 mutex_unlock(&server->srv_mutex); in compound_send_recv()
1090 add_credits(server, &credits[j], optype); in compound_send_recv()
1095 midQ[i] = server->ops->setup_request(ses, server, &rqst[i]); in compound_send_recv()
1097 revert_current_mid(server, i); in compound_send_recv()
1100 mutex_unlock(&server->srv_mutex); in compound_send_recv()
1102 /* Update # of requests on wire to server */ in compound_send_recv()
1104 add_credits(server, &credits[j], optype); in compound_send_recv()
1120 cifs_in_send_inc(server); in compound_send_recv()
1121 rc = smb_send_rqst(server, num_rqst, rqst, flags); in compound_send_recv()
1122 cifs_in_send_dec(server); in compound_send_recv()
1128 revert_current_mid(server, num_rqst); in compound_send_recv()
1129 server->sequence_number -= 2; in compound_send_recv()
1132 mutex_unlock(&server->srv_mutex); in compound_send_recv()
1140 add_credits(server, &credits[i], optype); in compound_send_recv()
1146 * that any credits taken from the server structure on the client have in compound_send_recv()
1148 * we will collect credits granted by the server in the mid callbacks in compound_send_recv()
1149 * and add those credits to the server structure. in compound_send_recv()
1156 mutex_lock(&server->srv_mutex); in compound_send_recv()
1159 mutex_unlock(&server->srv_mutex); in compound_send_recv()
1163 rc = wait_for_response(server, midQ[i]); in compound_send_recv()
1171 send_cancel(server, &rqst[i], midQ[i]); in compound_send_recv()
1187 rc = cifs_sync_mid_result(midQ[i], server); in compound_send_recv()
1204 server->vals->header_preamble_size; in compound_send_recv()
1211 rc = server->ops->check_receive(midQ[i], server, in compound_send_recv()
1228 mutex_lock(&server->srv_mutex); in compound_send_recv()
1230 mutex_unlock(&server->srv_mutex); in compound_send_recv()
1250 struct TCP_Server_Info *server, in cifs_send_recv() argument
1254 return compound_send_recv(xid, ses, server, flags, 1, in cifs_send_recv()
1290 rc = cifs_send_recv(xid, ses, ses->server, in SendReceive2()
1308 struct TCP_Server_Info *server; in SendReceive() local
1314 server = ses->server; in SendReceive()
1315 if (server == NULL) { in SendReceive()
1320 if (server->tcpStatus == CifsExiting) in SendReceive()
1324 to the same server. We may make this configurable later or in SendReceive()
1333 rc = wait_for_free_request(server, flags, &credits.instance); in SendReceive()
1341 mutex_lock(&server->srv_mutex); in SendReceive()
1345 mutex_unlock(&server->srv_mutex); in SendReceive()
1346 /* Update # of requests on wire to server */ in SendReceive()
1347 add_credits(server, &credits, 0); in SendReceive()
1351 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number); in SendReceive()
1353 mutex_unlock(&server->srv_mutex); in SendReceive()
1359 cifs_in_send_inc(server); in SendReceive()
1360 rc = smb_send(server, in_buf, len); in SendReceive()
1361 cifs_in_send_dec(server); in SendReceive()
1365 server->sequence_number -= 2; in SendReceive()
1367 mutex_unlock(&server->srv_mutex); in SendReceive()
1372 rc = wait_for_response(server, midQ); in SendReceive()
1374 send_cancel(server, &rqst, midQ); in SendReceive()
1380 add_credits(server, &credits, 0); in SendReceive()
1386 rc = cifs_sync_mid_result(midQ, server); in SendReceive()
1388 add_credits(server, &credits, 0); in SendReceive()
1401 rc = cifs_check_receive(midQ, server, 0); in SendReceive()
1404 add_credits(server, &credits, 0); in SendReceive()
1428 pSMB->hdr.Mid = get_next_mid(ses->server); in send_lock_cancel()
1447 struct TCP_Server_Info *server; in SendReceiveBlockingLock() local
1454 server = ses->server; in SendReceiveBlockingLock()
1456 if (server == NULL) { in SendReceiveBlockingLock()
1461 if (server->tcpStatus == CifsExiting) in SendReceiveBlockingLock()
1465 to the same server. We may make this configurable later or in SendReceiveBlockingLock()
1474 rc = wait_for_free_request(server, CIFS_BLOCKING_OP, &instance); in SendReceiveBlockingLock()
1482 mutex_lock(&server->srv_mutex); in SendReceiveBlockingLock()
1486 mutex_unlock(&server->srv_mutex); in SendReceiveBlockingLock()
1490 rc = cifs_sign_smb(in_buf, server, &midQ->sequence_number); in SendReceiveBlockingLock()
1493 mutex_unlock(&server->srv_mutex); in SendReceiveBlockingLock()
1498 cifs_in_send_inc(server); in SendReceiveBlockingLock()
1499 rc = smb_send(server, in_buf, len); in SendReceiveBlockingLock()
1500 cifs_in_send_dec(server); in SendReceiveBlockingLock()
1504 server->sequence_number -= 2; in SendReceiveBlockingLock()
1506 mutex_unlock(&server->srv_mutex); in SendReceiveBlockingLock()
1514 rc = wait_event_interruptible(server->response_q, in SendReceiveBlockingLock()
1516 ((server->tcpStatus != CifsGood) && in SendReceiveBlockingLock()
1517 (server->tcpStatus != CifsNew))); in SendReceiveBlockingLock()
1522 ((server->tcpStatus == CifsGood) || in SendReceiveBlockingLock()
1523 (server->tcpStatus == CifsNew))) { in SendReceiveBlockingLock()
1528 rc = send_cancel(server, &rqst, midQ); in SendReceiveBlockingLock()
1547 rc = wait_for_response(server, midQ); in SendReceiveBlockingLock()
1549 send_cancel(server, &rqst, midQ); in SendReceiveBlockingLock()
1564 rc = cifs_sync_mid_result(midQ, server); in SendReceiveBlockingLock()
1577 rc = cifs_check_receive(midQ, server, 0); in SendReceiveBlockingLock()