Lines Matching defs:server
34 change_conf(struct TCP_Server_Info *server)
36 server->credits += server->echo_credits + server->oplock_credits;
37 if (server->credits > server->max_credits)
38 server->credits = server->max_credits;
39 server->oplock_credits = server->echo_credits = 0;
40 switch (server->credits) {
44 server->echoes = false;
45 server->oplocks = false;
48 server->echoes = true;
49 server->oplocks = false;
50 server->echo_credits = 1;
53 server->echoes = true;
55 server->oplocks = true;
56 server->oplock_credits = 1;
58 server->oplocks = false;
60 server->echo_credits = 1;
62 server->credits -= server->echo_credits + server->oplock_credits;
63 return server->credits + server->echo_credits + server->oplock_credits;
67 smb2_add_credits(struct TCP_Server_Info *server,
77 spin_lock(&server->req_lock);
78 val = server->ops->get_credits_field(server, optype);
84 if ((instance == 0) || (instance == server->reconnect_instance))
91 pr_warn_once("server overflowed SMB3 credits\n");
92 trace_smb3_overflow_credits(server->CurrentMid,
93 server->conn_id, server->hostname, *val,
94 add, server->in_flight);
96 WARN_ON_ONCE(server->in_flight == 0);
97 server->in_flight--;
98 if (server->in_flight == 0 &&
101 rc = change_conf(server);
103 * Sometimes server returns 0 credits on oplock break ack - we need to
106 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
107 server->oplocks) {
108 if (server->credits > 1) {
109 server->credits--;
110 server->oplock_credits++;
112 } else if ((server->in_flight > 0) && (server->oplock_credits > 3) &&
115 change_conf(server);
118 in_flight = server->in_flight;
119 spin_unlock(&server->req_lock);
120 wake_up(&server->request_q);
123 trace_smb3_reconnect_detected(server->CurrentMid,
124 server->conn_id, server->hostname, scredits, add, in_flight);
126 cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\n",
131 trace_smb3_reconnect_with_invalid_credits(server->CurrentMid,
132 server->conn_id, server->hostname, scredits, add, in_flight);
133 cifs_dbg(FYI, "Negotiate operation when server credits is non-zero. Optype: %d, server credits: %d, credits added: %d\n",
137 spin_lock(&server->srv_lock);
138 if (server->tcpStatus == CifsNeedReconnect
139 || server->tcpStatus == CifsExiting) {
140 spin_unlock(&server->srv_lock);
143 spin_unlock(&server->srv_lock);
150 cifs_server_dbg(VFS, "Possible client or server bug - zero credits\n");
163 trace_smb3_add_credits(server->CurrentMid,
164 server->conn_id, server->hostname, scredits, add, in_flight);
169 smb2_set_credits(struct TCP_Server_Info *server, const int val)
173 spin_lock(&server->req_lock);
174 server->credits = val;
176 server->reconnect_instance++;
181 if (SERVER_IS_CHAN(server))
182 server->primary_server->channel_sequence_num++;
184 server->channel_sequence_num++;
186 scredits = server->credits;
187 in_flight = server->in_flight;
188 spin_unlock(&server->req_lock);
190 trace_smb3_set_credits(server->CurrentMid,
191 server->conn_id, server->hostname, scredits, val, in_flight);
200 smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
204 return &server->echo_credits;
206 return &server->oplock_credits;
208 return &server->credits;
219 smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
225 spin_lock(&server->req_lock);
227 spin_unlock(&server->req_lock);
229 spin_lock(&server->srv_lock);
230 if (server->tcpStatus == CifsExiting) {
231 spin_unlock(&server->srv_lock);
234 spin_unlock(&server->srv_lock);
236 spin_lock(&server->req_lock);
237 if (server->credits <= 0) {
238 spin_unlock(&server->req_lock);
239 cifs_num_waiters_inc(server);
240 rc = wait_event_killable(server->request_q,
241 has_credits(server, &server->credits, 1));
242 cifs_num_waiters_dec(server);
245 spin_lock(&server->req_lock);
247 scredits = server->credits;
263 credits->instance = server->reconnect_instance;
264 server->credits -= credits->value;
265 server->in_flight++;
266 if (server->in_flight > server->max_in_flight)
267 server->max_in_flight = server->in_flight;
271 scredits = server->credits;
272 in_flight = server->in_flight;
273 spin_unlock(&server->req_lock);
275 trace_smb3_wait_credits(server->CurrentMid,
276 server->conn_id, server->hostname, scredits, -(credits->value), in_flight);
284 smb2_adjust_credits(struct TCP_Server_Info *server,
295 trace_smb3_too_many_credits(server->CurrentMid,
296 server->conn_id, server->hostname, 0, credits->value - new_val, 0);
303 spin_lock(&server->req_lock);
305 if (server->reconnect_instance != credits->instance) {
306 scredits = server->credits;
307 in_flight = server->in_flight;
308 spin_unlock(&server->req_lock);
310 trace_smb3_reconnect_detected(server->CurrentMid,
311 server->conn_id, server->hostname, scredits,
318 server->credits += credits->value - new_val;
319 scredits = server->credits;
320 in_flight = server->in_flight;
321 spin_unlock(&server->req_lock);
322 wake_up(&server->request_q);
324 trace_smb3_adj_credits(server->CurrentMid,
325 server->conn_id, server->hostname, scredits,
336 smb2_get_next_mid(struct TCP_Server_Info *server)
340 spin_lock(&server->mid_lock);
341 mid = server->CurrentMid++;
342 spin_unlock(&server->mid_lock);
347 smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
349 spin_lock(&server->mid_lock);
350 if (server->CurrentMid >= val)
351 server->CurrentMid -= val;
352 spin_unlock(&server->mid_lock);
356 __smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue)
367 spin_lock(&server->mid_lock);
368 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
377 spin_unlock(&server->mid_lock);
381 spin_unlock(&server->mid_lock);
386 smb2_find_mid(struct TCP_Server_Info *server, char *buf)
388 return __smb2_find_mid(server, buf, false);
392 smb2_find_dequeue_mid(struct TCP_Server_Info *server, char *buf)
394 return __smb2_find_mid(server, buf, true);
398 smb2_dump_detail(void *buf, struct TCP_Server_Info *server)
406 if (!server->ops->check_message(buf, server->total_read, server)) {
408 server->ops->calc_smb_size(buf));
414 smb2_need_neg(struct TCP_Server_Info *server)
416 return server->max_read == 0;
422 struct TCP_Server_Info *server)
426 spin_lock(&server->mid_lock);
427 server->CurrentMid = 0;
428 spin_unlock(&server->mid_lock);
429 rc = SMB2_negotiate(xid, ses, server);
439 struct TCP_Server_Info *server = tcon->ses->server;
444 wsize = min_t(unsigned int, wsize, server->max_write);
445 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
454 struct TCP_Server_Info *server = tcon->ses->server;
459 wsize = min_t(unsigned int, wsize, server->max_write);
461 if (server->rdma) {
462 if (server->sign)
469 server->smbd_conn->max_fragmented_send_size -
474 wsize, server->smbd_conn->max_readwrite_size);
477 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
486 struct TCP_Server_Info *server = tcon->ses->server;
491 rsize = min_t(unsigned int, rsize, server->max_read);
493 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
502 struct TCP_Server_Info *server = tcon->ses->server;
507 rsize = min_t(unsigned int, rsize, server->max_read);
509 if (server->rdma) {
510 if (server->sign)
517 server->smbd_conn->max_fragmented_recv_size -
522 rsize, server->smbd_conn->max_readwrite_size);
526 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
607 * Samba server e.g. can return an empty interface list in some cases,
615 "Empty network interface list returned by server %s\n",
616 ses->server->hostname);
778 "server does not support query network interfaces\n");
791 pserver = ses->chans[0].server;
1111 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1147 if (ses->server->ops->query_all_EAs) {
1149 rc = ses->server->ops->query_all_EAs(xid, tcon, path,
1202 rc = SMB2_open_init(tcon, server,
1228 rc = SMB2_set_info_init(tcon, server,
1241 rc = SMB2_close_init(tcon, server,
1247 rc = compound_send_recv(xid, ses, server,
1268 smb2_can_echo(struct TCP_Server_Info *server)
1270 return server->echoes;
1330 seq_printf(m, "\nOpen files: %d total (local), %d open on server",
1381 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1389 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
1487 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1522 if (!ses || !server) {
1570 rc = SMB2_open_init(tcon, server,
1578 /* Can eventually relax perm check since server enforces too */
1586 rc = SMB2_ioctl_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1592 /* Can eventually relax perm check since server enforces too */
1608 rc = SMB2_set_info_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1616 rc = SMB2_query_info_init(tcon, server,
1638 rc = SMB2_close_init(tcon, server,
1644 rc = compound_send_recv(xid, ses, server,
1727 /* Request a key from the server to identify the source of the copy */
1749 /* Request server copy to target from src identified by key */
1769 * Check if server claimed to write more than we asked
1806 * and check if the server gave us different sizes after
1808 * if not then why is the server returning an error now
1813 /* Check that server is not asking us to grow size */
1819 goto cchunk_out; /* server gave us bogus size */
1903 * since Samba server doesn't set the flag on the share, yet
1906 * mark that server does not support sparse files for this share
1907 * to avoid repeatedly sending the unsupported fsctl to server
1966 /* server fileays advertise duplicate extent support with this flag */
2231 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
2259 rc = SMB2_open_init(tcon, server,
2273 rc = SMB2_query_directory_init(xid, tcon, server,
2283 rc = compound_send_recv(xid, tcon->ses, server,
2361 smb2_is_status_pending(char *buf, struct TCP_Server_Info *server)
2370 spin_lock(&server->req_lock);
2371 server->credits += le16_to_cpu(shdr->CreditRequest);
2372 scredits = server->credits;
2373 in_flight = server->in_flight;
2374 spin_unlock(&server->req_lock);
2375 wake_up(&server->request_q);
2377 trace_smb3_pend_credits(server->CurrentMid,
2378 server->conn_id, server->hostname, scredits,
2417 smb2_is_network_name_deleted(char *buf, struct TCP_Server_Info *server)
2427 /* If server is a channel, select the primary channel */
2428 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
2453 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
2481 struct TCP_Server_Info *server = ses->server;
2482 unsigned long len = smb_rqst_len(server, rqst);
2546 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2595 rc = SMB2_open_init(tcon, server,
2605 rc = SMB2_query_info_init(tcon, server,
2613 rc = SMB2_query_info_init(tcon, server,
2631 rc = SMB2_close_init(tcon, server,
2638 rc = compound_send_recv(xid, ses, server,
2642 rc = compound_send_recv(xid, ses, server,
2650 pr_warn_once("server share %s deleted\n",
3009 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
3052 rc = SMB2_open_init(tcon, server,
3063 rc = SMB2_ioctl_init(tcon, server,
3079 rc = SMB2_close_init(tcon, server,
3086 rc = compound_send_recv(xid, tcon->ses, server,
3288 /* Retrieve an ACL from the server */
3347 * first, otherwise the data may be inconsistent with the server.
3410 * caches first, otherwise the data may be inconsistent with the server.
3808 * might fill holes on the server.
3968 smb2_downgrade_oplock(struct TCP_Server_Info *server,
3972 server->ops->set_oplock_level(cinode, oplock, 0, NULL);
3980 smb3_downgrade_oplock(struct TCP_Server_Info *server,
4039 /* Check if the server granted an oplock rather than a lease */
4319 smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key)
4325 /* If server is a channel, select the primary channel */
4326 pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
4354 crypt_message(struct TCP_Server_Info *server, int num_rqst,
4372 rc = smb2_get_enc_key(server, le64_to_cpu(tr_hdr->SessionId), enc, key);
4379 rc = smb3_crypto_aead_allocate(server);
4385 tfm = enc ? server->secmech.enc : server->secmech.dec;
4387 if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
4388 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4414 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
4415 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4480 smb3_init_transform_rq(struct TCP_Server_Info *server, int num_rqst,
4495 orig_len += smb_rqst_len(server, old);
4535 fill_transform_hdr(tr_hdr, orig_len, old_rq, server->cipher_type);
4537 rc = crypt_message(server, num_rqst, new_rq, 1);
4558 decrypt_raw_data(struct TCP_Server_Info *server, char *buf,
4580 rc = crypt_message(server, 1, &rqst, 0);
4589 server->total_read = buf_data_size + iter_size;
4617 handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,
4636 if (server->ops->is_session_expired &&
4637 server->ops->is_session_expired(buf)) {
4639 cifs_reconnect(server, true);
4643 if (server->ops->is_status_pending &&
4644 server->ops->is_status_pending(buf, server))
4652 min_t(unsigned int, buf_len, server->vals->read_rsp_size);
4658 rdata->result = server->ops->map_error(buf, true);
4660 cifs_dbg(FYI, "%s: server returned error %d\n",
4670 data_offset = server->ops->read_data_offset(buf);
4674 data_len = server->ops->read_data_length(buf, use_rdma_mr);
4676 if (data_offset < server->vals->read_rsp_size) {
4684 data_offset = server->vals->read_rsp_size;
4697 pad_len = data_offset - server->vals->read_rsp_size;
4766 struct TCP_Server_Info *server;
4782 rc = decrypt_raw_data(dw->server, dw->buf, dw->server->vals->read_rsp_size,
4789 dw->server->lstrp = jiffies;
4790 mid = smb2_find_dequeue_mid(dw->server, dw->buf);
4795 rc = handle_read_data(dw->server, mid, dw->buf,
4796 dw->server->vals->read_rsp_size,
4803 if (dw->server->ops->is_network_name_deleted)
4804 dw->server->ops->is_network_name_deleted(dw->buf,
4805 dw->server);
4809 spin_lock(&dw->server->srv_lock);
4810 if (dw->server->tcpStatus == CifsNeedReconnect) {
4811 spin_lock(&dw->server->mid_lock);
4813 spin_unlock(&dw->server->mid_lock);
4814 spin_unlock(&dw->server->srv_lock);
4817 spin_lock(&dw->server->mid_lock);
4821 &dw->server->pending_mid_q);
4822 spin_unlock(&dw->server->mid_lock);
4823 spin_unlock(&dw->server->srv_lock);
4837 receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid,
4841 char *buf = server->smallbuf;
4845 unsigned int buflen = server->pdu_size;
4855 dw->server = server;
4858 len = min_t(unsigned int, buflen, server->vals->read_rsp_size +
4859 sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1;
4861 rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len);
4864 server->total_read += rc;
4867 server->vals->read_rsp_size;
4891 rc = cifs_read_iter_from_socket(server, &iter, dw->len);
4895 server->total_read += rc;
4901 rc = cifs_discard_remaining_data(server);
4910 if ((server->min_offload) && (server->in_flight > 1) &&
4911 (server->pdu_size >= server->min_offload)) {
4912 dw->buf = server->smallbuf;
4913 server->smallbuf = (char *)cifs_small_buf_get();
4920 rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size,
4925 *mid = smb2_find_mid(server, buf);
4931 rc = handle_read_data(server, *mid, buf,
4932 server->vals->read_rsp_size,
4935 if (server->ops->is_network_name_deleted) {
4936 server->ops->is_network_name_deleted(buf,
4937 server);
4948 cifs_discard_remaining_data(server);
4953 receive_encrypted_standard(struct TCP_Server_Info *server,
4958 char *buf = server->smallbuf;
4960 unsigned int pdu_length = server->pdu_size;
4971 server->large_buf = true;
4972 memcpy(server->bigbuf, buf, server->total_read);
4973 buf = server->bigbuf;
4977 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
4978 pdu_length - HEADER_SIZE(server) + 1);
4981 server->total_read += length;
4984 length = decrypt_raw_data(server, buf, buf_size, NULL, false);
4988 next_is_large = server->large_buf;
5002 mid_entry = smb2_find_mid(server, buf);
5008 mid_entry->resp_buf_size = server->pdu_size;
5019 ret = mid_entry->handle(server, mid_entry);
5021 ret = cifs_handle_standard(server, mid_entry);
5025 server->large_buf = next_is_large;
5027 server->bigbuf = buf = next_buffer;
5029 server->smallbuf = buf = next_buffer;
5034 * server->smallbuf and server->bigbuf are still valid. We need
5048 smb3_receive_transform(struct TCP_Server_Info *server,
5051 char *buf = server->smallbuf;
5052 unsigned int pdu_length = server->pdu_size;
5060 cifs_reconnect(server, true);
5066 cifs_reconnect(server, true);
5071 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {
5072 return receive_encrypted_read(server, &mids[0], num_mids);
5075 return receive_encrypted_standard(server, mids, bufs, num_mids);
5079 smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid)
5081 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
5083 return handle_read_data(server, mid, buf, server->pdu_size,
5087 static int smb2_next_header(struct TCP_Server_Info *server, char *buf,
5100 if (unlikely(*noff && *noff < MID_HEADER_SIZE(server)))
5132 * their current NFS server) uses this approach to expose special files
5152 if (tcon->ses->server->oplocks)
5156 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, &buf);
5176 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5182 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5188 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5191 tcon->ses->server->ops->close(xid, tcon, &fid);