sgi-xp: isolate allocation of XPC's msgqueues to sn2 only

Move the allocation of XPC's msgqueues to xpc_sn2.c.

Signed-off-by: Dean Nelson <dcn@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 193 insertions, 12 deletions

diff --git a/drivers/misc/sgi-xp/xpc_sn2.c b/drivers/misc/sgi-xp/xpc_sn2.c
index 01dd40ec2a89..e5dc8c44c6fb 100644
--- a/drivers/misc/sgi-xp/xpc_sn2.c
+++ b/drivers/misc/sgi-xp/xpc_sn2.c
@@ -1049,6 +1049,30 @@ xpc_process_activate_IRQ_rcvd_sn2(int n_IRQs_expected)
 }
 
 /*
+ * Guarantee that the kzalloc'd memory is cacheline aligned.
+ */
+static void *
+xpc_kzalloc_cacheline_aligned_sn2(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)
+                return NULL;
+
+        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)
+                return NULL;
+
+        return (void *)L1_CACHE_ALIGN((u64)*base);
+}
+
+/*
  * Setup the infrastructure necessary to support XPartition Communication
  * between the specified remote partition and the local one.
  */
@@ -1078,10 +1102,9 @@ xpc_setup_infrastructure_sn2(struct xpc_partition *part)
 
         /* allocate all the required GET/PUT values */
 
-        part_sn2->local_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
-                                                            GFP_KERNEL,
-                                                            &part_sn2->
-                                                            local_GPs_base);
+        part_sn2->local_GPs =
+            xpc_kzalloc_cacheline_aligned_sn2(XPC_GP_SIZE, GFP_KERNEL,
+                                              &part_sn2->local_GPs_base);
         if (part_sn2->local_GPs == NULL) {
                 dev_err(xpc_chan, "can't get memory for local get/put "
                         "values\n");
@@ -1089,10 +1112,9 @@ xpc_setup_infrastructure_sn2(struct xpc_partition *part)
                 goto out_1;
         }
 
-        part_sn2->remote_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
-                                                             GFP_KERNEL,
-                                                             &part_sn2->
-                                                             remote_GPs_base);
+        part_sn2->remote_GPs =
+            xpc_kzalloc_cacheline_aligned_sn2(XPC_GP_SIZE, GFP_KERNEL,
+                                              &part_sn2->remote_GPs_base);
         if (part_sn2->remote_GPs == NULL) {
                 dev_err(xpc_chan, "can't get memory for remote get/put "
                         "values\n");
@@ -1105,8 +1127,9 @@ xpc_setup_infrastructure_sn2(struct xpc_partition *part)
         /* allocate all the required open and close args */
 
         part->local_openclose_args =
-            xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
-                                          &part->local_openclose_args_base);
+            xpc_kzalloc_cacheline_aligned_sn2(XPC_OPENCLOSE_ARGS_SIZE,
+                                              GFP_KERNEL,
+                                              &part->local_openclose_args_base);
         if (part->local_openclose_args == NULL) {
                 dev_err(xpc_chan, "can't get memory for local connect args\n");
                 retval = xpNoMemory;
@@ -1114,8 +1137,9 @@ xpc_setup_infrastructure_sn2(struct xpc_partition *part)
         }
 
         part->remote_openclose_args =
-            xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
-                                          &part->remote_openclose_args_base);
+            xpc_kzalloc_cacheline_aligned_sn2(XPC_OPENCLOSE_ARGS_SIZE,
+                                              GFP_KERNEL,
+                                             &part->remote_openclose_args_base);
         if (part->remote_openclose_args == NULL) {
                 dev_err(xpc_chan, "can't get memory for remote connect args\n");
                 retval = xpNoMemory;
@@ -1528,6 +1552,161 @@ xpc_get_chctl_all_flags_sn2(struct xpc_partition *part)
 }
 
 /*
+ * Allocate the local message queue and the notify queue.
+ */
+static enum xp_retval
+xpc_allocate_local_msgqueue_sn2(struct xpc_channel *ch)
+{
+        unsigned long irq_flags;
+        int nentries;
+        size_t nbytes;
+
+        for (nentries = ch->local_nentries; nentries > 0; nentries--) {
+
+                nbytes = nentries * ch->msg_size;
+                ch->local_msgqueue =
+                    xpc_kzalloc_cacheline_aligned_sn2(nbytes, GFP_KERNEL,
+                                                      &ch->local_msgqueue_base);
+                if (ch->local_msgqueue == NULL)
+                        continue;
+
+                nbytes = nentries * sizeof(struct xpc_notify);
+                ch->notify_queue = kzalloc(nbytes, GFP_KERNEL);
+                if (ch->notify_queue == NULL) {
+                        kfree(ch->local_msgqueue_base);
+                        ch->local_msgqueue = NULL;
+                        continue;
+                }
+
+                spin_lock_irqsave(&ch->lock, irq_flags);
+                if (nentries < ch->local_nentries) {
+                        dev_dbg(xpc_chan, "nentries=%d local_nentries=%d, "
+                                "partid=%d, channel=%d\n", nentries,
+                                ch->local_nentries, ch->partid, ch->number);
+
+                        ch->local_nentries = nentries;
+                }
+                spin_unlock_irqrestore(&ch->lock, irq_flags);
+                return xpSuccess;
+        }
+
+        dev_dbg(xpc_chan, "can't get memory for local message queue and notify "
+                "queue, partid=%d, channel=%d\n", ch->partid, ch->number);
+        return xpNoMemory;
+}
+
+/*
+ * Allocate the cached remote message queue.
+ */
+static enum xp_retval
+xpc_allocate_remote_msgqueue_sn2(struct xpc_channel *ch)
+{
+        unsigned long irq_flags;
+        int nentries;
+        size_t nbytes;
+
+        DBUG_ON(ch->remote_nentries <= 0);
+
+        for (nentries = ch->remote_nentries; nentries > 0; nentries--) {
+
+                nbytes = nentries * ch->msg_size;
+                ch->remote_msgqueue =
+                    xpc_kzalloc_cacheline_aligned_sn2(nbytes, GFP_KERNEL,
+                                                     &ch->remote_msgqueue_base);
+                if (ch->remote_msgqueue == NULL)
+                        continue;
+
+                spin_lock_irqsave(&ch->lock, irq_flags);
+                if (nentries < ch->remote_nentries) {
+                        dev_dbg(xpc_chan, "nentries=%d remote_nentries=%d, "
+                                "partid=%d, channel=%d\n", nentries,
+                                ch->remote_nentries, ch->partid, ch->number);
+
+                        ch->remote_nentries = nentries;
+                }
+                spin_unlock_irqrestore(&ch->lock, irq_flags);
+                return xpSuccess;
+        }
+
+        dev_dbg(xpc_chan, "can't get memory for cached remote message queue, "
+                "partid=%d, channel=%d\n", ch->partid, ch->number);
+        return xpNoMemory;
+}
+
+/*
+ * Allocate message queues and other stuff associated with a channel.
+ *
+ * Note: Assumes all of the channel sizes are filled in.
+ */
+static enum xp_retval
+xpc_allocate_msgqueues_sn2(struct xpc_channel *ch)
+{
+        enum xp_retval ret;
+
+        DBUG_ON(ch->flags & XPC_C_SETUP);
+
+        ret = xpc_allocate_local_msgqueue_sn2(ch);
+        if (ret == xpSuccess) {
+
+                ret = xpc_allocate_remote_msgqueue_sn2(ch);
+                if (ret != xpSuccess) {
+                        kfree(ch->local_msgqueue_base);
+                        ch->local_msgqueue = NULL;
+                        kfree(ch->notify_queue);
+                        ch->notify_queue = NULL;
+                }
+        }
+        return ret;
+}
+
+/*
+ * Free up message queues and other stuff that were allocated for the specified
+ * channel.
+ *
+ * Note: ch->reason and ch->reason_line are left set for debugging purposes,
+ * they're cleared when XPC_C_DISCONNECTED is cleared.
+ */
+static void
+xpc_free_msgqueues_sn2(struct xpc_channel *ch)
+{
+        struct xpc_channel_sn2 *ch_sn2 = &ch->sn.sn2;
+
+        DBUG_ON(!spin_is_locked(&ch->lock));
+        DBUG_ON(atomic_read(&ch->n_to_notify) != 0);
+
+        ch->remote_msgqueue_pa = 0;
+        ch->func = NULL;
+        ch->key = NULL;
+        ch->msg_size = 0;
+        ch->local_nentries = 0;
+        ch->remote_nentries = 0;
+        ch->kthreads_assigned_limit = 0;
+        ch->kthreads_idle_limit = 0;
+
+        ch_sn2->local_GP->get = 0;
+        ch_sn2->local_GP->put = 0;
+        ch_sn2->remote_GP.get = 0;
+        ch_sn2->remote_GP.put = 0;
+        ch_sn2->w_local_GP.get = 0;
+        ch_sn2->w_local_GP.put = 0;
+        ch_sn2->w_remote_GP.get = 0;
+        ch_sn2->w_remote_GP.put = 0;
+        ch_sn2->next_msg_to_pull = 0;
+
+        if (ch->flags & XPC_C_SETUP) {
+                dev_dbg(xpc_chan, "ch->flags=0x%x, partid=%d, channel=%d\n",
+                        ch->flags, ch->partid, ch->number);
+
+                kfree(ch->local_msgqueue_base);
+                ch->local_msgqueue = NULL;
+                kfree(ch->remote_msgqueue_base);
+                ch->remote_msgqueue = NULL;
+                kfree(ch->notify_queue);
+                ch->notify_queue = NULL;
+        }
+}
+
+/*
  * Notify those who wanted to be notified upon delivery of their message.
  */
 static void
@@ -2177,6 +2356,8 @@ xpc_init_sn2(void)
         xpc_teardown_infrastructure = xpc_teardown_infrastructure_sn2;
         xpc_make_first_contact = xpc_make_first_contact_sn2;
         xpc_get_chctl_all_flags = xpc_get_chctl_all_flags_sn2;
+        xpc_allocate_msgqueues = xpc_allocate_msgqueues_sn2;
+        xpc_free_msgqueues = xpc_free_msgqueues_sn2;
         xpc_notify_senders_of_disconnect = xpc_notify_senders_of_disconnect_sn2;
         xpc_process_msg_chctl_flags = xpc_process_msg_chctl_flags_sn2;
         xpc_n_of_deliverable_msgs = xpc_n_of_deliverable_msgs_sn2;