@@ -136,7 +136,7 @@ cifs_dump_channel(struct seq_file *m, int i, struct cifs_chan *chan)
i+1, server->conn_id,
server->credits,
server->dialect,
- server->tcpStatus,
+ server->status,
server->reconnect_instance,
server->srv_count,
server->sec_mode,
@@ -364,7 +364,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
seq_printf(m, "\nRDMA ");
seq_printf(m, "\nTCP status: %d Instance: %d"
"\nLocal Users To Server: %d SecMode: 0x%x Req On Wire: %d",
- server->tcpStatus,
+ server->status,
server->reconnect_instance,
server->srv_count,
server->sec_mode, in_flight(server));
@@ -143,7 +143,7 @@ int cifs_sign_rqst(struct smb_rqst *rqst, struct cifs_server_info *server,
spin_lock(&g_servers_lock);
if (!(cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) ||
- server->tcpStatus == CifsNeedNegotiate) {
+ server->status == CifsNeedNegotiate) {
spin_unlock(&g_servers_lock);
return rc;
}
@@ -608,11 +608,11 @@ struct cifs_server_info {
__u64 conn_id; /* connection identifier (useful for debugging) */
int srv_count; /* reference counter */
/* 15 character server name + 0x20 16th byte indicating type = srv */
- char server_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
+ char server_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL];
struct smb_version_operations *ops;
struct smb_version_values *vals;
- /* updates to tcpStatus protected by g_servers_lock */
- enum statusEnum tcpStatus; /* what we think the status is */
+ /* updates to status protected by g_servers_lock */
+ enum statusEnum status; /* what we think the status is */
char *hostname; /* hostname portion of UNC string */
struct socket *ssocket;
struct sockaddr_storage dstaddr;
@@ -635,7 +635,7 @@ struct cifs_server_info {
struct mutex _srv_mutex;
unsigned int nofs_flag;
struct task_struct *tsk;
- char server_GUID[16];
+ char server_guid[16];
__u16 sec_mode;
bool sign; /* is signing enabled on this connection? */
bool ignore_signature:1; /* skip validation of signatures in SMB2/3 rsp */
@@ -646,19 +646,19 @@ struct cifs_server_info {
__u8 client_guid[SMB2_CLIENT_GUID_SIZE]; /* Client GUID */
u16 dialect; /* dialect index that server chose */
bool oplocks:1; /* enable oplocks */
- unsigned int maxReq; /* Clients should submit no more */
- /* than maxReq distinct unanswered SMBs to the server when using */
+ unsigned int max_req; /* Clients should submit no more */
+ /* than max_req distinct unanswered SMBs to the server when using */
/* multiplexed reads or writes (for SMB1/CIFS only, not SMB2/SMB3) */
- unsigned int maxBuf; /* maxBuf specifies the maximum */
+ unsigned int max_buf; /* max_buf specifies the maximum */
/* message size the server can send or receive for non-raw SMBs */
- /* maxBuf is returned by SMB NegotiateProtocol so maxBuf is only 0 */
+ /* max_buf is returned by SMB NegotiateProtocol so max_buf is only 0 */
/* when socket is setup (and during reconnect) before NegProt sent */
unsigned int max_rw; /* maxRw specifies the maximum */
/* message size the server can send or receive for */
/* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */
unsigned int capabilities; /* selective disabling of caps by smb sess */
- int timeAdj; /* Adjust for difference in server time zone in sec */
- __u64 CurrentMid; /* multiplex id - rotating counter, protected by g_mid_lock */
+ int time_adjust; /* Adjust for difference in server time zone in sec */
+ __u64 current_mid; /* multiplex id - rotating counter, protected by g_mid_lock */
char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */
/* 16th byte of RFC1001 workstation name is always null */
char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];
@@ -1908,8 +1908,8 @@ require use of the stronger protocol */
* list operations on pending_mid_q and oplockQ
* updates to XID counters, multiplex id and SMB sequence numbers
* list operations on global DnotifyReqList
- * updates to ses->status and cifs_server_info->tcpStatus
- * updates to server->CurrentMid
+ * updates to ses->status and cifs_server_info->status
+ * updates to server->current_mid
* g_servers_lock protects:
* list operations on tcp and SMB session lists
* tcon->open_file_lock protects the list of open files hanging off the tcon
@@ -79,9 +79,9 @@ extern char *cifs_compose_mount_options(const char *sb_mountdata,
const char *fullpath, const struct dfs_info3_param *ref,
char **devname);
/* extern void renew_parental_timestamps(struct dentry *direntry);*/
-extern struct mid_q_entry *AllocMidQEntry(const struct smb_hdr *smb_buffer,
+extern struct mid_q_entry *cifs_alloc_mid_q_entry(const struct smb_hdr *smb_buffer,
struct cifs_server_info *server);
-extern void DeleteMidQEntry(struct mid_q_entry *midEntry);
+extern void cifs_delete_mid_q_entry(struct mid_q_entry *midEntry);
extern void cifs_delete_mid(struct mid_q_entry *mid);
extern void cifs_mid_q_entry_release(struct mid_q_entry *midEntry);
extern void cifs_wake_up_task(struct mid_q_entry *mid);
@@ -154,9 +154,9 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
* reconnect -- should be greater than cifs socket timeout which is 7
* seconds.
*/
- while (server->tcpStatus == CifsNeedReconnect) {
+ while (server->status == CifsNeedReconnect) {
rc = wait_event_interruptible_timeout(server->response_q,
- (server->tcpStatus != CifsNeedReconnect),
+ (server->status != CifsNeedReconnect),
10 * HZ);
if (rc < 0) {
cifs_dbg(FYI, "%s: aborting reconnect due to a received signal by the process\n",
@@ -166,7 +166,7 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
/* are we still trying to reconnect? */
spin_lock(&g_servers_lock);
- if (server->tcpStatus != CifsNeedReconnect) {
+ if (server->status != CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
break;
}
@@ -199,10 +199,10 @@ cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
/*
* Recheck after acquire mutex. If another thread is negotiating
* and the server never sends an answer the socket will be closed
- * and tcpStatus set to reconnect.
+ * and status set to reconnect.
*/
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedReconnect) {
+ if (server->status == CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
rc = -EHOSTDOWN;
goto out;
@@ -435,13 +435,13 @@ decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
spin_lock(&g_servers_lock);
if (server->srv_count > 1) {
spin_unlock(&g_servers_lock);
- if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
+ if (memcmp(server->server_guid, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
cifs_dbg(FYI, "server UID changed\n");
- memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
+ memcpy(server->server_guid, guid, SMB1_CLIENT_GUID_SIZE);
}
} else {
spin_unlock(&g_servers_lock);
- memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
+ memcpy(server->server_guid, guid, SMB1_CLIENT_GUID_SIZE);
}
if (count == SMB1_CLIENT_GUID_SIZE) {
@@ -591,18 +591,18 @@ CIFSSMBNegotiate(const unsigned int xid,
/* one byte, so no need to convert this or EncryptionKeyLen from
little endian */
- server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
+ server->max_req = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
cifs_max_pending);
- set_credits(server, server->maxReq);
+ set_credits(server, server->max_req);
/* probably no need to store and check maxvcs */
- server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
+ server->max_buf = le32_to_cpu(pSMBr->MaxBufferSize);
/* set up max_read for readahead check */
- server->max_read = server->maxBuf;
+ server->max_read = server->max_buf;
server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
- cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
+ cifs_dbg(NOISY, "Max buf = %d\n", ses->server->max_buf);
server->capabilities = le32_to_cpu(pSMBr->Capabilities);
- server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
- server->timeAdj *= 60;
+ server->time_adjust = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
+ server->time_adjust *= 60;
if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
@@ -684,7 +684,7 @@ cifs_echo_callback(struct mid_q_entry *mid)
struct cifs_server_info *server = mid->callback_data;
struct cifs_credits credits = { .value = 1, .instance = 0 };
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(server, &credits, CIFS_ECHO_OP);
}
@@ -1607,7 +1607,7 @@ cifs_readv_callback(struct mid_q_entry *mid)
}
queue_work(cifsiod_wq, &rdata->work);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(server, &credits, 0);
}
@@ -1849,7 +1849,7 @@ CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
} else {
- bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
+ bytes_sent = (tcon->ses->server->max_buf - MAX_CIFS_HDR_SIZE)
& ~0xFF;
}
@@ -2132,7 +2132,7 @@ cifs_writev_callback(struct mid_q_entry *mid)
}
queue_work(cifsiod_wq, &wdata->work);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(tcon->ses->server, &credits, 0);
}
@@ -186,7 +186,7 @@ static void cifs_resolve_server(struct work_struct *work)
}
/*
- * Update the tcpStatus for the server.
+ * Update the status for the server.
* This is used to signal the cifsd thread to call cifs_reconnect
* ONLY cifsd thread should call cifs_reconnect. For any other
* thread, use this function
@@ -207,7 +207,7 @@ cifs_signal_cifsd_for_reconnect(struct cifs_server_info *server,
spin_lock(&g_servers_lock);
if (!all_channels) {
- pserver->tcpStatus = CifsNeedReconnect;
+ pserver->status = CifsNeedReconnect;
spin_unlock(&g_servers_lock);
return;
}
@@ -215,7 +215,7 @@ cifs_signal_cifsd_for_reconnect(struct cifs_server_info *server,
list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
spin_lock(&ses->chan_lock);
for (i = 0; i < ses->chan_count; i++)
- ses->chans[i].server->tcpStatus = CifsNeedReconnect;
+ ses->chans[i].server->status = CifsNeedReconnect;
spin_unlock(&ses->chan_lock);
}
spin_unlock(&g_servers_lock);
@@ -298,7 +298,7 @@ cifs_abort_connection(struct cifs_server_info *server)
struct mid_q_entry *mid, *nmid;
struct list_head retry_list;
- server->maxBuf = 0;
+ server->max_buf = 0;
server->max_read = 0;
/* do not want to be sending data on a socket we are freeing */
@@ -352,7 +352,7 @@ static bool cifs_server_needs_reconnect(struct cifs_server_info *server, int num
{
spin_lock(&g_servers_lock);
server->nr_targets = num_targets;
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
/* the demux thread will exit normally next time through the loop */
spin_unlock(&g_servers_lock);
wake_up(&server->response_q);
@@ -360,9 +360,9 @@ static bool cifs_server_needs_reconnect(struct cifs_server_info *server, int num
}
cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
- trace_smb3_reconnect(server->CurrentMid, server->conn_id,
+ trace_smb3_reconnect(server->current_mid, server->conn_id,
server->hostname);
- server->tcpStatus = CifsNeedReconnect;
+ server->status = CifsNeedReconnect;
spin_unlock(&g_servers_lock);
return true;
@@ -415,17 +415,17 @@ static int __cifs_reconnect(struct cifs_server_info *server,
atomic_inc(&g_server_reconnect_count);
set_credits(server, 1);
spin_lock(&g_servers_lock);
- if (server->tcpStatus != CifsExiting)
- server->tcpStatus = CifsNeedNegotiate;
+ if (server->status != CifsExiting)
+ server->status = CifsNeedNegotiate;
spin_unlock(&g_servers_lock);
cifs_swn_reset_server_dstaddr(server);
cifs_server_unlock(server);
mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
}
- } while (server->tcpStatus == CifsNeedReconnect);
+ } while (server->status == CifsNeedReconnect);
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedNegotiate)
+ if (server->status == CifsNeedNegotiate)
mod_delayed_work(cifsiod_wq, &server->echo, 0);
spin_unlock(&g_servers_lock);
@@ -542,13 +542,13 @@ static int reconnect_dfs_server(struct cifs_server_info *server)
atomic_inc(&g_server_reconnect_count);
set_credits(server, 1);
spin_lock(&g_servers_lock);
- if (server->tcpStatus != CifsExiting)
- server->tcpStatus = CifsNeedNegotiate;
+ if (server->status != CifsExiting)
+ server->status = CifsNeedNegotiate;
spin_unlock(&g_servers_lock);
cifs_swn_reset_server_dstaddr(server);
cifs_server_unlock(server);
mod_delayed_work(cifsiod_wq, &server->reconnect, 0);
- } while (server->tcpStatus == CifsNeedReconnect);
+ } while (server->status == CifsNeedReconnect);
if (target_hint)
dfs_cache_noreq_update_tgthint(refpath, target_hint);
@@ -557,7 +557,7 @@ static int reconnect_dfs_server(struct cifs_server_info *server)
/* Need to set up echo worker again once connection has been established */
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedNegotiate)
+ if (server->status == CifsNeedNegotiate)
mod_delayed_work(cifsiod_wq, &server->echo, 0);
spin_unlock(&g_servers_lock);
@@ -604,9 +604,9 @@ cifs_echo_request(struct work_struct *work)
* Also, no need to ping if we got a response recently.
*/
- if (server->tcpStatus == CifsNeedReconnect ||
- server->tcpStatus == CifsExiting ||
- server->tcpStatus == CifsNew ||
+ if (server->status == CifsNeedReconnect ||
+ server->status == CifsExiting ||
+ server->status == CifsNew ||
(server->ops->can_echo && !server->ops->can_echo(server)) ||
time_before(jiffies, server->lstrp + server->echo_interval - HZ))
goto requeue_echo;
@@ -671,8 +671,8 @@ server_unresponsive(struct cifs_server_info *server)
* a response in >60s.
*/
spin_lock(&g_servers_lock);
- if ((server->tcpStatus == CifsGood ||
- server->tcpStatus == CifsNeedNegotiate) &&
+ if ((server->status == CifsGood ||
+ server->status == CifsNeedNegotiate) &&
(!server->ops->can_echo || server->ops->can_echo(server)) &&
time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
spin_unlock(&g_servers_lock);
@@ -727,12 +727,12 @@ cifs_readv_from_socket(struct cifs_server_info *server, struct msghdr *smb_msg)
length = sock_recvmsg(server->ssocket, smb_msg, 0);
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ESHUTDOWN;
}
- if (server->tcpStatus == CifsNeedReconnect) {
+ if (server->status == CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
cifs_reconnect(server, false);
return -ECONNABORTED;
@@ -744,7 +744,7 @@ cifs_readv_from_socket(struct cifs_server_info *server, struct msghdr *smb_msg)
length == -EINTR) {
/*
* Minimum sleep to prevent looping, allowing socket
- * to clear and app threads to set tcpStatus
+ * to clear and app threads to set status
* CifsNeedReconnect if server hung.
*/
usleep_range(1000, 2000);
@@ -916,7 +916,7 @@ static void clean_demultiplex_info(struct cifs_server_info *server)
cancel_delayed_work_sync(&server->resolve);
spin_lock(&g_servers_lock);
- server->tcpStatus = CifsExiting;
+ server->status = CifsExiting;
spin_unlock(&g_servers_lock);
wake_up_all(&server->response_q);
@@ -1091,7 +1091,7 @@ smb2_add_credits_from_hdr(char *buffer, struct cifs_server_info *server)
spin_unlock(&server->req_lock);
wake_up(&server->request_q);
- trace_smb3_hdr_credits(server->CurrentMid,
+ trace_smb3_hdr_credits(server->current_mid,
server->conn_id, server->hostname, scredits,
le16_to_cpu(shdr->CreditRequest), in_flight);
cifs_server_dbg(FYI, "%s: added %u credits total=%d\n",
@@ -1123,7 +1123,7 @@ cifs_demultiplex_thread(void *p)
set_freezable();
allow_kernel_signal(SIGKILL);
- while (server->tcpStatus != CifsExiting) {
+ while (server->status != CifsExiting) {
if (try_to_freeze())
continue;
@@ -1534,7 +1534,7 @@ cifs_put_server(struct cifs_server_info *server, int from_reconnect)
cancel_delayed_work_sync(&server->reconnect);
spin_lock(&g_servers_lock);
- server->tcpStatus = CifsExiting;
+ server->status = CifsExiting;
spin_unlock(&g_servers_lock);
cifs_crypto_secmech_release(server);
@@ -1603,7 +1603,7 @@ cifs_get_server(struct smb3_fs_context *ctx,
mutex_init(&server->_srv_mutex);
memcpy(server->workstation_RFC1001_name,
ctx->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
- memcpy(server->server_RFC1001_name,
+ memcpy(server->server_rfc1001_name,
ctx->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
server->session_estab = false;
server->sequence_number = 0;
@@ -1632,9 +1632,9 @@ cifs_get_server(struct smb3_fs_context *ctx,
/*
* at this point we are the only ones with the pointer
* to the struct since the kernel thread not created yet
- * no need to spinlock this init of tcpStatus or srv_count
+ * no need to spinlock this init of status or srv_count
*/
- server->tcpStatus = CifsNew;
+ server->status = CifsNew;
++server->srv_count;
if (ctx->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
@@ -1682,10 +1682,10 @@ cifs_get_server(struct smb3_fs_context *ctx,
/*
* at this point we are the only ones with the pointer
* to the struct since the kernel thread not created yet
- * no need to spinlock this update of tcpStatus
+ * no need to spinlock this update of status
*/
spin_lock(&g_servers_lock);
- server->tcpStatus = CifsNeedNegotiate;
+ server->status = CifsNeedNegotiate;
spin_unlock(&g_servers_lock);
if ((ctx->max_credits < 20) || (ctx->max_credits > 60000))
@@ -2767,10 +2767,10 @@ ip_rfc1001_connect(struct cifs_server_info *server)
if (ses_init_buf) {
ses_init_buf->trailer.session_req.called_len = 32;
- if (server->server_RFC1001_name[0] != 0)
+ if (server->server_rfc1001_name[0] != 0)
rfc1002mangle(ses_init_buf->trailer.
session_req.called_name,
- server->server_RFC1001_name,
+ server->server_rfc1001_name,
RFC1001_NAME_LEN_WITH_NULL);
else
rfc1002mangle(ses_init_buf->trailer.
@@ -3179,7 +3179,7 @@ static int mount_get_conns(struct mount_ctx *mnt_ctx)
*/
reset_cifs_unix_caps(xid, tcon, cifs_sb, ctx);
spin_lock(&g_servers_lock);
- if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
+ if ((tcon->ses->server->status == CifsNeedReconnect) &&
(le64_to_cpu(tcon->fsUnixInfo.Capability) &
CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
spin_unlock(&g_servers_lock);
@@ -3988,25 +3988,25 @@ cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses,
/* only send once per connect */
spin_lock(&g_servers_lock);
if (!server->ops->need_neg(server) ||
- server->tcpStatus != CifsNeedNegotiate) {
+ server->status != CifsNeedNegotiate) {
spin_unlock(&g_servers_lock);
return 0;
}
- server->tcpStatus = CifsInNegotiate;
+ server->status = CifsInNegotiate;
spin_unlock(&g_servers_lock);
rc = server->ops->negotiate(xid, ses, server);
if (rc == 0) {
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsInNegotiate)
- server->tcpStatus = CifsGood;
+ if (server->status == CifsInNegotiate)
+ server->status = CifsGood;
else
rc = -EHOSTDOWN;
spin_unlock(&g_servers_lock);
} else {
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsInNegotiate)
- server->tcpStatus = CifsNeedNegotiate;
+ if (server->status == CifsInNegotiate)
+ server->status = CifsNeedNegotiate;
spin_unlock(&g_servers_lock);
}
@@ -4067,7 +4067,7 @@ cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
}
cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
- server->sec_mode, server->capabilities, server->timeAdj);
+ server->sec_mode, server->capabilities, server->time_adjust);
if (server->ops->sess_setup)
rc = server->ops->sess_setup(xid, ses, server, nls_info);
@@ -1267,10 +1267,10 @@ cifs_push_mandatory_locks(struct cifs_file_info *cfile)
tcon = tlink_tcon(cfile->tlink);
/*
- * Accessing maxBuf is racy with cifs_reconnect - need to store value
+ * Accessing max_buf is racy with cifs_reconnect - need to store value
* and check it before using.
*/
- max_buf = tcon->ses->server->maxBuf;
+ max_buf = tcon->ses->server->max_buf;
if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
free_xid(xid);
return -EINVAL;
@@ -1611,10 +1611,10 @@ cifs_unlock_range(struct cifs_file_info *cfile, struct file_lock *flock,
INIT_LIST_HEAD(&tmp_llist);
/*
- * Accessing maxBuf is racy with cifs_reconnect - need to store value
+ * Accessing max_buf is racy with cifs_reconnect - need to store value
* and check it before using.
*/
- max_buf = tcon->ses->server->maxBuf;
+ max_buf = tcon->ses->server->max_buf;
if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
return -EINVAL;
@@ -613,8 +613,8 @@ smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *
fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
if (adjust_tz) {
- fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
- fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
+ fattr->cf_ctime.tv_sec += tcon->ses->server->time_adjust;
+ fattr->cf_mtime.tv_sec += tcon->ses->server->time_adjust;
}
fattr->cf_eof = le64_to_cpu(info->EndOfFile);
@@ -669,8 +669,8 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
if (adjust_tz) {
- fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
- fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
+ fattr->cf_ctime.tv_sec += tcon->ses->server->time_adjust;
+ fattr->cf_mtime.tv_sec += tcon->ses->server->time_adjust;
}
fattr->cf_eof = le64_to_cpu(info->EndOfFile);
@@ -318,7 +318,7 @@ static void
cifs_std_info_to_fattr(struct cifs_fattr *fattr, FIND_FILE_STANDARD_INFO *info,
struct cifs_sb_info *cifs_sb)
{
- int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->timeAdj;
+ int offset = cifs_sb_master_tcon(cifs_sb)->ses->server->time_adjust;
memset(fattr, 0, sizeof(*fattr));
fattr->cf_atime = cnvrtDosUnixTm(info->LastAccessDate,
@@ -514,7 +514,7 @@ static __u32 cifs_ssetup_hdr(struct cifs_ses *ses,
pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32,
CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4,
USHRT_MAX));
- pSMB->req.MaxMpxCount = cpu_to_le16(server->maxReq);
+ pSMB->req.MaxMpxCount = cpu_to_le16(server->max_req);
pSMB->req.VcNumber = cpu_to_le16(1);
/* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
@@ -169,7 +169,7 @@ cifs_get_next_mid(struct cifs_server_info *server)
spin_lock(&g_mid_lock);
/* mid is 16 bit only for CIFS/SMB */
- cur_mid = (__u16)((server->CurrentMid) & 0xffff);
+ cur_mid = (__u16)((server->current_mid) & 0xffff);
/* we do not want to loop forever */
last_mid = cur_mid;
cur_mid++;
@@ -220,7 +220,7 @@ cifs_get_next_mid(struct cifs_server_info *server)
if (!collision) {
mid = (__u64)cur_mid;
- server->CurrentMid = mid;
+ server->current_mid = mid;
break;
}
cur_mid++;
@@ -416,7 +416,7 @@ cifs_check_trans2(struct mid_q_entry *mid, struct cifs_server_info *server,
static bool
cifs_need_neg(struct cifs_server_info *server)
{
- return server->maxBuf == 0;
+ return server->max_buf == 0;
}
static int
@@ -463,7 +463,7 @@ cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
(!(server->capabilities & CAP_UNIX) && server->sign))
wsize = min_t(unsigned int, wsize,
- server->maxBuf - sizeof(WRITE_REQ) + 4);
+ server->max_buf - sizeof(WRITE_REQ) + 4);
/* hard limit of CIFS_MAX_WSIZE */
wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
@@ -495,7 +495,7 @@ cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
else if (server->capabilities & CAP_LARGE_READ_X)
defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
else
- defsize = server->maxBuf - sizeof(READ_RSP);
+ defsize = server->max_buf - sizeof(READ_RSP);
rsize = ctx->rsize ? ctx->rsize : defsize;
@@ -1024,7 +1024,7 @@ cifs_dir_needs_close(struct cifs_file_info *cfile)
static bool
cifs_can_echo(struct cifs_server_info *server)
{
- if (server->tcpStatus == CifsGood)
+ if (server->status == CifsGood)
return true;
return false;
@@ -116,10 +116,10 @@ smb2_unlock_range(struct cifs_file_info *cfile, struct file_lock *flock,
INIT_LIST_HEAD(&tmp_llist);
/*
- * Accessing maxBuf is racy with cifs_reconnect - need to store value
+ * Accessing max_buf is racy with cifs_reconnect - need to store value
* and check it before using.
*/
- max_buf = tcon->ses->server->maxBuf;
+ max_buf = tcon->ses->server->max_buf;
if (max_buf < sizeof(struct smb2_lock_element))
return -EINVAL;
@@ -257,10 +257,10 @@ smb2_push_mandatory_locks(struct cifs_file_info *cfile)
xid = get_xid();
/*
- * Accessing maxBuf is racy with cifs_reconnect - need to store value
+ * Accessing max_buf is racy with cifs_reconnect - need to store value
* and check it for zero before using.
*/
- max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;
+ max_buf = tlink_tcon(cfile->tlink)->ses->server->max_buf;
if (max_buf < sizeof(struct smb2_lock_element)) {
free_xid(xid);
return -EINVAL;
@@ -86,7 +86,7 @@ smb2_add_credits(struct cifs_server_info *server,
if (*val > 65000) {
*val = 65000; /* Don't get near 64K credits, avoid srv bugs */
pr_warn_once("server overflowed SMB3 credits\n");
- trace_smb3_overflow_credits(server->CurrentMid,
+ trace_smb3_overflow_credits(server->current_mid,
server->conn_id, server->hostname, *val,
add, server->in_flight);
}
@@ -112,7 +112,7 @@ smb2_add_credits(struct cifs_server_info *server,
wake_up(&server->request_q);
if (reconnect_detected) {
- trace_smb3_reconnect_detected(server->CurrentMid,
+ trace_smb3_reconnect_detected(server->current_mid,
server->conn_id, server->hostname, scredits, add, in_flight);
cifs_dbg(FYI, "trying to put %d credits from the old server instance %d\n",
@@ -120,15 +120,15 @@ smb2_add_credits(struct cifs_server_info *server,
}
if (reconnect_with_invalid_credits) {
- trace_smb3_reconnect_with_invalid_credits(server->CurrentMid,
+ trace_smb3_reconnect_with_invalid_credits(server->current_mid,
server->conn_id, server->hostname, scredits, add, in_flight);
cifs_dbg(FYI, "Negotiate operation when server credits is non-zero. Optype: %d, server credits: %d, credits added: %d\n",
optype, scredits, add);
}
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedReconnect
- || server->tcpStatus == CifsExiting) {
+ if (server->status == CifsNeedReconnect
+ || server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return;
}
@@ -152,7 +152,7 @@ smb2_add_credits(struct cifs_server_info *server,
break;
}
- trace_smb3_add_credits(server->CurrentMid,
+ trace_smb3_add_credits(server->current_mid,
server->conn_id, server->hostname, scredits, add, in_flight);
cifs_dbg(FYI, "%s: added %u credits total=%d\n", __func__, add, scredits);
}
@@ -170,7 +170,7 @@ smb2_set_credits(struct cifs_server_info *server, const int val)
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_set_credits(server->CurrentMid,
+ trace_smb3_set_credits(server->current_mid,
server->conn_id, server->hostname, scredits, val, in_flight);
cifs_dbg(FYI, "%s: set %u credits\n", __func__, val);
@@ -219,7 +219,7 @@ smb2_wait_mtu_credits(struct cifs_server_info *server, unsigned int size,
} else {
spin_unlock(&server->req_lock);
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
@@ -254,7 +254,7 @@ smb2_wait_mtu_credits(struct cifs_server_info *server, unsigned int size,
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_wait_credits(server->CurrentMid,
+ trace_smb3_wait_credits(server->current_mid,
server->conn_id, server->hostname, scredits, -(credits->value), in_flight);
cifs_dbg(FYI, "%s: removed %u credits total=%d\n",
__func__, credits->value, scredits);
@@ -274,7 +274,7 @@ smb2_adjust_credits(struct cifs_server_info *server,
return 0;
if (credits->value < new_val) {
- trace_smb3_too_many_credits(server->CurrentMid,
+ trace_smb3_too_many_credits(server->current_mid,
server->conn_id, server->hostname, 0, credits->value - new_val, 0);
cifs_server_dbg(VFS, "request has less credits (%d) than required (%d)",
credits->value, new_val);
@@ -289,7 +289,7 @@ smb2_adjust_credits(struct cifs_server_info *server,
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_reconnect_detected(server->CurrentMid,
+ trace_smb3_reconnect_detected(server->current_mid,
server->conn_id, server->hostname, scredits,
credits->value - new_val, in_flight);
cifs_server_dbg(VFS, "trying to return %d credits to old session\n",
@@ -303,7 +303,7 @@ smb2_adjust_credits(struct cifs_server_info *server,
spin_unlock(&server->req_lock);
wake_up(&server->request_q);
- trace_smb3_adj_credits(server->CurrentMid,
+ trace_smb3_adj_credits(server->current_mid,
server->conn_id, server->hostname, scredits,
credits->value - new_val, in_flight);
cifs_dbg(FYI, "%s: adjust added %u credits total=%d\n",
@@ -320,7 +320,7 @@ smb2_get_next_mid(struct cifs_server_info *server)
__u64 mid;
/* for SMB2 we need the current value */
spin_lock(&g_mid_lock);
- mid = server->CurrentMid++;
+ mid = server->current_mid++;
spin_unlock(&g_mid_lock);
return mid;
}
@@ -329,8 +329,8 @@ static void
smb2_revert_current_mid(struct cifs_server_info *server, const unsigned int val)
{
spin_lock(&g_mid_lock);
- if (server->CurrentMid >= val)
- server->CurrentMid -= val;
+ if (server->current_mid >= val)
+ server->current_mid -= val;
spin_unlock(&g_mid_lock);
}
@@ -404,7 +404,7 @@ smb2_negotiate(const unsigned int xid,
int rc;
spin_lock(&g_mid_lock);
- server->CurrentMid = 0;
+ server->current_mid = 0;
spin_unlock(&g_mid_lock);
rc = SMB2_negotiate(xid, ses, server);
/* BB we probably don't need to retry with modern servers */
@@ -2532,7 +2532,7 @@ smb2_is_status_pending(char *buf, struct cifs_server_info *server)
spin_unlock(&server->req_lock);
wake_up(&server->request_q);
- trace_smb3_pend_credits(server->CurrentMid,
+ trace_smb3_pend_credits(server->current_mid,
server->conn_id, server->hostname, scredits,
le16_to_cpu(shdr->CreditRequest), in_flight);
cifs_dbg(FYI, "%s: status pending add %u credits total=%d\n",
@@ -5080,7 +5080,7 @@ static void smb2_decrypt_offload(struct work_struct *work)
} else {
spin_lock(&g_servers_lock);
spin_lock(&g_mid_lock);
- if (dw->server->tcpStatus == CifsNeedReconnect) {
+ if (dw->server->status == CifsNeedReconnect) {
mid->mid_state = MID_RETRY_NEEDED;
spin_unlock(&g_mid_lock);
spin_unlock(&g_servers_lock);
@@ -191,7 +191,7 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,
* reconnect -- should be greater than cifs socket timeout which is 7
* seconds.
*/
- while (server->tcpStatus == CifsNeedReconnect) {
+ while (server->status == CifsNeedReconnect) {
/*
* Return to caller for TREE_DISCONNECT and LOGOFF and CLOSE
* here since they are implicitly done when session drops.
@@ -208,7 +208,7 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,
}
rc = wait_event_interruptible_timeout(server->response_q,
- (server->tcpStatus != CifsNeedReconnect),
+ (server->status != CifsNeedReconnect),
10 * HZ);
if (rc < 0) {
cifs_dbg(FYI, "%s: aborting reconnect due to a received signal by the process\n",
@@ -218,7 +218,7 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,
/* are we still trying to reconnect? */
spin_lock(&g_servers_lock);
- if (server->tcpStatus != CifsNeedReconnect) {
+ if (server->status != CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
break;
}
@@ -254,10 +254,10 @@ smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon,
/*
* Recheck after acquire mutex. If another thread is negotiating
* and the server never sends an answer the socket will be closed
- * and tcpStatus set to reconnect.
+ * and status set to reconnect.
*/
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedReconnect) {
+ if (server->status == CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
rc = -EHOSTDOWN;
goto out;
@@ -1032,7 +1032,7 @@ SMB2_negotiate(const unsigned int xid,
/* SMB2 only has an extended negflavor */
server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
/* set it to the maximum buffer size value we can send with 1 credit */
- server->maxBuf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
+ server->max_buf = min_t(unsigned int, le32_to_cpu(rsp->MaxTransactSize),
SMB2_MAX_BUFFER_SIZE);
server->max_read = le32_to_cpu(rsp->MaxReadSize);
server->max_write = le32_to_cpu(rsp->MaxWriteSize);
@@ -3776,7 +3776,7 @@ smb2_echo_callback(struct mid_q_entry *mid)
credits.instance = server->reconnect_instance;
}
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(server, &credits, CIFS_ECHO_OP);
}
@@ -4201,7 +4201,7 @@ smb2_readv_callback(struct mid_q_entry *mid)
rdata->offset, rdata->got_bytes);
queue_work(cifsiod_wq, &rdata->work);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(server, &credits, 0);
}
@@ -4440,7 +4440,7 @@ smb2_writev_callback(struct mid_q_entry *mid)
wdata->offset, wdata->bytes);
queue_work(cifsiod_wq, &wdata->work);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
add_credits(server, &credits, 0);
}
@@ -4874,7 +4874,7 @@ int SMB2_query_directory_init(const unsigned int xid,
* BB could be 30 bytes or so longer if we used SMB2 specific
* buffer lengths, but this is safe and close enough.
*/
- output_size = min_t(unsigned int, output_size, server->maxBuf);
+ output_size = min_t(unsigned int, output_size, server->max_buf);
output_size = min_t(unsigned int, output_size, 2 << 15);
req->OutputBufferLength = cpu_to_le32(output_size);
@@ -763,18 +763,18 @@ smb2_get_mid_entry(struct cifs_ses *ses, struct cifs_server_info *server,
struct smb2_hdr *shdr, struct mid_q_entry **mid)
{
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
- if (server->tcpStatus == CifsNeedReconnect) {
+ if (server->status == CifsNeedReconnect) {
spin_unlock(&g_servers_lock);
cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
return -EAGAIN;
}
- if (server->tcpStatus == CifsNeedNegotiate &&
+ if (server->status == CifsNeedNegotiate &&
shdr->Command != SMB2_NEGOTIATE) {
spin_unlock(&g_servers_lock);
return -EAGAIN;
@@ -870,7 +870,7 @@ smb2_setup_async_request(struct cifs_server_info *server, struct smb_rqst *rqst)
struct mid_q_entry *mid;
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsNeedNegotiate &&
+ if (server->status == CifsNeedNegotiate &&
shdr->Command != SMB2_NEGOTIATE) {
spin_unlock(&g_servers_lock);
return ERR_PTR(-EAGAIN);
@@ -888,7 +888,7 @@ smb2_setup_async_request(struct cifs_server_info *server, struct smb_rqst *rqst)
rc = smb2_sign_rqst(rqst, server);
if (rc) {
revert_current_mid_from_hdr(server, shdr);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
return ERR_PTR(rc);
}
@@ -38,12 +38,12 @@ cifs_wake_up_task(struct mid_q_entry *mid)
}
struct mid_q_entry *
-AllocMidQEntry(const struct smb_hdr *smb_buffer, struct cifs_server_info *server)
+cifs_alloc_mid_q_entry(const struct smb_hdr *smb_buffer, struct cifs_server_info *server)
{
struct mid_q_entry *temp;
if (server == NULL) {
- cifs_dbg(VFS, "Null TCP session in AllocMidQEntry\n");
+ cifs_dbg(VFS, "Null TCP session in cifs_alloc_mid_q_entry\n");
return NULL;
}
@@ -159,7 +159,7 @@ void cifs_mid_q_entry_release(struct mid_q_entry *midEntry)
spin_unlock(&g_mid_lock);
}
-void DeleteMidQEntry(struct mid_q_entry *midEntry)
+void cifs_delete_mid_q_entry(struct mid_q_entry *midEntry)
{
cifs_mid_q_entry_release(midEntry);
}
@@ -174,7 +174,7 @@ cifs_delete_mid(struct mid_q_entry *mid)
}
spin_unlock(&g_mid_lock);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
}
/*
@@ -431,7 +431,7 @@ __smb_send_rqst(struct cifs_server_info *server, int num_rqst,
* socket so the server throws away the partial SMB
*/
cifs_signal_cifsd_for_reconnect(server, false);
- trace_smb3_partial_send_reconnect(server->CurrentMid,
+ trace_smb3_partial_send_reconnect(server->current_mid,
server->conn_id, server->hostname);
}
smbd_done:
@@ -541,7 +541,7 @@ wait_for_free_credits(struct cifs_server_info *server, const int num_credits,
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_nblk_credits(server->CurrentMid,
+ trace_smb3_nblk_credits(server->current_mid,
server->conn_id, server->hostname, scredits, -1, in_flight);
cifs_dbg(FYI, "%s: remove %u credits total=%d\n",
__func__, 1, scredits);
@@ -564,7 +564,7 @@ wait_for_free_credits(struct cifs_server_info *server, const int num_credits,
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_credit_timeout(server->CurrentMid,
+ trace_smb3_credit_timeout(server->current_mid,
server->conn_id, server->hostname, scredits,
num_credits, in_flight);
cifs_server_dbg(VFS, "wait timed out after %d ms\n",
@@ -578,7 +578,7 @@ wait_for_free_credits(struct cifs_server_info *server, const int num_credits,
spin_unlock(&server->req_lock);
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
@@ -617,7 +617,7 @@ wait_for_free_credits(struct cifs_server_info *server, const int num_credits,
spin_unlock(&server->req_lock);
trace_smb3_credit_timeout(
- server->CurrentMid,
+ server->current_mid,
server->conn_id, server->hostname,
scredits, num_credits, in_flight);
cifs_server_dbg(VFS, "wait timed out after %d ms\n",
@@ -647,7 +647,7 @@ wait_for_free_credits(struct cifs_server_info *server, const int num_credits,
in_flight = server->in_flight;
spin_unlock(&server->req_lock);
- trace_smb3_waitff_credits(server->CurrentMid,
+ trace_smb3_waitff_credits(server->current_mid,
server->conn_id, server->hostname, scredits,
-(num_credits), in_flight);
cifs_dbg(FYI, "%s: remove %u credits total=%d\n",
@@ -698,7 +698,7 @@ wait_for_compound_request(struct cifs_server_info *server, int num,
*/
if (server->in_flight == 0) {
spin_unlock(&server->req_lock);
- trace_smb3_insufficient_credits(server->CurrentMid,
+ trace_smb3_insufficient_credits(server->current_mid,
server->conn_id, server->hostname, scredits,
num, in_flight);
cifs_dbg(FYI, "%s: %d requests in flight, needed %d total=%d\n",
@@ -745,7 +745,7 @@ static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
}
spin_unlock(&g_servers_lock);
- *ppmidQ = AllocMidQEntry(in_buf, ses->server);
+ *ppmidQ = cifs_alloc_mid_q_entry(in_buf, ses->server);
if (*ppmidQ == NULL)
return -ENOMEM;
spin_lock(&g_mid_lock);
@@ -782,13 +782,13 @@ cifs_setup_async_request(struct cifs_server_info *server, struct smb_rqst *rqst)
if (server->sign)
hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
- mid = AllocMidQEntry(hdr, server);
+ mid = cifs_alloc_mid_q_entry(hdr, server);
if (mid == NULL)
return ERR_PTR(-ENOMEM);
rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
if (rc) {
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
return ERR_PTR(rc);
}
@@ -937,7 +937,7 @@ cifs_sync_mid_result(struct mid_q_entry *mid, struct cifs_server_info *server)
}
spin_unlock(&g_mid_lock);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
return rc;
}
@@ -1026,7 +1026,7 @@ static void
cifs_cancelled_callback(struct mid_q_entry *mid)
{
cifs_compound_callback(mid);
- DeleteMidQEntry(mid);
+ cifs_delete_mid_q_entry(mid);
}
/*
@@ -1079,7 +1079,7 @@ compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
}
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
@@ -1361,7 +1361,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
}
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
@@ -1369,7 +1369,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
/* Ensure that we do not send more than 50 overlapping requests
to the same server. We may make this configurable later or
- use ses->maxReq */
+ use ses->max_req */
if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
cifs_server_dbg(VFS, "Invalid length, greater than maximum frame, %d\n",
@@ -1422,7 +1422,7 @@ SendReceive(const unsigned int xid, struct cifs_ses *ses,
spin_lock(&g_mid_lock);
if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
/* no longer considered to be "in-flight" */
- midQ->callback = DeleteMidQEntry;
+ midQ->callback = cifs_delete_mid_q_entry;
spin_unlock(&g_mid_lock);
add_credits(server, &credits, 0);
return rc;
@@ -1506,7 +1506,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
}
spin_lock(&g_servers_lock);
- if (server->tcpStatus == CifsExiting) {
+ if (server->status == CifsExiting) {
spin_unlock(&g_servers_lock);
return -ENOENT;
}
@@ -1514,7 +1514,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
/* Ensure that we do not send more than 50 overlapping requests
to the same server. We may make this configurable later or
- use ses->maxReq */
+ use ses->max_req */
if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
cifs_tcon_dbg(VFS, "Invalid length, greater than maximum frame, %d\n",
@@ -1564,15 +1564,15 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
/* Wait for a reply - allow signals to interrupt. */
rc = wait_event_interruptible(server->response_q,
(!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
- ((server->tcpStatus != CifsGood) &&
- (server->tcpStatus != CifsNew)));
+ ((server->status != CifsGood) &&
+ (server->status != CifsNew)));
/* Were we interrupted by a signal ? */
spin_lock(&g_servers_lock);
if ((rc == -ERESTARTSYS) &&
(midQ->mid_state == MID_REQUEST_SUBMITTED) &&
- ((server->tcpStatus == CifsGood) ||
- (server->tcpStatus == CifsNew))) {
+ ((server->status == CifsGood) ||
+ (server->status == CifsNew))) {
spin_unlock(&g_servers_lock);
if (in_buf->Command == SMB_COM_TRANSACTION2) {
@@ -1603,7 +1603,7 @@ SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
spin_lock(&g_mid_lock);
if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
/* no longer considered to be "in-flight" */
- midQ->callback = DeleteMidQEntry;
+ midQ->callback = cifs_delete_mid_q_entry;
spin_unlock(&g_mid_lock);
return rc;
}
Rename cifs_server_info variables that were still in CamelCase or Camel_Case to snake_case. Rename [Alloc,Delete]MidQEntry() functions to cifs_{alloc,delete}_mid_q_entry(). Signed-off-by: Enzo Matsumiya <ematsumiya@suse.de> --- fs/cifs/cifs_debug.c | 4 +- fs/cifs/cifsencrypt.c | 2 +- fs/cifs/cifsglob.h | 24 ++++++------ fs/cifs/cifsproto.h | 4 +- fs/cifs/cifssmb.c | 38 +++++++++---------- fs/cifs/connect.c | 84 ++++++++++++++++++++--------------------- fs/cifs/file.c | 8 ++-- fs/cifs/inode.c | 8 ++-- fs/cifs/readdir.c | 2 +- fs/cifs/sess.c | 2 +- fs/cifs/smb1ops.c | 12 +++--- fs/cifs/smb2file.c | 8 ++-- fs/cifs/smb2ops.c | 36 +++++++++--------- fs/cifs/smb2pdu.c | 20 +++++----- fs/cifs/smb2transport.c | 10 ++--- fs/cifs/transport.c | 54 +++++++++++++------------- 16 files changed, 158 insertions(+), 158 deletions(-)