6 files changed, 75 insertions, 55 deletions

diff --git a/net/iucv/iucv.c b/net/iucv/iucv.c
index a2f5a6ea389..7698f6c459d 100644
--- a/net/iucv/iucv.c
+++ b/net/iucv/iucv.c
@@ -97,7 +97,7 @@ struct iucv_irq_list {
         struct iucv_irq_data data;
 };
 
-static struct iucv_irq_data *iucv_irq_data;
+static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
 static cpumask_t iucv_buffer_cpumask = CPU_MASK_NONE;
 static cpumask_t iucv_irq_cpumask = CPU_MASK_NONE;
 
@@ -277,7 +277,7 @@ union iucv_param {
 /*
  * Anchor for per-cpu IUCV command parameter block.
  */
-static union iucv_param *iucv_param;
+static union iucv_param *iucv_param[NR_CPUS];
 
 /**
  * iucv_call_b2f0
@@ -356,7 +356,7 @@ static void iucv_allow_cpu(void *data)
          *      0x10 - Flag to allow priority message completion interrupts
          *      0x08 - Flag to allow IUCV control interrupts
          */
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         parm->set_mask.ipmask = 0xf8;
         iucv_call_b2f0(IUCV_SETMASK, parm);
@@ -377,7 +377,7 @@ static void iucv_block_cpu(void *data)
         union iucv_param *parm;
 
         /* Disable all iucv interrupts. */
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[cpu];
         memset(parm, 0, sizeof(union iucv_param));
         iucv_call_b2f0(IUCV_SETMASK, parm);
 
@@ -401,9 +401,9 @@ static void iucv_declare_cpu(void *data)
                 return;
 
         /* Declare interrupt buffer. */
-        parm = percpu_ptr(iucv_param, cpu);
+        parm = iucv_param[cpu];
         memset(parm, 0, sizeof(union iucv_param));
-        parm->db.ipbfadr1 = virt_to_phys(percpu_ptr(iucv_irq_data, cpu));
+        parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
         rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
         if (rc) {
                 char *err = "Unknown";
@@ -458,7 +458,7 @@ static void iucv_retrieve_cpu(void *data)
         iucv_block_cpu(NULL);
 
         /* Retrieve interrupt buffer. */
-        parm = percpu_ptr(iucv_param, cpu);
+        parm = iucv_param[cpu];
         iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
 
         /* Clear indication that an iucv buffer exists for this cpu. */
@@ -558,22 +558,23 @@ static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
         switch (action) {
         case CPU_UP_PREPARE:
         case CPU_UP_PREPARE_FROZEN:
-                if (!percpu_populate(iucv_irq_data,
-                                     sizeof(struct iucv_irq_data),
-                                     GFP_KERNEL|GFP_DMA, cpu))
+                iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
+                                        GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_irq_data[cpu])
                         return NOTIFY_BAD;
-                if (!percpu_populate(iucv_param, sizeof(union iucv_param),
-                                     GFP_KERNEL|GFP_DMA, cpu)) {
-                        percpu_depopulate(iucv_irq_data, cpu);
+                iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                     GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param[cpu])
                         return NOTIFY_BAD;
-                }
                 break;
         case CPU_UP_CANCELED:
         case CPU_UP_CANCELED_FROZEN:
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
-                percpu_depopulate(iucv_param, cpu);
-                percpu_depopulate(iucv_irq_data, cpu);
+                kfree(iucv_param[cpu]);
+                iucv_param[cpu] = NULL;
+                kfree(iucv_irq_data[cpu]);
+                iucv_irq_data[cpu] = NULL;
                 break;
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -612,7 +613,7 @@ static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
 {
         union iucv_param *parm;
 
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
@@ -755,7 +756,7 @@ int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
 
         local_bh_disable();
         /* Prepare parameter block. */
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->ctrl.ippathid = path->pathid;
         parm->ctrl.ipmsglim = path->msglim;
@@ -799,7 +800,7 @@ int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
         BUG_ON(in_atomic());
         spin_lock_bh(&iucv_table_lock);
         iucv_cleanup_queue();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->ctrl.ipmsglim = path->msglim;
         parm->ctrl.ipflags1 = path->flags;
@@ -854,7 +855,7 @@ int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
@@ -881,7 +882,7 @@ int iucv_path_resume(struct iucv_path *path, u8 userdata[16])
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (userdata)
                 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
@@ -936,7 +937,7 @@ int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->purge.ippathid = path->pathid;
         parm->purge.ipmsgid = msg->id;
@@ -1003,7 +1004,7 @@ int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
         }
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ipbfadr1 = (u32)(addr_t) buffer;
         parm->db.ipbfln1f = (u32) size;
@@ -1040,7 +1041,7 @@ int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ippathid = path->pathid;
         parm->db.ipmsgid = msg->id;
@@ -1074,7 +1075,7 @@ int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
                 parm->dpl.ippathid = path->pathid;
@@ -1118,7 +1119,7 @@ int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
                 /* Message of 8 bytes can be placed into the parameter list. */
@@ -1172,7 +1173,7 @@ int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
         int rc;
 
         local_bh_disable();
-        parm = percpu_ptr(iucv_param, smp_processor_id());
+        parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
                 parm->dpl.ippathid = path->pathid;
@@ -1559,7 +1560,7 @@ static void iucv_external_interrupt(u16 code)
         struct iucv_irq_data *p;
         struct iucv_irq_list *work;
 
-        p = percpu_ptr(iucv_irq_data, smp_processor_id());
+        p = iucv_irq_data[smp_processor_id()];
         if (p->ippathid >= iucv_max_pathid) {
                 printk(KERN_WARNING "iucv_do_int: Got interrupt with "
                        "pathid %d > max_connections (%ld)\n",
@@ -1598,6 +1599,7 @@ static void iucv_external_interrupt(u16 code)
 static int __init iucv_init(void)
 {
         int rc;
+        int cpu;
 
         if (!MACHINE_IS_VM) {
                 rc = -EPROTONOSUPPORT;
@@ -1617,19 +1619,23 @@ static int __init iucv_init(void)
                 rc = PTR_ERR(iucv_root);
                 goto out_bus;
         }
-        /* Note: GFP_DMA used to get memory below 2G */
-        iucv_irq_data = percpu_alloc(sizeof(struct iucv_irq_data),
-                                     GFP_KERNEL|GFP_DMA);
-        if (!iucv_irq_data) {
-                rc = -ENOMEM;
-                goto out_root;
-        }
-        /* Allocate parameter blocks. */
-        iucv_param = percpu_alloc(sizeof(union iucv_param),
-                                  GFP_KERNEL|GFP_DMA);
-        if (!iucv_param) {
-                rc = -ENOMEM;
-                goto out_extint;
+
+        for_each_online_cpu(cpu) {
+                /* Note: GFP_DMA used to get memory below 2G */
+                iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
+                                     GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_irq_data[cpu]) {
+                        rc = -ENOMEM;
+                        goto out_free;
+                }
+
+                /* Allocate parameter blocks. */
+                iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
+                                  GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
+                if (!iucv_param[cpu]) {
+                        rc = -ENOMEM;
+                        goto out_free;
+                }
         }
         register_hotcpu_notifier(&iucv_cpu_notifier);
         ASCEBC(iucv_error_no_listener, 16);
@@ -1638,9 +1644,13 @@ static int __init iucv_init(void)
         iucv_available = 1;
         return 0;
 
-out_extint:
-        percpu_free(iucv_irq_data);
-out_root:
+out_free:
+        for_each_possible_cpu(cpu) {
+                kfree(iucv_param[cpu]);
+                iucv_param[cpu] = NULL;
+                kfree(iucv_irq_data[cpu]);
+                iucv_irq_data[cpu] = NULL;
+        }
         s390_root_dev_unregister(iucv_root);
 out_bus:
         bus_unregister(&iucv_bus);
@@ -1658,6 +1668,7 @@ out:
 static void __exit iucv_exit(void)
 {
         struct iucv_irq_list *p, *n;
+        int cpu;
 
         spin_lock_irq(&iucv_queue_lock);
         list_for_each_entry_safe(p, n, &iucv_task_queue, list)
@@ -1666,8 +1677,12 @@ static void __exit iucv_exit(void)
                 kfree(p);
         spin_unlock_irq(&iucv_queue_lock);
         unregister_hotcpu_notifier(&iucv_cpu_notifier);
-        percpu_free(iucv_param);
-        percpu_free(iucv_irq_data);
+        for_each_possible_cpu(cpu) {
+                kfree(iucv_param[cpu]);
+                iucv_param[cpu] = NULL;
+                kfree(iucv_irq_data[cpu]);
+                iucv_irq_data[cpu] = NULL;
+        }
         s390_root_dev_unregister(iucv_root);
         bus_unregister(&iucv_bus);
         unregister_external_interrupt(0x4000, iucv_external_interrupt);
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 22906b80352..a6e57d1c2eb 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -540,7 +540,7 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
         p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
         if (IS_ERR(p)) {
                 err = PTR_ERR(p);
-                gss_msg->msg.errno = (err == -EACCES) ? -EACCES : -EAGAIN;
+                gss_msg->msg.errno = (err == -EAGAIN) ? -EAGAIN : -EACCES;
                 goto err_release_msg;
         }
         gss_msg->ctx = gss_get_ctx(ctx);
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 9843eacef11..60c3dba545d 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -147,13 +147,17 @@ gss_import_sec_context_kerberos(const void *p,
         p = simple_get_bytes(p, end, &tmp, sizeof(tmp));
         if (IS_ERR(p))
                 goto out_err_free_ctx;
-        if (tmp != SGN_ALG_DES_MAC_MD5)
+        if (tmp != SGN_ALG_DES_MAC_MD5) {
+                p = ERR_PTR(-ENOSYS);
                 goto out_err_free_ctx;
+        }
         p = simple_get_bytes(p, end, &tmp, sizeof(tmp));
         if (IS_ERR(p))
                 goto out_err_free_ctx;
-        if (tmp != SEAL_ALG_DES)
+        if (tmp != SEAL_ALG_DES) {
+                p = ERR_PTR(-ENOSYS);
                 goto out_err_free_ctx;
+        }
         p = simple_get_bytes(p, end, &ctx->endtime, sizeof(ctx->endtime));
         if (IS_ERR(p))
                 goto out_err_free_ctx;
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index 1c6eda5077c..dedcbd6108f 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -83,6 +83,7 @@ gss_get_mic_kerberos(struct gss_ctx *gss_ctx, struct xdr_buf *text,
         u32                     seq_send;
 
         dprintk("RPC:       gss_krb5_seal\n");
+        BUG_ON(ctx == NULL);
 
         now = get_seconds();
 
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 18f0a8dcc09..c59f3ca2b41 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -280,7 +280,7 @@ rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
         mask = POLLOUT | POLLWRNORM;
         if (rpci->ops == NULL)
                 mask |= POLLERR | POLLHUP;
-        if (!list_empty(&rpci->pipe))
+        if (filp->private_data || !list_empty(&rpci->pipe))
                 mask |= POLLIN | POLLRDNORM;
         return mask;
 }
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index 1afeb3eb8e4..6f2112dd9f7 100644
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -89,7 +89,7 @@ static struct ctl_table_header *sunrpc_table_header;
 
 static ctl_table xr_tunables_table[] = {
         {
-                .ctl_name       = CTL_SLOTTABLE_RDMA,
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "rdma_slot_table_entries",
                 .data           = &xprt_rdma_slot_table_entries,
                 .maxlen         = sizeof(unsigned int),
@@ -100,7 +100,7 @@ static ctl_table xr_tunables_table[] = {
                 .extra2         = &max_slot_table_size
         },
         {
-                .ctl_name       = CTL_RDMA_MAXINLINEREAD,
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "rdma_max_inline_read",
                 .data           = &xprt_rdma_max_inline_read,
                 .maxlen         = sizeof(unsigned int),
@@ -109,7 +109,7 @@ static ctl_table xr_tunables_table[] = {
                 .strategy       = &sysctl_intvec,
         },
         {
-                .ctl_name       = CTL_RDMA_MAXINLINEWRITE,
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "rdma_max_inline_write",
                 .data           = &xprt_rdma_max_inline_write,
                 .maxlen         = sizeof(unsigned int),
@@ -118,7 +118,7 @@ static ctl_table xr_tunables_table[] = {
                 .strategy       = &sysctl_intvec,
         },
         {
-                .ctl_name       = CTL_RDMA_WRITEPADDING,
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "rdma_inline_write_padding",
                 .data           = &xprt_rdma_inline_write_padding,
                 .maxlen         = sizeof(unsigned int),
@@ -129,7 +129,7 @@ static ctl_table xr_tunables_table[] = {
                 .extra2         = &max_padding,
         },
         {
-                .ctl_name       = CTL_RDMA_MEMREG,
+                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "rdma_memreg_strategy",
                 .data           = &xprt_rdma_memreg_strategy,
                 .maxlen         = sizeof(unsigned int),