[CIFS] list entry can not return null

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

diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index 688a2d42153f53417efd8938a229ffbd9fcf2a92..69a12aae91d313e832ae3e2002d3bdfc7732ecc6 100644 (file)
--- 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 1ec7076f7b241b7a86d182043db5debf36fdd977..e8da4ee761b512af8744c69f3b3361eb9edffef8 100644 (file)
--- 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 6e8e8fc04c0290f1e246453295e305bc2236a132..994de7c90474708ab5ed381bfc833a65d57e8c47 100644 (file)
--- 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 ff4345db72015007b030e77546304a7b852f8440..0711db65afe8025e0a4abafc56df66b7b2e3545f 100644 (file)
--- 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);