Lines Matching defs:server
35 change_conf(struct TCP_Server_Info *server)
37 server->credits += server->echo_credits + server->oplock_credits;
38 if (server->credits > server->max_credits)
39 server->credits = server->max_credits;
40 server->oplock_credits = server->echo_credits = 0;
41 switch (server->credits) {
45 server->echoes = false;
46 server->oplocks = false;
49 server->echoes = true;
50 server->oplocks = false;
51 server->echo_credits = 1;
54 server->echoes = true;
56 server->oplocks = true;
57 server->oplock_credits = 1;
59 server->oplocks = false;
61 server->echo_credits = 1;
63 server->credits -= server->echo_credits + server->oplock_credits;
64 return server->credits + server->echo_credits + server->oplock_credits;
68 smb2_add_credits(struct TCP_Server_Info *server,
78 spin_lock(&server->req_lock);
79 val = server->ops->get_credits_field(server, optype);
85 if ((instance == 0) || (instance == server->reconnect_instance))
92 pr_warn_once("server overflowed SMB3 credits\n");
93 trace_smb3_overflow_credits(server->CurrentMid,
94 server->conn_id, server->hostname, *val,
95 add, server->in_flight);
97 WARN_ON_ONCE(server->in_flight == 0);
98 server->in_flight--;
99 if (server->in_flight == 0 &&
102 rc = change_conf(server);
104 * Sometimes server returns 0 credits on oplock break ack - we need to
107 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
108 server->oplocks) {
109 if (server->credits > 1) {
110 server->credits--;
111 server->oplock_credits++;
113 } else if ((server->in_flight > 0) && (server->oplock_credits > 3) &&
116 change_conf(server);
119 in_flight = server->in_flight;
120 spin_unlock(&server->req_lock);
121 wake_up(&server->request_q);
124 trace_smb3_reconnect_detected(server->CurrentMid,
125 server->conn_id, server->hostname, scredits, add, in_flight);
127 cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\n",
132 trace_smb3_reconnect_with_invalid_credits(server->CurrentMid,
133 server->conn_id, server->hostname, scredits, add, in_flight);
134 cifs_dbg(FYI, "Negotiate operation when server credits is non-zero. Optype: %d, server credits: %d, credits added: %d\n",
138 spin_lock(&server->srv_lock);
139 if (server->tcpStatus == CifsNeedReconnect
140 || server->tcpStatus == CifsExiting) {
141 spin_unlock(&server->srv_lock);
144 spin_unlock(&server->srv_lock);
151 cifs_server_dbg(VFS, "Possible client or server bug - zero credits\n");
164 trace_smb3_add_credits(server->CurrentMid,
165 server->conn_id, server->hostname, scredits, add, in_flight);
170 smb2_set_credits(struct TCP_Server_Info *server, const int val)
174 spin_lock(&server->req_lock);
175 server->credits = val;
177 server->reconnect_instance++;
182 if (SERVER_IS_CHAN(server))
183 server->primary_server->channel_sequence_num++;
185 server->channel_sequence_num++;
187 scredits = server->credits;
188 in_flight = server->in_flight;
189 spin_unlock(&server->req_lock);
191 trace_smb3_set_credits(server->CurrentMid,
192 server->conn_id, server->hostname, scredits, val, in_flight);
201 smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
205 return &server->echo_credits;
207 return &server->oplock_credits;
209 return &server->credits;
220 smb2_wait_mtu_credits(struct TCP_Server_Info *server, size_t size,
226 spin_lock(&server->req_lock);
228 spin_unlock(&server->req_lock);
230 spin_lock(&server->srv_lock);
231 if (server->tcpStatus == CifsExiting) {
232 spin_unlock(&server->srv_lock);
235 spin_unlock(&server->srv_lock);
237 spin_lock(&server->req_lock);
238 if (server->credits <= 0) {
239 spin_unlock(&server->req_lock);
240 cifs_num_waiters_inc(server);
241 rc = wait_event_killable(server->request_q,
242 has_credits(server, &server->credits, 1));
243 cifs_num_waiters_dec(server);
246 spin_lock(&server->req_lock);
248 scredits = server->credits;
264 credits->instance = server->reconnect_instance;
265 server->credits -= credits->value;
266 server->in_flight++;
267 if (server->in_flight > server->max_in_flight)
268 server->max_in_flight = server->in_flight;
272 scredits = server->credits;
273 in_flight = server->in_flight;
274 spin_unlock(&server->req_lock);
276 trace_smb3_wait_credits(server->CurrentMid,
277 server->conn_id, server->hostname, scredits, -(credits->value), in_flight);
285 smb2_adjust_credits(struct TCP_Server_Info *server,
296 trace_smb3_too_many_credits(server->CurrentMid,
297 server->conn_id, server->hostname, 0, credits->value - new_val, 0);
304 spin_lock(&server->req_lock);
306 if (server->reconnect_instance != credits->instance) {
307 scredits = server->credits;
308 in_flight = server->in_flight;
309 spin_unlock(&server->req_lock);
311 trace_smb3_reconnect_detected(server->CurrentMid,
312 server->conn_id, server->hostname, scredits,
319 server->credits += credits->value - new_val;
320 scredits = server->credits;
321 in_flight = server->in_flight;
322 spin_unlock(&server->req_lock);
323 wake_up(&server->request_q);
325 trace_smb3_adj_credits(server->CurrentMid,
326 server->conn_id, server->hostname, scredits,
337 smb2_get_next_mid(struct TCP_Server_Info *server)
341 spin_lock(&server->mid_lock);
342 mid = server->CurrentMid++;
343 spin_unlock(&server->mid_lock);
348 smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
350 spin_lock(&server->mid_lock);
351 if (server->CurrentMid >= val)
352 server->CurrentMid -= val;
353 spin_unlock(&server->mid_lock);
357 __smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue)
368 spin_lock(&server->mid_lock);
369 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
378 spin_unlock(&server->mid_lock);
382 spin_unlock(&server->mid_lock);
387 smb2_find_mid(struct TCP_Server_Info *server, char *buf)
389 return __smb2_find_mid(server, buf, false);
393 smb2_find_dequeue_mid(struct TCP_Server_Info *server, char *buf)
395 return __smb2_find_mid(server, buf, true);
399 smb2_dump_detail(void *buf, struct TCP_Server_Info *server)
407 if (!server->ops->check_message(buf, server->total_read, server)) {
409 server->ops->calc_smb_size(buf));
415 smb2_need_neg(struct TCP_Server_Info *server)
417 return server->max_read == 0;
423 struct TCP_Server_Info *server)
427 spin_lock(&server->mid_lock);
428 server->CurrentMid = 0;
429 spin_unlock(&server->mid_lock);
430 rc = SMB2_negotiate(xid, ses, server);
440 struct TCP_Server_Info *server = tcon->ses->server;
445 wsize = min_t(unsigned int, wsize, server->max_write);
446 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
455 struct TCP_Server_Info *server = tcon->ses->server;
460 wsize = min_t(unsigned int, wsize, server->max_write);
462 if (server->rdma) {
463 if (server->sign)
470 server->smbd_conn->max_fragmented_send_size -
475 wsize, server->smbd_conn->max_readwrite_size);
478 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
487 struct TCP_Server_Info *server = tcon->ses->server;
492 rsize = min_t(unsigned int, rsize, server->max_read);
494 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
503 struct TCP_Server_Info *server = tcon->ses->server;
508 rsize = min_t(unsigned int, rsize, server->max_read);
510 if (server->rdma) {
511 if (server->sign)
518 server->smbd_conn->max_fragmented_recv_size -
523 rsize, server->smbd_conn->max_readwrite_size);
527 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
608 * Samba server e.g. can return an empty interface list in some cases,
616 "Empty network interface list returned by server %s\n",
617 ses->server->hostname);
779 "server does not support query network interfaces\n");
792 pserver = ses->chans[0].server;
1112 struct TCP_Server_Info *server;
1134 server = cifs_pick_channel(ses);
1155 if (ses->server->ops->query_all_EAs) {
1157 rc = ses->server->ops->query_all_EAs(xid, tcon, path,
1211 rc = SMB2_open_init(tcon, server,
1237 rc = SMB2_set_info_init(tcon, server,
1250 rc = SMB2_close_init(tcon, server,
1257 smb2_set_replay(server, &rqst[0]);
1258 smb2_set_replay(server, &rqst[1]);
1259 smb2_set_replay(server, &rqst[2]);
1262 rc = compound_send_recv(xid, ses, server,
1288 smb2_can_echo(struct TCP_Server_Info *server)
1290 return server->echoes;
1350 seq_printf(m, "\nOpen files: %d total (local), %d open on server",
1401 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1409 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
1508 struct TCP_Server_Info *server;
1531 server = cifs_pick_channel(ses);
1550 if (!ses || !server) {
1599 rc = SMB2_open_init(tcon, server,
1607 /* Can eventually relax perm check since server enforces too */
1615 rc = SMB2_ioctl_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1621 /* Can eventually relax perm check since server enforces too */
1637 rc = SMB2_set_info_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1645 rc = SMB2_query_info_init(tcon, server,
1667 rc = SMB2_close_init(tcon, server,
1674 smb2_set_replay(server, &rqst[0]);
1675 smb2_set_replay(server, &rqst[1]);
1676 smb2_set_replay(server, &rqst[2]);
1679 rc = compound_send_recv(xid, ses, server,
1767 /* Request a key from the server to identify the source of the copy */
1789 /* Request server copy to target from src identified by key */
1809 * Check if server claimed to write more than we asked
1846 * and check if the server gave us different sizes after
1848 * if not then why is the server returning an error now
1853 /* Check that server is not asking us to grow size */
1859 goto cchunk_out; /* server gave us bogus size */
1943 * since Samba server doesn't set the flag on the share, yet
1946 * mark that server does not support sparse files for this share
1947 * to avoid repeatedly sending the unsupported fsctl to server
2005 /* server fileays advertise duplicate extent support with this flag */
2270 struct TCP_Server_Info *server;
2277 server = cifs_pick_channel(tcon->ses);
2305 rc = SMB2_open_init(tcon, server,
2319 rc = SMB2_query_directory_init(xid, tcon, server,
2329 smb2_set_replay(server, &rqst[0]);
2330 smb2_set_replay(server, &rqst[1]);
2333 rc = compound_send_recv(xid, tcon->ses, server,
2413 smb2_is_status_pending(char *buf, struct TCP_Server_Info *server)
2422 spin_lock(&server->req_lock);
2423 server->credits += le16_to_cpu(shdr->CreditRequest);
2424 scredits = server->credits;
2425 in_flight = server->in_flight;
2426 spin_unlock(&server->req_lock);
2427 wake_up(&server->request_q);
2429 trace_smb3_pend_credits(server->CurrentMid,
2430 server->conn_id, server->hostname, scredits,
2469 smb2_is_network_name_deleted(char *buf, struct TCP_Server_Info *server)
2479 /* If server is a channel, select the primary channel */
2480 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
2507 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
2516 smb2_set_replay(struct TCP_Server_Info *server, struct smb_rqst *rqst)
2520 if (server->dialect < SMB30_PROT_ID)
2551 struct TCP_Server_Info *server = ses->server;
2552 unsigned long len = smb_rqst_len(server, rqst);
2613 if (tcon->retry || (*pretries)++ < tcon->ses->server->retrans) {
2637 struct TCP_Server_Info *server;
2654 server = cifs_pick_channel(ses);
2694 rc = SMB2_open_init(tcon, server,
2704 rc = SMB2_query_info_init(tcon, server,
2712 rc = SMB2_query_info_init(tcon, server,
2730 rc = SMB2_close_init(tcon, server,
2738 smb2_set_replay(server, &rqst[0]);
2739 smb2_set_replay(server, &rqst[2]);
2741 smb2_set_replay(server, &rqst[1]);
2745 rc = compound_send_recv(xid, ses, server,
2749 rc = compound_send_recv(xid, ses, server,
2757 pr_warn_once("server share %s deleted\n",
3151 /* Retrieve an ACL from the server */
3209 * first, otherwise the data may be inconsistent with the server.
3274 * caches first, otherwise the data may be inconsistent with the server.
3675 * might fill holes on the server.
3835 smb2_downgrade_oplock(struct TCP_Server_Info *server,
3839 server->ops->set_oplock_level(cinode, oplock, 0, NULL);
3847 smb3_downgrade_oplock(struct TCP_Server_Info *server,
3906 /* Check if the server granted an oplock rather than a lease */
4186 smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key)
4192 /* If server is a channel, select the primary channel */
4193 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
4221 crypt_message(struct TCP_Server_Info *server, int num_rqst,
4239 rc = smb2_get_enc_key(server, le64_to_cpu(tr_hdr->SessionId), enc, key);
4246 rc = smb3_crypto_aead_allocate(server);
4252 tfm = enc ? server->secmech.enc : server->secmech.dec;
4254 if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
4255 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4281 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
4282 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4347 smb3_init_transform_rq(struct TCP_Server_Info *server, int num_rqst,
4362 orig_len += smb_rqst_len(server, old);
4402 fill_transform_hdr(tr_hdr, orig_len, old_rq, server->cipher_type);
4404 rc = crypt_message(server, num_rqst, new_rq, 1);
4425 decrypt_raw_data(struct TCP_Server_Info *server, char *buf,
4447 rc = crypt_message(server, 1, &rqst, 0);
4456 server->total_read = buf_data_size + iter_size;
4484 handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,
4503 if (server->ops->is_session_expired &&
4504 server->ops->is_session_expired(buf)) {
4506 cifs_reconnect(server, true);
4510 if (server->ops->is_status_pending &&
4511 server->ops->is_status_pending(buf, server))
4519 min_t(unsigned int, buf_len, server->vals->read_rsp_size);
4525 rdata->result = server->ops->map_error(buf, true);
4527 cifs_dbg(FYI, "%s: server returned error %d\n",
4537 data_offset = server->ops->read_data_offset(buf);
4541 data_len = server->ops->read_data_length(buf, use_rdma_mr);
4543 if (data_offset < server->vals->read_rsp_size) {
4551 data_offset = server->vals->read_rsp_size;
4564 pad_len = data_offset - server->vals->read_rsp_size;
4633 struct TCP_Server_Info *server;
4649 rc = decrypt_raw_data(dw->server, dw->buf, dw->server->vals->read_rsp_size,
4656 dw->server->lstrp = jiffies;
4657 mid = smb2_find_dequeue_mid(dw->server, dw->buf);
4662 rc = handle_read_data(dw->server, mid, dw->buf,
4663 dw->server->vals->read_rsp_size,
4670 if (dw->server->ops->is_network_name_deleted)
4671 dw->server->ops->is_network_name_deleted(dw->buf,
4672 dw->server);
4676 spin_lock(&dw->server->srv_lock);
4677 if (dw->server->tcpStatus == CifsNeedReconnect) {
4678 spin_lock(&dw->server->mid_lock);
4680 spin_unlock(&dw->server->mid_lock);
4681 spin_unlock(&dw->server->srv_lock);
4684 spin_lock(&dw->server->mid_lock);
4688 &dw->server->pending_mid_q);
4689 spin_unlock(&dw->server->mid_lock);
4690 spin_unlock(&dw->server->srv_lock);
4704 receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid,
4708 char *buf = server->smallbuf;
4712 unsigned int buflen = server->pdu_size;
4722 dw->server = server;
4725 len = min_t(unsigned int, buflen, server->vals->read_rsp_size +
4726 sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1;
4728 rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len);
4731 server->total_read += rc;
4734 server->vals->read_rsp_size;
4758 rc = cifs_read_iter_from_socket(server, &iter, dw->len);
4762 server->total_read += rc;
4768 rc = cifs_discard_remaining_data(server);
4777 if ((server->min_offload) && (server->in_flight > 1) &&
4778 (server->pdu_size >= server->min_offload)) {
4779 dw->buf = server->smallbuf;
4780 server->smallbuf = (char *)cifs_small_buf_get();
4787 rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size,
4792 *mid = smb2_find_mid(server, buf);
4798 rc = handle_read_data(server, *mid, buf,
4799 server->vals->read_rsp_size,
4802 if (server->ops->is_network_name_deleted) {
4803 server->ops->is_network_name_deleted(buf,
4804 server);
4815 cifs_discard_remaining_data(server);
4820 receive_encrypted_standard(struct TCP_Server_Info *server,
4825 char *buf = server->smallbuf;
4827 unsigned int pdu_length = server->pdu_size;
4838 server->large_buf = true;
4839 memcpy(server->bigbuf, buf, server->total_read);
4840 buf = server->bigbuf;
4844 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
4845 pdu_length - HEADER_SIZE(server) + 1);
4848 server->total_read += length;
4851 length = decrypt_raw_data(server, buf, buf_size, NULL, false);
4855 next_is_large = server->large_buf;
4869 mid_entry = smb2_find_mid(server, buf);
4875 mid_entry->resp_buf_size = server->pdu_size;
4886 ret = mid_entry->handle(server, mid_entry);
4888 ret = cifs_handle_standard(server, mid_entry);
4892 server->large_buf = next_is_large;
4894 server->bigbuf = buf = next_buffer;
4896 server->smallbuf = buf = next_buffer;
4901 * server->smallbuf and server->bigbuf are still valid. We need
4915 smb3_receive_transform(struct TCP_Server_Info *server,
4918 char *buf = server->smallbuf;
4919 unsigned int pdu_length = server->pdu_size;
4927 cifs_reconnect(server, true);
4933 cifs_reconnect(server, true);
4938 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {
4939 return receive_encrypted_read(server, &mids[0], num_mids);
4942 return receive_encrypted_standard(server, mids, bufs, num_mids);
4946 smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid)
4948 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
4950 return handle_read_data(server, mid, buf, server->pdu_size,
4954 static int smb2_next_header(struct TCP_Server_Info *server, char *buf,
4967 if (unlikely(*noff && *noff < MID_HEADER_SIZE(server)))
4976 struct TCP_Server_Info *server = tcon->ses->server;
4984 __u32 oplock = server->oplocks ? REQ_OPLOCK : 0;
5010 rc = server->ops->open(xid, &oparms, &oplock, NULL);
5020 rc = server->ops->sync_write(xid, &fid, &io_parms,
5022 server->ops->close(xid, tcon, &fid);