[CIFS] list entry can not return null

Signed-off-by: Steve French <sfrench@us.ibm.com>

4 files changed, 61 insertions, 74 deletions

diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index 688a2d42153f..69a12aae91d3 100644
--- a/fs/cifs/cifs_debug.c
+++ b/fs/cifs/cifs_debug.c
@@ -79,27 +79,25 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
         spin_lock(&GlobalMid_Lock);
         list_for_each(tmp, &server->pending_mid_q) {
                 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",
-                                mid_entry->midState,
-                                (int)mid_entry->command,
-                                mid_entry->pid,
-                                mid_entry->tsk,
-                                mid_entry->mid));
+                cERROR(1, ("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
+                        mid_entry->midState,
+                        (int)mid_entry->command,
+                        mid_entry->pid,
+                        mid_entry->tsk,
+                        mid_entry->mid));
 #ifdef CONFIG_CIFS_STATS2
-                        cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld",
-                                mid_entry->largeBuf,
-                                mid_entry->resp_buf,
-                                mid_entry->when_received,
-                                jiffies));
+                cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld",
+                        mid_entry->largeBuf,
+                        mid_entry->resp_buf,
+                        mid_entry->when_received,
+                        jiffies));
 #endif /* STATS2 */
-                        cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
-                                  mid_entry->multiEnd));
-                        if (mid_entry->resp_buf) {
-                                cifs_dump_detail(mid_entry->resp_buf);
-                                cifs_dump_mem("existing buf: ",
-                                        mid_entry->resp_buf, 62);
-                        }
+                cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
+                          mid_entry->multiEnd));
+                if (mid_entry->resp_buf) {
+                        cifs_dump_detail(mid_entry->resp_buf);
+                        cifs_dump_mem("existing buf: ",
+                                mid_entry->resp_buf, 62);
                 }
         }
         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_q_entry,
                                         qhead);
-                                if (mid_entry) {
-                                        seq_printf(m,
-                                                        "State: %d com: %d pid:"
-                                                        " %d tsk: %p mid %d\n",
-                                                        mid_entry->midState,
-                                                        (int)mid_entry->command,
-                                                        mid_entry->pid,
-                                                        mid_entry->tsk,
-                                                        mid_entry->mid);
-                                }
+                                seq_printf(m, "State: %d com: %d pid:"
+                                                " %d tsk: %p mid %d\n",
+                                                mid_entry->midState,
+                                                (int)mid_entry->command,
+                                                mid_entry->pid,
+                                                mid_entry->tsk,
+                                                mid_entry->mid);
                         }
                         spin_unlock(&GlobalMid_Lock);
                 }
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 1ec7076f7b24..e8da4ee761b5 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -930,36 +930,34 @@ static int cifs_oplock_thread(void *dummyarg)
                         schedule_timeout(39*HZ);
                 } else {
                         oplock_item = list_entry(GlobalOplock_Q.next,
-                                struct oplock_q_entry, qhead);
-                        if (oplock_item) {
-                                cFYI(1, ("found oplock item to write out"));
-                                pTcon = oplock_item->tcon;
-                                inode = oplock_item->pinode;
-                                netfid = oplock_item->netfid;
-                                spin_unlock(&GlobalMid_Lock);
-                                DeleteOplockQEntry(oplock_item);
-                                /* can not grab inode sem here since it would
+                                                struct oplock_q_entry, qhead);
+                        cFYI(1, ("found oplock item to write out"));
+                        pTcon = oplock_item->tcon;
+                        inode = oplock_item->pinode;
+                        netfid = oplock_item->netfid;
+                        spin_unlock(&GlobalMid_Lock);
+                        DeleteOplockQEntry(oplock_item);
+                        /* can not grab inode sem here since it would
                                 deadlock when oplock received on delete
                                 since vfs_unlink holds the i_mutex across
                                 the call */
-                                /* mutex_lock(&inode->i_mutex);*/
-                                if (S_ISREG(inode->i_mode)) {
-                                        rc =
-                                           filemap_fdatawrite(inode->i_mapping);
-                                        if (CIFS_I(inode)->clientCanCacheRead
-                                                                         == 0) {
-                                                waitrc = filemap_fdatawait(inode->i_mapping);
-                                                invalidate_remote_inode(inode);
-                                        }
-                                        if (rc == 0)
-                                                rc = waitrc;
-                                } else
-                                        rc = 0;
-                                /* mutex_unlock(&inode->i_mutex);*/
-                                if (rc)
-                                        CIFS_I(inode)->write_behind_rc = rc;
-                                cFYI(1, ("Oplock flush inode %p rc %d",
-                                        inode, rc));
+                        /* mutex_lock(&inode->i_mutex);*/
+                        if (S_ISREG(inode->i_mode)) {
+                                rc = filemap_fdatawrite(inode->i_mapping);
+                                if (CIFS_I(inode)->clientCanCacheRead == 0) {
+                                        waitrc = filemap_fdatawait(
+                                                              inode->i_mapping);
+                                        invalidate_remote_inode(inode);
+                                }
+                                if (rc == 0)
+                                        rc = waitrc;
+                        } else
+                                rc = 0;
+                        /* mutex_unlock(&inode->i_mutex);*/
+                        if (rc)
+                                CIFS_I(inode)->write_behind_rc = rc;
+                        cFYI(1, ("Oplock flush inode %p rc %d",
+                                inode, rc));
 
                                 /* releasing stale oplock after recent reconnect
                                 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
                                 to server still is disconnected since oplock
                                 already released by the server in that case */
-                                if (pTcon->tidStatus != CifsNeedReconnect) {
-                                    rc = CIFSSMBLock(0, pTcon, netfid,
-                                            0 /* len */ , 0 /* offset */, 0,
-                                            0, LOCKING_ANDX_OPLOCK_RELEASE,
-                                            false /* wait flag */);
-                                        cFYI(1, ("Oplock release rc = %d", rc));
-                                }
-                        } else
-                                spin_unlock(&GlobalMid_Lock);
+                        if (pTcon->tidStatus != CifsNeedReconnect) {
+                                rc = CIFSSMBLock(0, pTcon, netfid,
+                                                0 /* len */ , 0 /* offset */, 0,
+                                                0, LOCKING_ANDX_OPLOCK_RELEASE,
+                                                false /* wait flag */);
+                                cFYI(1, ("Oplock release rc = %d", rc));
+                        }
                         set_current_state(TASK_INTERRUPTIBLE);
                         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) {
                         ses = list_entry(tmp, struct cifsSesInfo,
                                 cifsSessionList);
-                        if (ses && ses->server &&
-                             atomic_read(&ses->server->inFlight))
+                        if (ses->server && atomic_read(&ses->server->inFlight))
                                 wake_up_all(&ses->server->response_q);
                 }
                 read_unlock(&GlobalSMBSeslock);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 6e8e8fc04c02..994de7c90474 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -128,8 +128,7 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
         write_lock(&GlobalSMBSeslock);
         list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
-                if (open_file)
-                        open_file->invalidHandle = true;
+                open_file->invalidHandle = true;
         }
         write_unlock(&GlobalSMBSeslock);
         /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index ff4345db7201..0711db65afe8 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -151,7 +151,7 @@ cifs_reconnect(struct TCP_Server_Info *server)
         }
         list_for_each(tmp, &GlobalTreeConnectionList) {
                 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;
         }
         read_unlock(&GlobalSMBSeslock);
@@ -173,14 +173,12 @@ cifs_reconnect(struct TCP_Server_Info *server)
                 mid_entry = list_entry(tmp, struct
                                         mid_q_entry,
                                         qhead);
-                if (mid_entry) {
-                        if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
+                if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
                                 /* Mark other intransit requests as needing
                                    retry so we do not immediately mark the
                                    session bad again (ie after we reconnect
                                    below) as they timeout too */
-                                mid_entry->midState = MID_RETRY_NEEDED;
-                        }
+                        mid_entry->midState = MID_RETRY_NEEDED;
                 }
         }
         spin_unlock(&GlobalMid_Lock);