sgi-xp: isolate xpc_vars_part structure to sn2 only

Isolate the xpc_vars_part structure of XPC's reserved page to sn2 only.

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, 1 insertions, 537 deletions

diff --git a/drivers/misc/sgi-xp/xpc_channel.c b/drivers/misc/sgi-xp/xpc_channel.c
index 9e79ad7eafe..8081e8155df 100644
--- a/drivers/misc/sgi-xp/xpc_channel.c
+++ b/drivers/misc/sgi-xp/xpc_channel.c
@@ -27,7 +27,7 @@
 /*
  * Guarantee that the kzalloc'd memory is cacheline aligned.
  */
-static void *
+void *
 xpc_kzalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
 {
         /* see if kzalloc will give us cachline aligned memory by default */
@@ -49,382 +49,6 @@ xpc_kzalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
 }
 
 /*
- * Set up the initial values for the XPartition Communication channels.
- */
-static void
-xpc_initialize_channels(struct xpc_partition *part, short partid)
-{
-        int ch_number;
-        struct xpc_channel *ch;
-
-        for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
-                ch = &part->channels[ch_number];
-
-                ch->partid = partid;
-                ch->number = ch_number;
-                ch->flags = XPC_C_DISCONNECTED;
-
-                ch->local_GP = &part->local_GPs[ch_number];
-                ch->local_openclose_args =
-                    &part->local_openclose_args[ch_number];
-
-                atomic_set(&ch->kthreads_assigned, 0);
-                atomic_set(&ch->kthreads_idle, 0);
-                atomic_set(&ch->kthreads_active, 0);
-
-                atomic_set(&ch->references, 0);
-                atomic_set(&ch->n_to_notify, 0);
-
-                spin_lock_init(&ch->lock);
-                mutex_init(&ch->msg_to_pull_mutex);
-                init_completion(&ch->wdisconnect_wait);
-
-                atomic_set(&ch->n_on_msg_allocate_wq, 0);
-                init_waitqueue_head(&ch->msg_allocate_wq);
-                init_waitqueue_head(&ch->idle_wq);
-        }
-}
-
-/*
- * Setup the infrastructure necessary to support XPartition Communication
- * between the specified remote partition and the local one.
- */
-enum xp_retval
-xpc_setup_infrastructure(struct xpc_partition *part)
-{
-        int ret, cpuid;
-        struct timer_list *timer;
-        short partid = XPC_PARTID(part);
-
-        /*
-         * Zero out MOST of the entry for this partition. Only the fields
-         * starting with `nchannels' will be zeroed. The preceding fields must
-         * remain `viable' across partition ups and downs, since they may be
-         * referenced during this memset() operation.
-         */
-        memset(&part->nchannels, 0, sizeof(struct xpc_partition) -
-               offsetof(struct xpc_partition, nchannels));
-
-        /*
-         * Allocate all of the channel structures as a contiguous chunk of
-         * memory.
-         */
-        part->channels = kzalloc(sizeof(struct xpc_channel) * XPC_MAX_NCHANNELS,
-                                 GFP_KERNEL);
-        if (part->channels == NULL) {
-                dev_err(xpc_chan, "can't get memory for channels\n");
-                return xpNoMemory;
-        }
-
-        part->nchannels = XPC_MAX_NCHANNELS;
-
-        /* allocate all the required GET/PUT values */
-
-        part->local_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
-                                                        GFP_KERNEL,
-                                                        &part->local_GPs_base);
-        if (part->local_GPs == NULL) {
-                kfree(part->channels);
-                part->channels = NULL;
-                dev_err(xpc_chan, "can't get memory for local get/put "
-                        "values\n");
-                return xpNoMemory;
-        }
-
-        part->remote_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
-                                                         GFP_KERNEL,
-                                                         &part->
-                                                         remote_GPs_base);
-        if (part->remote_GPs == NULL) {
-                dev_err(xpc_chan, "can't get memory for remote get/put "
-                        "values\n");
-                kfree(part->local_GPs_base);
-                part->local_GPs = NULL;
-                kfree(part->channels);
-                part->channels = NULL;
-                return xpNoMemory;
-        }
-
-        /* 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);
-        if (part->local_openclose_args == NULL) {
-                dev_err(xpc_chan, "can't get memory for local connect args\n");
-                kfree(part->remote_GPs_base);
-                part->remote_GPs = NULL;
-                kfree(part->local_GPs_base);
-                part->local_GPs = NULL;
-                kfree(part->channels);
-                part->channels = NULL;
-                return xpNoMemory;
-        }
-
-        part->remote_openclose_args =
-            xpc_kzalloc_cacheline_aligned(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");
-                kfree(part->local_openclose_args_base);
-                part->local_openclose_args = NULL;
-                kfree(part->remote_GPs_base);
-                part->remote_GPs = NULL;
-                kfree(part->local_GPs_base);
-                part->local_GPs = NULL;
-                kfree(part->channels);
-                part->channels = NULL;
-                return xpNoMemory;
-        }
-
-        xpc_initialize_channels(part, partid);
-
-        atomic_set(&part->nchannels_active, 0);
-        atomic_set(&part->nchannels_engaged, 0);
-
-        /* local_IPI_amo were set to 0 by an earlier memset() */
-
-        /* Initialize this partitions AMO_t structure */
-        part->local_IPI_amo_va = xpc_IPI_init(partid);
-
-        spin_lock_init(&part->IPI_lock);
-
-        atomic_set(&part->channel_mgr_requests, 1);
-        init_waitqueue_head(&part->channel_mgr_wq);
-
-        sprintf(part->IPI_owner, "xpc%02d", partid);
-        ret = request_irq(SGI_XPC_NOTIFY, xpc_notify_IRQ_handler, IRQF_SHARED,
-                          part->IPI_owner, (void *)(u64)partid);
-        if (ret != 0) {
-                dev_err(xpc_chan, "can't register NOTIFY IRQ handler, "
-                        "errno=%d\n", -ret);
-                kfree(part->remote_openclose_args_base);
-                part->remote_openclose_args = NULL;
-                kfree(part->local_openclose_args_base);
-                part->local_openclose_args = NULL;
-                kfree(part->remote_GPs_base);
-                part->remote_GPs = NULL;
-                kfree(part->local_GPs_base);
-                part->local_GPs = NULL;
-                kfree(part->channels);
-                part->channels = NULL;
-                return xpLackOfResources;
-        }
-
-        /* Setup a timer to check for dropped IPIs */
-        timer = &part->dropped_IPI_timer;
-        init_timer(timer);
-        timer->function = (void (*)(unsigned long))xpc_dropped_IPI_check;
-        timer->data = (unsigned long)part;
-        timer->expires = jiffies + XPC_P_DROPPED_IPI_WAIT;
-        add_timer(timer);
-
-        /*
-         * With the setting of the partition setup_state to XPC_P_SETUP, we're
-         * declaring that this partition is ready to go.
-         */
-        part->setup_state = XPC_P_SETUP;
-
-        /*
-         * Setup the per partition specific variables required by the
-         * remote partition to establish channel connections with us.
-         *
-         * The setting of the magic # indicates that these per partition
-         * specific variables are ready to be used.
-         */
-        xpc_vars_part[partid].GPs_pa = __pa(part->local_GPs);
-        xpc_vars_part[partid].openclose_args_pa =
-            __pa(part->local_openclose_args);
-        xpc_vars_part[partid].IPI_amo_pa = __pa(part->local_IPI_amo_va);
-        cpuid = raw_smp_processor_id(); /* any CPU in this partition will do */
-        xpc_vars_part[partid].IPI_nasid = cpuid_to_nasid(cpuid);
-        xpc_vars_part[partid].IPI_phys_cpuid = cpu_physical_id(cpuid);
-        xpc_vars_part[partid].nchannels = part->nchannels;
-        xpc_vars_part[partid].magic = XPC_VP_MAGIC1;
-
-        return xpSuccess;
-}
-
-/*
- * Create a wrapper that hides the underlying mechanism for pulling a cacheline
- * (or multiple cachelines) from a remote partition.
- *
- * src must be a cacheline aligned physical address on the remote partition.
- * dst must be a cacheline aligned virtual address on this partition.
- * cnt must be cacheline sized
- */
-static enum xp_retval
-xpc_pull_remote_cachelines(struct xpc_partition *part, void *dst,
-                           const void *src, size_t cnt)
-{
-        enum xp_retval ret;
-
-        DBUG_ON((u64)src != L1_CACHE_ALIGN((u64)src));
-        DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));
-        DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));
-
-        if (part->act_state == XPC_P_DEACTIVATING)
-                return part->reason;
-
-        ret = xp_remote_memcpy(dst, src, cnt);
-        if (ret != xpSuccess) {
-                dev_dbg(xpc_chan, "xp_remote_memcpy() from partition %d failed,"
-                        " ret=%d\n", XPC_PARTID(part), ret);
-        }
-        return ret;
-}
-
-/*
- * Pull the remote per partition specific variables from the specified
- * partition.
- */
-enum xp_retval
-xpc_pull_remote_vars_part(struct xpc_partition *part)
-{
-        u8 buffer[L1_CACHE_BYTES * 2];
-        struct xpc_vars_part *pulled_entry_cacheline =
-            (struct xpc_vars_part *)L1_CACHE_ALIGN((u64)buffer);
-        struct xpc_vars_part *pulled_entry;
-        u64 remote_entry_cacheline_pa, remote_entry_pa;
-        short partid = XPC_PARTID(part);
-        enum xp_retval ret;
-
-        /* pull the cacheline that contains the variables we're interested in */
-
-        DBUG_ON(part->remote_vars_part_pa !=
-                L1_CACHE_ALIGN(part->remote_vars_part_pa));
-        DBUG_ON(sizeof(struct xpc_vars_part) != L1_CACHE_BYTES / 2);
-
-        remote_entry_pa = part->remote_vars_part_pa +
-            sn_partition_id * sizeof(struct xpc_vars_part);
-
-        remote_entry_cacheline_pa = (remote_entry_pa & ~(L1_CACHE_BYTES - 1));
-
-        pulled_entry = (struct xpc_vars_part *)((u64)pulled_entry_cacheline +
-                                                (remote_entry_pa &
-                                                 (L1_CACHE_BYTES - 1)));
-
-        ret = xpc_pull_remote_cachelines(part, pulled_entry_cacheline,
-                                         (void *)remote_entry_cacheline_pa,
-                                         L1_CACHE_BYTES);
-        if (ret != xpSuccess) {
-                dev_dbg(xpc_chan, "failed to pull XPC vars_part from "
-                        "partition %d, ret=%d\n", partid, ret);
-                return ret;
-        }
-
-        /* see if they've been set up yet */
-
-        if (pulled_entry->magic != XPC_VP_MAGIC1 &&
-            pulled_entry->magic != XPC_VP_MAGIC2) {
-
-                if (pulled_entry->magic != 0) {
-                        dev_dbg(xpc_chan, "partition %d's XPC vars_part for "
-                                "partition %d has bad magic value (=0x%lx)\n",
-                                partid, sn_partition_id, pulled_entry->magic);
-                        return xpBadMagic;
-                }
-
-                /* they've not been initialized yet */
-                return xpRetry;
-        }
-
-        if (xpc_vars_part[partid].magic == XPC_VP_MAGIC1) {
-
-                /* validate the variables */
-
-                if (pulled_entry->GPs_pa == 0 ||
-                    pulled_entry->openclose_args_pa == 0 ||
-                    pulled_entry->IPI_amo_pa == 0) {
-
-                        dev_err(xpc_chan, "partition %d's XPC vars_part for "
-                                "partition %d are not valid\n", partid,
-                                sn_partition_id);
-                        return xpInvalidAddress;
-                }
-
-                /* the variables we imported look to be valid */
-
-                part->remote_GPs_pa = pulled_entry->GPs_pa;
-                part->remote_openclose_args_pa =
-                    pulled_entry->openclose_args_pa;
-                part->remote_IPI_amo_va =
-                    (AMO_t *)__va(pulled_entry->IPI_amo_pa);
-                part->remote_IPI_nasid = pulled_entry->IPI_nasid;
-                part->remote_IPI_phys_cpuid = pulled_entry->IPI_phys_cpuid;
-
-                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)
-                return xpRetry;
-
-        return xpSuccess;
-}
-
-/*
- * Get the IPI flags and pull the openclose args and/or remote GPs as needed.
- */
-static u64
-xpc_get_IPI_flags(struct xpc_partition *part)
-{
-        unsigned long irq_flags;
-        u64 IPI_amo;
-        enum xp_retval ret;
-
-        /*
-         * See if there are any IPI flags to be handled.
-         */
-
-        spin_lock_irqsave(&part->IPI_lock, irq_flags);
-        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)) {
-                ret = xpc_pull_remote_cachelines(part,
-                                                 part->remote_openclose_args,
-                                                 (void *)part->
-                                                 remote_openclose_args_pa,
-                                                 XPC_OPENCLOSE_ARGS_SIZE);
-                if (ret != xpSuccess) {
-                        XPC_DEACTIVATE_PARTITION(part, ret);
-
-                        dev_dbg(xpc_chan, "failed to pull openclose args from "
-                                "partition %d, ret=%d\n", XPC_PARTID(part),
-                                ret);
-
-                        /* don't bother processing IPIs anymore */
-                        IPI_amo = 0;
-                }
-        }
-
-        if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_amo)) {
-                ret = xpc_pull_remote_cachelines(part, part->remote_GPs,
-                                                 (void *)part->remote_GPs_pa,
-                                                 XPC_GP_SIZE);
-                if (ret != xpSuccess) {
-                        XPC_DEACTIVATE_PARTITION(part, ret);
-
-                        dev_dbg(xpc_chan, "failed to pull GPs from partition "
-                                "%d, ret=%d\n", XPC_PARTID(part), ret);
-
-                        /* don't bother processing IPIs anymore */
-                        IPI_amo = 0;
-                }
-        }
-
-        return IPI_amo;
-}
-
-/*
  * Allocate the local message queue and the notify queue.
  */
 static enum xp_retval
@@ -1365,59 +989,6 @@ xpc_partition_going_down(struct xpc_partition *part, enum xp_retval reason)
 }
 
 /*
- * Teardown the infrastructure necessary to support XPartition Communication
- * between the specified remote partition and the local one.
- */
-void
-xpc_teardown_infrastructure(struct xpc_partition *part)
-{
-        short partid = XPC_PARTID(part);
-
-        /*
-         * We start off by making this partition inaccessible to local
-         * processes by marking it as no longer setup. Then we make it
-         * inaccessible to remote processes by clearing the XPC per partition
-         * specific variable's magic # (which indicates that these variables
-         * are no longer valid) and by ignoring all XPC notify IPIs sent to
-         * this partition.
-         */
-
-        DBUG_ON(atomic_read(&part->nchannels_engaged) != 0);
-        DBUG_ON(atomic_read(&part->nchannels_active) != 0);
-        DBUG_ON(part->setup_state != XPC_P_SETUP);
-        part->setup_state = XPC_P_WTEARDOWN;
-
-        xpc_vars_part[partid].magic = 0;
-
-        free_irq(SGI_XPC_NOTIFY, (void *)(u64)partid);
-
-        /*
-         * Before proceeding with the teardown we have to wait until all
-         * existing references cease.
-         */
-        wait_event(part->teardown_wq, (atomic_read(&part->references) == 0));
-
-        /* now we can begin tearing down the infrastructure */
-
-        part->setup_state = XPC_P_TORNDOWN;
-
-        /* in case we've still got outstanding timers registered... */
-        del_timer_sync(&part->dropped_IPI_timer);
-
-        kfree(part->remote_openclose_args_base);
-        part->remote_openclose_args = NULL;
-        kfree(part->local_openclose_args_base);
-        part->local_openclose_args = NULL;
-        kfree(part->remote_GPs_base);
-        part->remote_GPs = NULL;
-        kfree(part->local_GPs_base);
-        part->local_GPs = NULL;
-        kfree(part->channels);
-        part->channels = NULL;
-        part->local_IPI_amo_va = NULL;
-}
-
-/*
  * Called by XP at the time of channel connection registration to cause
  * XPC to establish connections to all currently active partitions.
  */
@@ -1974,113 +1545,6 @@ xpc_initiate_send_notify(short partid, int ch_number, void *payload,
         return ret;
 }
 
-static struct xpc_msg *
-xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
-{
-        struct xpc_partition *part = &xpc_partitions[ch->partid];
-        struct xpc_msg *remote_msg, *msg;
-        u32 msg_index, nmsgs;
-        u64 msg_offset;
-        enum xp_retval ret;
-
-        if (mutex_lock_interruptible(&ch->msg_to_pull_mutex) != 0) {
-                /* we were interrupted by a signal */
-                return NULL;
-        }
-
-        while (get >= ch->next_msg_to_pull) {
-
-                /* pull as many messages as are ready and able to be pulled */
-
-                msg_index = ch->next_msg_to_pull % ch->remote_nentries;
-
-                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;
-                }
-
-                msg_offset = msg_index * ch->msg_size;
-                msg = (struct xpc_msg *)((u64)ch->remote_msgqueue + msg_offset);
-                remote_msg = (struct xpc_msg *)(ch->remote_msgqueue_pa +
-                                                msg_offset);
-
-                ret = xpc_pull_remote_cachelines(part, msg, remote_msg,
-                                                 nmsgs * ch->msg_size);
-                if (ret != xpSuccess) {
-
-                        dev_dbg(xpc_chan, "failed to pull %d msgs starting with"
-                                " msg %ld from partition %d, channel=%d, "
-                                "ret=%d\n", nmsgs, ch->next_msg_to_pull,
-                                ch->partid, ch->number, ret);
-
-                        XPC_DEACTIVATE_PARTITION(part, ret);
-
-                        mutex_unlock(&ch->msg_to_pull_mutex);
-                        return NULL;
-                }
-
-                ch->next_msg_to_pull += nmsgs;
-        }
-
-        mutex_unlock(&ch->msg_to_pull_mutex);
-
-        /* return the message we were looking for */
-        msg_offset = (get % ch->remote_nentries) * ch->msg_size;
-        msg = (struct xpc_msg *)((u64)ch->remote_msgqueue + msg_offset);
-
-        return msg;
-}
-
-/*
- * Get a message to be delivered.
- */
-static struct xpc_msg *
-xpc_get_deliverable_msg(struct xpc_channel *ch)
-{
-        struct xpc_msg *msg = NULL;
-        s64 get;
-
-        do {
-                if (ch->flags & XPC_C_DISCONNECTING)
-                        break;
-
-                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
-                 * by trying to increment w_local_GP.get and hope that no one
-                 * else beats us to it. If they do, we'll we'll simply have
-                 * to try again for the next one.
-                 */
-
-                if (cmpxchg(&ch->w_local_GP.get, get, get + 1) == get) {
-                        /* we got the entry referenced by get */
-
-                        dev_dbg(xpc_chan, "w_local_GP.get changed to %ld, "
-                                "partid=%d, channel=%d\n", get + 1,
-                                ch->partid, ch->number);
-
-                        /* pull the message from the remote partition */
-
-                        msg = xpc_pull_remote_msg(ch, get);
-
-                        DBUG_ON(msg != NULL && msg->number != get);
-                        DBUG_ON(msg != NULL && (msg->flags & XPC_M_DONE));
-                        DBUG_ON(msg != NULL && !(msg->flags & XPC_M_READY));
-
-                        break;
-                }
-
-        } while (1);
-
-        return msg;
-}
-
 /*
  * Deliver a message to its intended recipient.
  */