[IA64] run drivers/misc/sgi-xp through scripts/checkpatch.pl

Addressed issues raised by scripts/checkpatch.pl. Removed unnecessary curly
braces. Eliminated uses of volatiles and use of kernel_thread() and daemonize().

Signed-off-by: Dean Nelson <dcn@sgi.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>

1 files changed, 75 insertions, 117 deletions

diff --git a/drivers/misc/sgi-xp/xpc_channel.c b/drivers/misc/sgi-xp/xpc_channel.c
index 15cb91a82102..bfcb9ea968e9 100644
--- a/drivers/misc/sgi-xp/xpc_channel.c
+++ b/drivers/misc/sgi-xp/xpc_channel.c
@@ -33,19 +33,19 @@ xpc_kzalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
 {
         /* see if kzalloc will give us cachline aligned memory by default */
         *base = kzalloc(size, flags);
-        if (*base == NULL) {
+        if (*base == NULL)
                 return NULL;
-        }
-        if ((u64)*base == L1_CACHE_ALIGN((u64)*base)) {
+
+        if ((u64)*base == L1_CACHE_ALIGN((u64)*base))
                 return *base;
-        }
+
         kfree(*base);
 
         /* nope, we'll have to do it ourselves */
         *base = kzalloc(size + L1_CACHE_BYTES, flags);
-        if (*base == NULL) {
+        if (*base == NULL)
                 return NULL;
-        }
+
         return (void *)L1_CACHE_ALIGN((u64)*base);
 }
 
@@ -264,15 +264,13 @@ xpc_pull_remote_cachelines(struct xpc_partition *part, void *dst,
         DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));
         DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));
 
-        if (part->act_state == XPC_P_DEACTIVATING) {
+        if (part->act_state == XPC_P_DEACTIVATING)
                 return part->reason;
-        }
 
         bte_ret = xp_bte_copy((u64)src, (u64)dst, (u64)cnt,
                               (BTE_NORMAL | BTE_WACQUIRE), NULL);
-        if (bte_ret == BTE_SUCCESS) {
+        if (bte_ret == BTE_SUCCESS)
                 return xpcSuccess;
-        }
 
         dev_dbg(xpc_chan, "xp_bte_copy() from partition %d failed, ret=%d\n",
                 XPC_PARTID(part), bte_ret);
@@ -359,18 +357,16 @@ xpc_pull_remote_vars_part(struct xpc_partition *part)
                 part->remote_IPI_nasid = pulled_entry->IPI_nasid;
                 part->remote_IPI_phys_cpuid = pulled_entry->IPI_phys_cpuid;
 
-                if (part->nchannels > pulled_entry->nchannels) {
+                if (part->nchannels > pulled_entry->nchannels)
                         part->nchannels = pulled_entry->nchannels;
-                }
 
                 /* let the other side know that we've pulled their variables */
 
                 xpc_vars_part[partid].magic = XPC_VP_MAGIC2;
         }
 
-        if (pulled_entry->magic == XPC_VP_MAGIC1) {
+        if (pulled_entry->magic == XPC_VP_MAGIC1)
                 return xpcRetry;
-        }
 
         return xpcSuccess;
 }
@@ -390,9 +386,10 @@ xpc_get_IPI_flags(struct xpc_partition *part)
          */
 
         spin_lock_irqsave(&part->IPI_lock, irq_flags);
-        if ((IPI_amo = part->local_IPI_amo) != 0) {
+        IPI_amo = part->local_IPI_amo;
+        if (IPI_amo != 0)
                 part->local_IPI_amo = 0;
-        }
+
         spin_unlock_irqrestore(&part->IPI_lock, irq_flags);
 
         if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_amo)) {
@@ -441,20 +438,14 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
         int nentries;
         size_t nbytes;
 
-        // >>> may want to check for ch->flags & XPC_C_DISCONNECTING between
-        // >>> iterations of the for-loop, bail if set?
-
-        // >>> should we impose a minimum #of entries? like 4 or 8?
         for (nentries = ch->local_nentries; nentries > 0; nentries--) {
 
                 nbytes = nentries * ch->msg_size;
                 ch->local_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
                                                                    GFP_KERNEL,
-                                                                   &ch->
-                                                                   local_msgqueue_base);
-                if (ch->local_msgqueue == NULL) {
+                                                      &ch->local_msgqueue_base);
+                if (ch->local_msgqueue == NULL)
                         continue;
-                }
 
                 nbytes = nentries * sizeof(struct xpc_notify);
                 ch->notify_queue = kzalloc(nbytes, GFP_KERNEL);
@@ -493,20 +484,14 @@ xpc_allocate_remote_msgqueue(struct xpc_channel *ch)
 
         DBUG_ON(ch->remote_nentries <= 0);
 
-        // >>> may want to check for ch->flags & XPC_C_DISCONNECTING between
-        // >>> iterations of the for-loop, bail if set?
-
-        // >>> should we impose a minimum #of entries? like 4 or 8?
         for (nentries = ch->remote_nentries; nentries > 0; nentries--) {
 
                 nbytes = nentries * ch->msg_size;
                 ch->remote_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
                                                                     GFP_KERNEL,
-                                                                    &ch->
-                                                                    remote_msgqueue_base);
-                if (ch->remote_msgqueue == NULL) {
+                                                     &ch->remote_msgqueue_base);
+                if (ch->remote_msgqueue == NULL)
                         continue;
-                }
 
                 spin_lock_irqsave(&ch->lock, irq_flags);
                 if (nentries < ch->remote_nentries) {
@@ -538,11 +523,12 @@ xpc_allocate_msgqueues(struct xpc_channel *ch)
 
         DBUG_ON(ch->flags & XPC_C_SETUP);
 
-        if ((ret = xpc_allocate_local_msgqueue(ch)) != xpcSuccess) {
+        ret = xpc_allocate_local_msgqueue(ch);
+        if (ret != xpcSuccess)
                 return ret;
-        }
 
-        if ((ret = xpc_allocate_remote_msgqueue(ch)) != xpcSuccess) {
+        ret = xpc_allocate_remote_msgqueue(ch);
+        if (ret != xpcSuccess) {
                 kfree(ch->local_msgqueue_base);
                 ch->local_msgqueue = NULL;
                 kfree(ch->notify_queue);
@@ -582,12 +568,11 @@ xpc_process_connect(struct xpc_channel *ch, unsigned long *irq_flags)
                 ret = xpc_allocate_msgqueues(ch);
                 spin_lock_irqsave(&ch->lock, *irq_flags);
 
-                if (ret != xpcSuccess) {
+                if (ret != xpcSuccess)
                         XPC_DISCONNECT_CHANNEL(ch, ret, irq_flags);
-                }
-                if (ch->flags & (XPC_C_CONNECTED | XPC_C_DISCONNECTING)) {
+
+                if (ch->flags & (XPC_C_CONNECTED | XPC_C_DISCONNECTING))
                         return;
-                }
 
                 DBUG_ON(!(ch->flags & XPC_C_SETUP));
                 DBUG_ON(ch->local_msgqueue == NULL);
@@ -599,9 +584,8 @@ xpc_process_connect(struct xpc_channel *ch, unsigned long *irq_flags)
                 xpc_IPI_send_openreply(ch, irq_flags);
         }
 
-        if (!(ch->flags & XPC_C_ROPENREPLY)) {
+        if (!(ch->flags & XPC_C_ROPENREPLY))
                 return;
-        }
 
         DBUG_ON(ch->remote_msgqueue_pa == 0);
 
@@ -719,9 +703,8 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
 
         DBUG_ON(!spin_is_locked(&ch->lock));
 
-        if (!(ch->flags & XPC_C_DISCONNECTING)) {
+        if (!(ch->flags & XPC_C_DISCONNECTING))
                 return;
-        }
 
         DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));
 
@@ -736,26 +719,23 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
 
         if (part->act_state == XPC_P_DEACTIVATING) {
                 /* can't proceed until the other side disengages from us */
-                if (xpc_partition_engaged(1UL << ch->partid)) {
+                if (xpc_partition_engaged(1UL << ch->partid))
                         return;
-                }
 
         } else {
 
                 /* as long as the other side is up do the full protocol */
 
-                if (!(ch->flags & XPC_C_RCLOSEREQUEST)) {
+                if (!(ch->flags & XPC_C_RCLOSEREQUEST))
                         return;
-                }
 
                 if (!(ch->flags & XPC_C_CLOSEREPLY)) {
                         ch->flags |= XPC_C_CLOSEREPLY;
                         xpc_IPI_send_closereply(ch, irq_flags);
                 }
 
-                if (!(ch->flags & XPC_C_RCLOSEREPLY)) {
+                if (!(ch->flags & XPC_C_RCLOSEREPLY))
                         return;
-                }
         }
 
         /* wake those waiting for notify completion */
@@ -815,9 +795,10 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
 
         spin_lock_irqsave(&ch->lock, irq_flags);
 
-      again:
+again:
 
-        if ((ch->flags & XPC_C_DISCONNECTED) && (ch->flags & XPC_C_WDISCONNECT)) {
+        if ((ch->flags & XPC_C_DISCONNECTED) &&
+            (ch->flags & XPC_C_WDISCONNECT)) {
                 /*
                  * Delay processing IPI flags until thread waiting disconnect
                  * has had a chance to see that the channel is disconnected.
@@ -890,11 +871,10 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
 
                 if (!(ch->flags & XPC_C_DISCONNECTING)) {
                         reason = args->reason;
-                        if (reason <= xpcSuccess || reason > xpcUnknownReason) {
+                        if (reason <= xpcSuccess || reason > xpcUnknownReason)
                                 reason = xpcUnknownReason;
-                        } else if (reason == xpcUnregistering) {
+                        else if (reason == xpcUnregistering)
                                 reason = xpcOtherUnregistering;
-                        }
 
                         XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);
 
@@ -1068,9 +1048,8 @@ xpc_connect_channel(struct xpc_channel *ch)
         unsigned long irq_flags;
         struct xpc_registration *registration = &xpc_registrations[ch->number];
 
-        if (mutex_trylock(&registration->mutex) == 0) {
+        if (mutex_trylock(&registration->mutex) == 0)
                 return xpcRetry;
-        }
 
         if (!XPC_CHANNEL_REGISTERED(ch->number)) {
                 mutex_unlock(&registration->mutex);
@@ -1159,7 +1138,7 @@ xpc_clear_local_msgqueue_flags(struct xpc_channel *ch)
                                          (get % ch->local_nentries) *
                                          ch->msg_size);
                 msg->flags = 0;
-        } while (++get < (volatile s64)ch->remote_GP.get);
+        } while (++get < ch->remote_GP.get);
 }
 
 /*
@@ -1177,7 +1156,7 @@ xpc_clear_remote_msgqueue_flags(struct xpc_channel *ch)
                                          (put % ch->remote_nentries) *
                                          ch->msg_size);
                 msg->flags = 0;
-        } while (++put < (volatile s64)ch->remote_GP.put);
+        } while (++put < ch->remote_GP.put);
 }
 
 static void
@@ -1244,9 +1223,8 @@ xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)
                  * If anyone was waiting for message queue entries to become
                  * available, wake them up.
                  */
-                if (atomic_read(&ch->n_on_msg_allocate_wq) > 0) {
+                if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
                         wake_up(&ch->msg_allocate_wq);
-                }
         }
 
         /*
@@ -1273,9 +1251,8 @@ xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)
                                 "delivered=%d, partid=%d, channel=%d\n",
                                 nmsgs_sent, ch->partid, ch->number);
 
-                        if (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) {
+                        if (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE)
                                 xpc_activate_kthreads(ch, nmsgs_sent);
-                        }
                 }
         }
 
@@ -1310,9 +1287,8 @@ xpc_process_channel_activity(struct xpc_partition *part)
 
                 IPI_flags = XPC_GET_IPI_FLAGS(IPI_amo, ch_number);
 
-                if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_flags)) {
+                if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_flags))
                         xpc_process_openclose_IPI(part, ch_number, IPI_flags);
-                }
 
                 ch_flags = ch->flags;   /* need an atomic snapshot of flags */
 
@@ -1323,9 +1299,8 @@ xpc_process_channel_activity(struct xpc_partition *part)
                         continue;
                 }
 
-                if (part->act_state == XPC_P_DEACTIVATING) {
+                if (part->act_state == XPC_P_DEACTIVATING)
                         continue;
-                }
 
                 if (!(ch_flags & XPC_C_CONNECTED)) {
                         if (!(ch_flags & XPC_C_OPENREQUEST)) {
@@ -1345,9 +1320,8 @@ xpc_process_channel_activity(struct xpc_partition *part)
                  * from the other partition.
                  */
 
-                if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_flags)) {
+                if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_flags))
                         xpc_process_msg_IPI(part, ch_number);
-                }
         }
 }
 
@@ -1560,9 +1534,9 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
 
         DBUG_ON(!spin_is_locked(&ch->lock));
 
-        if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED)) {
+        if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED))
                 return;
-        }
+
         DBUG_ON(!(ch->flags & (XPC_C_CONNECTING | XPC_C_CONNECTED)));
 
         dev_dbg(xpc_chan, "reason=%d, line=%d, partid=%d, channel=%d\n",
@@ -1578,9 +1552,8 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
 
         xpc_IPI_send_closerequest(ch, irq_flags);
 
-        if (channel_was_connected) {
+        if (channel_was_connected)
                 ch->flags |= XPC_C_WASCONNECTED;
-        }
 
         spin_unlock_irqrestore(&ch->lock, *irq_flags);
 
@@ -1595,9 +1568,8 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
         }
 
         /* wake those waiting to allocate an entry from the local msg queue */
-        if (atomic_read(&ch->n_on_msg_allocate_wq) > 0) {
+        if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
                 wake_up(&ch->msg_allocate_wq);
-        }
 
         spin_lock_irqsave(&ch->lock, *irq_flags);
 }
@@ -1632,7 +1604,7 @@ xpc_allocate_msg_wait(struct xpc_channel *ch)
         enum xpc_retval ret;
 
         if (ch->flags & XPC_C_DISCONNECTING) {
-                DBUG_ON(ch->reason == xpcInterrupted);  // >>> Is this true?
+                DBUG_ON(ch->reason == xpcInterrupted);
                 return ch->reason;
         }
 
@@ -1642,7 +1614,7 @@ xpc_allocate_msg_wait(struct xpc_channel *ch)
 
         if (ch->flags & XPC_C_DISCONNECTING) {
                 ret = ch->reason;
-                DBUG_ON(ch->reason == xpcInterrupted);  // >>> Is this true?
+                DBUG_ON(ch->reason == xpcInterrupted);
         } else if (ret == 0) {
                 ret = xpcTimeout;
         } else {
@@ -1685,9 +1657,9 @@ xpc_allocate_msg(struct xpc_channel *ch, u32 flags,
 
         while (1) {
 
-                put = (volatile s64)ch->w_local_GP.put;
-                if (put - (volatile s64)ch->w_remote_GP.get <
-                    ch->local_nentries) {
+                put = ch->w_local_GP.put;
+                rmb();  /* guarantee that .put loads before .get */
+                if (put - ch->w_remote_GP.get < ch->local_nentries) {
 
                         /* There are available message entries. We need to try
                          * to secure one for ourselves. We'll do this by trying
@@ -1711,9 +1683,8 @@ xpc_allocate_msg(struct xpc_channel *ch, u32 flags,
                  * that will cause the IPI handler to fetch the latest
                  * GP values as if an IPI was sent by the other side.
                  */
-                if (ret == xpcTimeout) {
+                if (ret == xpcTimeout)
                         xpc_IPI_send_local_msgrequest(ch);
-                }
 
                 if (flags & XPC_NOWAIT) {
                         xpc_msgqueue_deref(ch);
@@ -1772,9 +1743,8 @@ xpc_initiate_allocate(partid_t partid, int ch_number, u32 flags, void **payload)
                 ret = xpc_allocate_msg(&part->channels[ch_number], flags, &msg);
                 xpc_part_deref(part);
 
-                if (msg != NULL) {
+                if (msg != NULL)
                         *payload = &msg->payload;
-                }
         }
 
         return ret;
@@ -1795,17 +1765,15 @@ xpc_send_msgs(struct xpc_channel *ch, s64 initial_put)
         while (1) {
 
                 while (1) {
-                        if (put == (volatile s64)ch->w_local_GP.put) {
+                        if (put == ch->w_local_GP.put)
                                 break;
-                        }
 
                         msg = (struct xpc_msg *)((u64)ch->local_msgqueue +
                                                  (put % ch->local_nentries) *
                                                  ch->msg_size);
 
-                        if (!(msg->flags & XPC_M_READY)) {
+                        if (!(msg->flags & XPC_M_READY))
                                 break;
-                        }
 
                         put++;
                 }
@@ -1818,7 +1786,7 @@ xpc_send_msgs(struct xpc_channel *ch, s64 initial_put)
                 if (cmpxchg_rel(&ch->local_GP->put, initial_put, put) !=
                     initial_put) {
                         /* someone else beat us to it */
-                        DBUG_ON((volatile s64)ch->local_GP->put < initial_put);
+                        DBUG_ON(ch->local_GP->put < initial_put);
                         break;
                 }
 
@@ -1837,9 +1805,8 @@ xpc_send_msgs(struct xpc_channel *ch, s64 initial_put)
                 initial_put = put;
         }
 
-        if (send_IPI) {
+        if (send_IPI)
                 xpc_IPI_send_msgrequest(ch);
-        }
 }
 
 /*
@@ -1880,7 +1847,7 @@ xpc_send_msg(struct xpc_channel *ch, struct xpc_msg *msg, u8 notify_type,
                 notify->key = key;
                 notify->type = notify_type;
 
-                // >>> is a mb() needed here?
+                /* >>> is a mb() needed here? */
 
                 if (ch->flags & XPC_C_DISCONNECTING) {
                         /*
@@ -1913,9 +1880,8 @@ xpc_send_msg(struct xpc_channel *ch, struct xpc_msg *msg, u8 notify_type,
         /* see if the message is next in line to be sent, if so send it */
 
         put = ch->local_GP->put;
-        if (put == msg_number) {
+        if (put == msg_number)
                 xpc_send_msgs(ch, put);
-        }
 
         /* drop the reference grabbed in xpc_allocate_msg() */
         xpc_msgqueue_deref(ch);
@@ -2032,10 +1998,8 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
 
                 msg_index = ch->next_msg_to_pull % ch->remote_nentries;
 
-                DBUG_ON(ch->next_msg_to_pull >=
-                        (volatile s64)ch->w_remote_GP.put);
-                nmsgs = (volatile s64)ch->w_remote_GP.put -
-                    ch->next_msg_to_pull;
+                DBUG_ON(ch->next_msg_to_pull >= ch->w_remote_GP.put);
+                nmsgs = ch->w_remote_GP.put - ch->next_msg_to_pull;
                 if (msg_index + nmsgs > ch->remote_nentries) {
                         /* ignore the ones that wrap the msg queue for now */
                         nmsgs = ch->remote_nentries - msg_index;
@@ -2046,9 +2010,9 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
                 remote_msg = (struct xpc_msg *)(ch->remote_msgqueue_pa +
                                                 msg_offset);
 
-                if ((ret = xpc_pull_remote_cachelines(part, msg, remote_msg,
-                                                      nmsgs * ch->msg_size)) !=
-                    xpcSuccess) {
+                ret = xpc_pull_remote_cachelines(part, msg, remote_msg,
+                                                 nmsgs * ch->msg_size);
+                if (ret != xpcSuccess) {
 
                         dev_dbg(xpc_chan, "failed to pull %d msgs starting with"
                                 " msg %ld from partition %d, channel=%d, "
@@ -2061,8 +2025,6 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
                         return NULL;
                 }
 
-                mb();           /* >>> this may not be needed, we're not sure */
-
                 ch->next_msg_to_pull += nmsgs;
         }
 
@@ -2085,14 +2047,13 @@ xpc_get_deliverable_msg(struct xpc_channel *ch)
         s64 get;
 
         do {
-                if ((volatile u32)ch->flags & XPC_C_DISCONNECTING) {
+                if (ch->flags & XPC_C_DISCONNECTING)
                         break;
-                }
 
-                get = (volatile s64)ch->w_local_GP.get;
-                if (get == (volatile s64)ch->w_remote_GP.put) {
+                get = ch->w_local_GP.get;
+                rmb();  /* guarantee that .get loads before .put */
+                if (get == ch->w_remote_GP.put)
                         break;
-                }
 
                 /* There are messages waiting to be pulled and delivered.
                  * We need to try to secure one for ourselves. We'll do this
@@ -2132,7 +2093,8 @@ xpc_deliver_msg(struct xpc_channel *ch)
 {
         struct xpc_msg *msg;
 
-        if ((msg = xpc_get_deliverable_msg(ch)) != NULL) {
+        msg = xpc_get_deliverable_msg(ch);
+        if (msg != NULL) {
 
                 /*
                  * This ref is taken to protect the payload itself from being
@@ -2178,17 +2140,15 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
         while (1) {
 
                 while (1) {
-                        if (get == (volatile s64)ch->w_local_GP.get) {
+                        if (get == ch->w_local_GP.get)
                                 break;
-                        }
 
                         msg = (struct xpc_msg *)((u64)ch->remote_msgqueue +
                                                  (get % ch->remote_nentries) *
                                                  ch->msg_size);
 
-                        if (!(msg->flags & XPC_M_DONE)) {
+                        if (!(msg->flags & XPC_M_DONE))
                                 break;
-                        }
 
                         msg_flags |= msg->flags;
                         get++;
@@ -2202,7 +2162,7 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
                 if (cmpxchg_rel(&ch->local_GP->get, initial_get, get) !=
                     initial_get) {
                         /* someone else beat us to it */
-                        DBUG_ON((volatile s64)ch->local_GP->get <= initial_get);
+                        DBUG_ON(ch->local_GP->get <= initial_get);
                         break;
                 }
 
@@ -2221,9 +2181,8 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
                 initial_get = get;
         }
 
-        if (send_IPI) {
+        if (send_IPI)
                 xpc_IPI_send_msgrequest(ch);
-        }
 }
 
 /*
@@ -2276,9 +2235,8 @@ xpc_initiate_received(partid_t partid, int ch_number, void *payload)
          * been delivered.
          */
         get = ch->local_GP->get;
-        if (get == msg_number) {
+        if (get == msg_number)
                 xpc_acknowledge_msgs(ch, get, msg->flags);
-        }
 
         /* the call to xpc_msgqueue_ref() was done by xpc_deliver_msg()  */
         xpc_msgqueue_deref(ch);