Lines Matching defs:server
30 change_conf(struct TCP_Server_Info *server)
32 server->credits += server->echo_credits + server->oplock_credits;
33 server->oplock_credits = server->echo_credits = 0;
34 switch (server->credits) {
38 server->echoes = false;
39 server->oplocks = false;
42 server->echoes = true;
43 server->oplocks = false;
44 server->echo_credits = 1;
47 server->echoes = true;
49 server->oplocks = true;
50 server->oplock_credits = 1;
52 server->oplocks = false;
54 server->echo_credits = 1;
56 server->credits -= server->echo_credits + server->oplock_credits;
57 return server->credits + server->echo_credits + server->oplock_credits;
61 smb2_add_credits(struct TCP_Server_Info *server,
69 spin_lock(&server->req_lock);
70 val = server->ops->get_credits_field(server, optype);
74 trace_smb3_reconnect_with_invalid_credits(server->CurrentMid,
75 server->hostname, *val, add);
76 if ((instance == 0) || (instance == server->reconnect_instance))
83 pr_warn_once("server overflowed SMB3 credits\n");
85 server->in_flight--;
86 if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
87 rc = change_conf(server);
89 * Sometimes server returns 0 credits on oplock break ack - we need to
92 else if (server->in_flight > 0 && server->oplock_credits == 0 &&
93 server->oplocks) {
94 if (server->credits > 1) {
95 server->credits--;
96 server->oplock_credits++;
99 spin_unlock(&server->req_lock);
100 wake_up(&server->request_q);
103 cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\n",
106 if (server->tcpStatus == CifsNeedReconnect
107 || server->tcpStatus == CifsExiting)
115 cifs_server_dbg(VFS, "Possible client or server bug - zero credits\n");
124 trace_smb3_add_credits(server->CurrentMid,
125 server->hostname, rc, add);
131 smb2_set_credits(struct TCP_Server_Info *server, const int val)
133 spin_lock(&server->req_lock);
134 server->credits = val;
136 server->reconnect_instance++;
137 spin_unlock(&server->req_lock);
144 smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
148 return &server->echo_credits;
150 return &server->oplock_credits;
152 return &server->credits;
163 smb2_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
169 spin_lock(&server->req_lock);
171 if (server->credits <= 0) {
172 spin_unlock(&server->req_lock);
173 cifs_num_waiters_inc(server);
174 rc = wait_event_killable(server->request_q,
175 has_credits(server, &server->credits, 1));
176 cifs_num_waiters_dec(server);
179 spin_lock(&server->req_lock);
181 if (server->tcpStatus == CifsExiting) {
182 spin_unlock(&server->req_lock);
186 scredits = server->credits;
202 credits->instance = server->reconnect_instance;
203 server->credits -= credits->value;
204 server->in_flight++;
205 if (server->in_flight > server->max_in_flight)
206 server->max_in_flight = server->in_flight;
210 spin_unlock(&server->req_lock);
215 smb2_adjust_credits(struct TCP_Server_Info *server,
230 spin_lock(&server->req_lock);
232 if (server->reconnect_instance != credits->instance) {
233 spin_unlock(&server->req_lock);
239 server->credits += credits->value - new_val;
240 spin_unlock(&server->req_lock);
241 wake_up(&server->request_q);
247 smb2_get_next_mid(struct TCP_Server_Info *server)
252 mid = server->CurrentMid++;
258 smb2_revert_current_mid(struct TCP_Server_Info *server, const unsigned int val)
261 if (server->CurrentMid >= val)
262 server->CurrentMid -= val;
267 __smb2_find_mid(struct TCP_Server_Info *server, char *buf, bool dequeue)
279 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
297 smb2_find_mid(struct TCP_Server_Info *server, char *buf)
299 return __smb2_find_mid(server, buf, false);
303 smb2_find_dequeue_mid(struct TCP_Server_Info *server, char *buf)
305 return __smb2_find_mid(server, buf, true);
309 smb2_dump_detail(void *buf, struct TCP_Server_Info *server)
318 server->ops->calc_smb_size(buf, server));
323 smb2_need_neg(struct TCP_Server_Info *server)
325 return server->max_read == 0;
344 struct TCP_Server_Info *server = tcon->ses->server;
349 wsize = min_t(unsigned int, wsize, server->max_write);
350 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
359 struct TCP_Server_Info *server = tcon->ses->server;
364 wsize = min_t(unsigned int, wsize, server->max_write);
366 if (server->rdma) {
367 if (server->sign)
374 server->smbd_conn->max_fragmented_send_size -
379 wsize, server->smbd_conn->max_readwrite_size);
382 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
391 struct TCP_Server_Info *server = tcon->ses->server;
396 rsize = min_t(unsigned int, rsize, server->max_read);
398 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
407 struct TCP_Server_Info *server = tcon->ses->server;
412 rsize = min_t(unsigned int, rsize, server->max_read);
414 if (server->rdma) {
415 if (server->sign)
422 server->smbd_conn->max_fragmented_recv_size -
427 rsize, server->smbd_conn->max_readwrite_size);
431 if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
595 "server does not support query network interfaces\n");
677 struct TCP_Server_Info *server = ses->server;
712 if (!server->ops->new_lease_key)
716 server->ops->new_lease_key(pfid);
734 rc = SMB2_open_init(tcon, server,
744 rc = SMB2_query_info_init(tcon, server,
755 rc = compound_send_recv(xid, ses, server,
797 pr_warn_once("server share %s deleted\n",
821 smb2_parse_contexts(server, o_rsp,
1139 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1173 if (ses->server->ops->query_all_EAs) {
1175 rc = ses->server->ops->query_all_EAs(xid, tcon, path,
1228 rc = SMB2_open_init(tcon, server,
1255 rc = SMB2_set_info_init(tcon, server,
1270 rc = SMB2_close_init(tcon, server,
1276 rc = compound_send_recv(xid, ses, server,
1295 smb2_can_echo(struct TCP_Server_Info *server)
1297 return server->echoes;
1357 seq_printf(m, "\nOpen files: %d total (local), %d open on server",
1408 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1416 server->ops->set_oplock_level(cinode, oplock, fid->epoch,
1518 struct TCP_Server_Info *server = cifs_pick_channel(ses);
1553 if (!ses || !server) {
1601 rc = SMB2_open_init(tcon, server,
1609 /* Can eventually relax perm check since server enforces too */
1617 rc = SMB2_ioctl_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1623 /* Can eventually relax perm check since server enforces too */
1639 rc = SMB2_set_info_init(tcon, server, &rqst[1], COMPOUND_FID, COMPOUND_FID,
1647 rc = SMB2_query_info_init(tcon, server,
1669 rc = SMB2_close_init(tcon, server,
1675 rc = compound_send_recv(xid, ses, server,
1758 * copychunk ioctl to the 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
2006 /* server fileays advertise duplicate extent support with this flag */
2247 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
2272 rc = SMB2_open_init(tcon, server,
2286 rc = SMB2_query_directory_init(xid, tcon, server,
2295 rc = compound_send_recv(xid, tcon->ses, server,
2370 smb2_is_status_pending(char *buf, struct TCP_Server_Info *server)
2378 spin_lock(&server->req_lock);
2379 server->credits += le16_to_cpu(shdr->CreditRequest);
2380 spin_unlock(&server->req_lock);
2381 wake_up(&server->request_q);
2419 if (tcon->ses->server->capabilities & SMB2_GLOBAL_CAP_LEASING)
2448 struct TCP_Server_Info *server = ses->server;
2449 unsigned long len = smb_rqst_len(server, rqst);
2512 struct TCP_Server_Info *server = cifs_pick_channel(ses);
2543 rc = SMB2_open_init(tcon, server,
2553 rc = SMB2_query_info_init(tcon, server,
2567 rc = SMB2_close_init(tcon, server,
2573 rc = compound_send_recv(xid, ses, server,
2580 pr_warn_once("server share %s deleted\n",
2907 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
2953 rc = SMB2_open_init(tcon, server,
2965 rc = SMB2_ioctl_init(tcon, server,
2983 rc = SMB2_close_init(tcon, server,
2990 rc = compound_send_recv(xid, tcon->ses, server,
3092 struct TCP_Server_Info *server = cifs_pick_channel(tcon->ses);
3133 rc = SMB2_open_init(tcon, server,
3145 rc = SMB2_ioctl_init(tcon, server,
3163 rc = SMB2_close_init(tcon, server,
3170 rc = compound_send_recv(xid, tcon->ses, server,
3355 /* Retrieve an ACL from the server */
3396 * first, otherwise the data may be inconsistent with the server.
3465 * caches first, otherwise the data may be inconsistent with the server.
3755 * might fill holes on the server.
3911 smb2_downgrade_oplock(struct TCP_Server_Info *server,
3915 server->ops->set_oplock_level(cinode, oplock, 0, NULL);
3923 smb3_downgrade_oplock(struct TCP_Server_Info *server,
3980 /* Check if the server granted an oplock rather than a lease */
4255 smb2_get_enc_key(struct TCP_Server_Info *server, __u64 ses_id, int enc, u8 *key)
4261 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
4262 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
4284 crypt_message(struct TCP_Server_Info *server, int num_rqst,
4301 rc = smb2_get_enc_key(server, tr_hdr->SessionId, enc, key);
4308 rc = smb3_crypto_aead_allocate(server);
4314 tfm = enc ? server->secmech.ccmaesencrypt :
4315 server->secmech.ccmaesdecrypt;
4317 if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
4318 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4343 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
4344 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
4396 smb3_init_transform_rq(struct TCP_Server_Info *server, int num_rqst,
4421 orig_len += smb_rqst_len(server, &old_rq[i - 1]);
4446 fill_transform_hdr(tr_hdr, orig_len, old_rq, server->cipher_type);
4448 rc = crypt_message(server, num_rqst, new_rq, 1);
4469 decrypt_raw_data(struct TCP_Server_Info *server, char *buf,
4490 rc = crypt_message(server, 1, &rqst, 0);
4499 server->total_read = buf_data_size + page_data_size;
4505 read_data_into_pages(struct TCP_Server_Info *server, struct page **pages,
4524 length = cifs_read_page_from_socket(server, page, 0, n);
4527 server->total_read += length;
4562 handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid,
4585 if (server->ops->is_session_expired &&
4586 server->ops->is_session_expired(buf)) {
4588 cifs_reconnect(server);
4592 if (server->ops->is_status_pending &&
4593 server->ops->is_status_pending(buf, server))
4601 min_t(unsigned int, buf_len, server->vals->read_rsp_size);
4607 rdata->result = server->ops->map_error(buf, true);
4609 cifs_dbg(FYI, "%s: server returned error %d\n",
4619 data_offset = server->ops->read_data_offset(buf);
4623 data_len = server->ops->read_data_length(buf, use_rdma_mr);
4625 if (data_offset < server->vals->read_rsp_size) {
4633 data_offset = server->vals->read_rsp_size;
4646 pad_len = data_offset - server->vals->read_rsp_size;
4703 length = rdata->copy_into_pages(server, rdata, &iter);
4719 struct TCP_Server_Info *server;
4734 rc = decrypt_raw_data(dw->server, dw->buf, dw->server->vals->read_rsp_size,
4741 dw->server->lstrp = jiffies;
4742 mid = smb2_find_dequeue_mid(dw->server, dw->buf);
4747 rc = handle_read_data(dw->server, mid, dw->buf,
4748 dw->server->vals->read_rsp_size,
4758 if (dw->server->tcpStatus == CifsNeedReconnect) {
4766 &dw->server->pending_mid_q);
4784 receive_encrypted_read(struct TCP_Server_Info *server, struct mid_q_entry **mid,
4787 char *buf = server->smallbuf;
4792 unsigned int buflen = server->pdu_size;
4798 len = min_t(unsigned int, buflen, server->vals->read_rsp_size +
4799 sizeof(struct smb2_transform_hdr)) - HEADER_SIZE(server) + 1;
4801 rc = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, len);
4804 server->total_read += rc;
4807 server->vals->read_rsp_size;
4825 rc = read_data_into_pages(server, pages, npages, len);
4829 rc = cifs_discard_remaining_data(server);
4838 if ((server->min_offload) && (server->in_flight > 1) &&
4839 (server->pdu_size >= server->min_offload)) {
4844 dw->buf = server->smallbuf;
4845 server->smallbuf = (char *)cifs_small_buf_get();
4850 dw->server = server;
4859 rc = decrypt_raw_data(server, buf, server->vals->read_rsp_size,
4864 *mid = smb2_find_mid(server, buf);
4870 rc = handle_read_data(server, *mid, buf,
4871 server->vals->read_rsp_size,
4881 cifs_discard_remaining_data(server);
4886 receive_encrypted_standard(struct TCP_Server_Info *server,
4891 char *buf = server->smallbuf;
4893 unsigned int pdu_length = server->pdu_size;
4903 server->large_buf = true;
4904 memcpy(server->bigbuf, buf, server->total_read);
4905 buf = server->bigbuf;
4909 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
4910 pdu_length - HEADER_SIZE(server) + 1);
4913 server->total_read += length;
4916 length = decrypt_raw_data(server, buf, buf_size, NULL, 0, 0, false);
4920 next_is_large = server->large_buf;
4933 mid_entry = smb2_find_mid(server, buf);
4939 mid_entry->resp_buf_size = server->pdu_size;
4950 ret = mid_entry->handle(server, mid_entry);
4952 ret = cifs_handle_standard(server, mid_entry);
4956 server->large_buf = next_is_large;
4958 server->bigbuf = buf = next_buffer;
4960 server->smallbuf = buf = next_buffer;
4965 * server->smallbuf and server->bigbuf are still valid. We need
4979 smb3_receive_transform(struct TCP_Server_Info *server,
4982 char *buf = server->smallbuf;
4983 unsigned int pdu_length = server->pdu_size;
4991 cifs_reconnect(server);
4997 cifs_reconnect(server);
5002 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server)) {
5003 return receive_encrypted_read(server, &mids[0], num_mids);
5006 return receive_encrypted_standard(server, mids, bufs, num_mids);
5010 smb3_handle_read_data(struct TCP_Server_Info *server, struct mid_q_entry *mid)
5012 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
5014 return handle_read_data(server, mid, buf, server->pdu_size,
5058 * their current NFS server) uses this approach to expose special files
5083 if (tcon->ses->server->oplocks)
5087 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
5107 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5113 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
5116 tcon->ses->server->ops->close(xid, tcon, &fid);