FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2024-12-16 14:02:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[CIFS] list entry can not return null

Browse Source 
Signed-off-by: Steve French <sfrench@us.ibm.com>
This commit is contained in:
Steve French 2008-08-08 21:10:16 +00:00
parent 0510eeb736
commit ad8b15f0ff
4 changed files with 61 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
fs/cifs/cifs_debug.c
View File

@ -79,27 +79,25 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
spin_lock(&GlobalMid_Lock); spin_lock(&GlobalMid_Lock);
list_for_each(tmp, &server->pending_mid_q) { list_for_each(tmp, &server->pending_mid_q) {
mid_entry = list_entry(tmp, struct mid_q_entry, qhead); mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
if (mid_entry) { cERROR(1, ("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
cERROR(1, ("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d", mid_entry->midState,
mid_entry->midState, (int)mid_entry->command,
(int)mid_entry->command, mid_entry->pid,
mid_entry->pid, mid_entry->tsk,
mid_entry->tsk, mid_entry->mid));
mid_entry->mid));
#ifdef CONFIG_CIFS_STATS2 #ifdef CONFIG_CIFS_STATS2
cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld", cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld",
mid_entry->largeBuf, mid_entry->largeBuf,
mid_entry->resp_buf, mid_entry->resp_buf,
mid_entry->when_received, mid_entry->when_received,
jiffies)); jiffies));
#endif /* STATS2 */ #endif /* STATS2 */
cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp, cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
mid_entry->multiEnd)); mid_entry->multiEnd));
if (mid_entry->resp_buf) { if (mid_entry->resp_buf) {
cifs_dump_detail(mid_entry->resp_buf); cifs_dump_detail(mid_entry->resp_buf);
cifs_dump_mem("existing buf: ", cifs_dump_mem("existing buf: ",
mid_entry->resp_buf, 62); mid_entry->resp_buf, 62);
}
} }
} }
spin_unlock(&GlobalMid_Lock); spin_unlock(&GlobalMid_Lock);
@ -163,16 +161,13 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
mid_entry = list_entry(tmp1, struct mid_entry = list_entry(tmp1, struct
mid_q_entry, mid_q_entry,
qhead); qhead);
if (mid_entry) { seq_printf(m, "State: %d com: %d pid:"
seq_printf(m, " %d tsk: %p mid %d\n",
"State: %d com: %d pid:" mid_entry->midState,
" %d tsk: %p mid %d\n", (int)mid_entry->command,
mid_entry->midState, mid_entry->pid,
(int)mid_entry->command, mid_entry->tsk,
mid_entry->pid, mid_entry->mid);
mid_entry->tsk,
mid_entry->mid);
}
} }
spin_unlock(&GlobalMid_Lock); spin_unlock(&GlobalMid_Lock);
} }

71
fs/cifs/cifsfs.c
View File

@ -930,36 +930,34 @@ static int cifs_oplock_thread(void *dummyarg)
schedule_timeout(39*HZ); schedule_timeout(39*HZ);
} else { } else {
oplock_item = list_entry(GlobalOplock_Q.next, oplock_item = list_entry(GlobalOplock_Q.next,
struct oplock_q_entry, qhead); struct oplock_q_entry, qhead);
if (oplock_item) { cFYI(1, ("found oplock item to write out"));
cFYI(1, ("found oplock item to write out")); pTcon = oplock_item->tcon;
pTcon = oplock_item->tcon; inode = oplock_item->pinode;
inode = oplock_item->pinode; netfid = oplock_item->netfid;
netfid = oplock_item->netfid; spin_unlock(&GlobalMid_Lock);
spin_unlock(&GlobalMid_Lock); DeleteOplockQEntry(oplock_item);
DeleteOplockQEntry(oplock_item); /* can not grab inode sem here since it would
/* can not grab inode sem here since it would
deadlock when oplock received on delete deadlock when oplock received on delete
since vfs_unlink holds the i_mutex across since vfs_unlink holds the i_mutex across
the call */ the call */
/* mutex_lock(&inode->i_mutex);*/ /* mutex_lock(&inode->i_mutex);*/
if (S_ISREG(inode->i_mode)) { if (S_ISREG(inode->i_mode)) {
rc = rc = filemap_fdatawrite(inode->i_mapping);
filemap_fdatawrite(inode->i_mapping); if (CIFS_I(inode)->clientCanCacheRead == 0) {
if (CIFS_I(inode)->clientCanCacheRead waitrc = filemap_fdatawait(
== 0) { inode->i_mapping);
waitrc = filemap_fdatawait(inode->i_mapping); invalidate_remote_inode(inode);
invalidate_remote_inode(inode); }
} if (rc == 0)
if (rc == 0) rc = waitrc;
rc = waitrc; } else
} else rc = 0;
rc = 0; /* mutex_unlock(&inode->i_mutex);*/
/* mutex_unlock(&inode->i_mutex);*/ if (rc)
if (rc) CIFS_I(inode)->write_behind_rc = rc;
CIFS_I(inode)->write_behind_rc = rc; cFYI(1, ("Oplock flush inode %p rc %d",
cFYI(1, ("Oplock flush inode %p rc %d", inode, rc));
inode, rc));
/* releasing stale oplock after recent reconnect /* releasing stale oplock after recent reconnect
of smb session using a now incorrect file of smb session using a now incorrect file
@ -967,15 +965,13 @@ static int cifs_oplock_thread(void *dummyarg)
not bother sending an oplock release if session not bother sending an oplock release if session
to server still is disconnected since oplock to server still is disconnected since oplock
already released by the server in that case */ already released by the server in that case */
if (pTcon->tidStatus != CifsNeedReconnect) { if (pTcon->tidStatus != CifsNeedReconnect) {
rc = CIFSSMBLock(0, pTcon, netfid, rc = CIFSSMBLock(0, pTcon, netfid,
0 /* len */ , 0 /* offset */, 0, 0 /* len */ , 0 /* offset */, 0,
0, LOCKING_ANDX_OPLOCK_RELEASE, 0, LOCKING_ANDX_OPLOCK_RELEASE,
false /* wait flag */); false /* wait flag */);
cFYI(1, ("Oplock release rc = %d", rc)); cFYI(1, ("Oplock release rc = %d", rc));
} }
} else
spin_unlock(&GlobalMid_Lock);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(1); /* yield in case q were corrupt */ schedule_timeout(1); /* yield in case q were corrupt */
} }
@ -1001,8 +997,7 @@ static int cifs_dnotify_thread(void *dummyarg)
list_for_each(tmp, &GlobalSMBSessionList) { list_for_each(tmp, &GlobalSMBSessionList) {
ses = list_entry(tmp, struct cifsSesInfo, ses = list_entry(tmp, struct cifsSesInfo,
cifsSessionList); cifsSessionList);
if (ses && ses->server && if (ses->server && atomic_read(&ses->server->inFlight))
atomic_read(&ses->server->inFlight))
wake_up_all(&ses->server->response_q); wake_up_all(&ses->server->response_q);
} }
read_unlock(&GlobalSMBSeslock); read_unlock(&GlobalSMBSeslock);

3
fs/cifs/cifssmb.c
View File

@ -128,8 +128,7 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
write_lock(&GlobalSMBSeslock); write_lock(&GlobalSMBSeslock);
list_for_each_safe(tmp, tmp1, &pTcon->openFileList) { list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
open_file = list_entry(tmp, struct cifsFileInfo, tlist); open_file = list_entry(tmp, struct cifsFileInfo, tlist);
if (open_file) open_file->invalidHandle = true;
open_file->invalidHandle = true;
} }
write_unlock(&GlobalSMBSeslock); write_unlock(&GlobalSMBSeslock);
/* BB Add call to invalidate_inodes(sb) for all superblocks mounted /* BB Add call to invalidate_inodes(sb) for all superblocks mounted

8
fs/cifs/connect.c
View File

@ -151,7 +151,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
} }
list_for_each(tmp, &GlobalTreeConnectionList) { list_for_each(tmp, &GlobalTreeConnectionList) {
tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList); tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList);
if ((tcon) && (tcon->ses) && (tcon->ses->server == server)) if ((tcon->ses) && (tcon->ses->server == server))
tcon->tidStatus = CifsNeedReconnect; tcon->tidStatus = CifsNeedReconnect;
} }
read_unlock(&GlobalSMBSeslock); read_unlock(&GlobalSMBSeslock);
@ -173,14 +173,12 @@ cifs_reconnect(struct TCP_Server_Info *server)
mid_entry = list_entry(tmp, struct mid_entry = list_entry(tmp, struct
mid_q_entry, mid_q_entry,
qhead); qhead);
if (mid_entry) { if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
/* Mark other intransit requests as needing /* Mark other intransit requests as needing
retry so we do not immediately mark the retry so we do not immediately mark the
session bad again (ie after we reconnect session bad again (ie after we reconnect
below) as they timeout too */ below) as they timeout too */
mid_entry->midState = MID_RETRY_NEEDED; mid_entry->midState = MID_RETRY_NEEDED;
}
} }
} }
spin_unlock(&GlobalMid_Lock); spin_unlock(&GlobalMid_Lock);