2 files changed, 138 insertions, 42 deletions

diff --git a/net/iucv/af_iucv.c b/net/iucv/af_iucv.c
index 29f7baa25110..af3192d2a5a3 100644
--- a/net/iucv/af_iucv.c
+++ b/net/iucv/af_iucv.c
@@ -8,6 +8,9 @@
  *  Author(s):  Jennifer Hunt <jenhunt@us.ibm.com>
  */
 
+#define KMSG_COMPONENT "af_iucv"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/list.h>
@@ -616,6 +619,8 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
         struct iucv_sock *iucv = iucv_sk(sk);
         struct sk_buff *skb;
         struct iucv_message txmsg;
+        char user_id[9];
+        char appl_id[9];
         int err;
 
         err = sock_error(sk);
@@ -651,8 +656,15 @@ static int iucv_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
                 err = iucv_message_send(iucv->path, &txmsg, 0, 0,
                                         (void *) skb->data, skb->len);
                 if (err) {
-                        if (err == 3)
-                                printk(KERN_ERR "AF_IUCV msg limit exceeded\n");
+                        if (err == 3) {
+                                user_id[8] = 0;
+                                memcpy(user_id, iucv->dst_user_id, 8);
+                                appl_id[8] = 0;
+                                memcpy(appl_id, iucv->dst_name, 8);
+                                pr_err("Application %s on z/VM guest %s"
+                                       " exceeds message limit\n",
+                                       user_id, appl_id);
+                        }
                         skb_unlink(skb, &iucv->send_skb_q);
                         err = -EPIPE;
                         goto fail;
@@ -1190,7 +1202,8 @@ static int __init afiucv_init(void)
         int err;
 
         if (!MACHINE_IS_VM) {
-                printk(KERN_ERR "AF_IUCV connection needs VM as base\n");
+                pr_err("The af_iucv module cannot be loaded"
+                       " without z/VM\n");
                 err = -EPROTONOSUPPORT;
                 goto out;
         }
diff --git a/net/iucv/iucv.c b/net/iucv/iucv.c
index d7b54b5bfa69..8f57d4f4328a 100644
--- a/net/iucv/iucv.c
+++ b/net/iucv/iucv.c
@@ -30,6 +30,9 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define KMSG_COMPONENT "iucv"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/spinlock.h>
@@ -424,8 +427,8 @@ static void iucv_declare_cpu(void *data)
                         err = "Paging or storage error";
                         break;
                 }
-                printk(KERN_WARNING "iucv_register: iucv_declare_buffer "
-                       "on cpu %i returned error 0x%02x (%s)\n", cpu, rc, err);
+                pr_warning("Defining an interrupt buffer on CPU %i"
+                           " failed with 0x%02x (%s)\n", cpu, rc, err);
                 return;
         }
 
@@ -957,7 +960,52 @@ int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
 EXPORT_SYMBOL(iucv_message_purge);
 
 /**
- * iucv_message_receive
+ * iucv_message_receive_iprmdata
+ * @path: address of iucv path structure
+ * @msg: address of iucv msg structure
+ * @flags: how the message is received (IUCV_IPBUFLST)
+ * @buffer: address of data buffer or address of struct iucv_array
+ * @size: length of data buffer
+ * @residual:
+ *
+ * Internal function used by iucv_message_receive and __iucv_message_receive
+ * to receive RMDATA data stored in struct iucv_message.
+ */
+static int iucv_message_receive_iprmdata(struct iucv_path *path,
+                                         struct iucv_message *msg,
+                                         u8 flags, void *buffer,
+                                         size_t size, size_t *residual)
+{
+        struct iucv_array *array;
+        u8 *rmmsg;
+        size_t copy;
+
+        /*
+         * Message is 8 bytes long and has been stored to the
+         * message descriptor itself.
+         */
+        if (residual)
+                *residual = abs(size - 8);
+        rmmsg = msg->rmmsg;
+        if (flags & IUCV_IPBUFLST) {
+                /* Copy to struct iucv_array. */
+                size = (size < 8) ? size : 8;
+                for (array = buffer; size > 0; array++) {
+                        copy = min_t(size_t, size, array->length);
+                        memcpy((u8 *)(addr_t) array->address,
+                                rmmsg, copy);
+                        rmmsg += copy;
+                        size -= copy;
+                }
+        } else {
+                /* Copy to direct buffer. */
+                memcpy(buffer, rmmsg, min_t(size_t, size, 8));
+        }
+        return 0;
+}
+
+/**
+ * __iucv_message_receive
  * @path: address of iucv path structure
  * @msg: address of iucv msg structure
  * @flags: how the message is received (IUCV_IPBUFLST)
@@ -969,44 +1017,19 @@ EXPORT_SYMBOL(iucv_message_purge);
  * established paths. This function will deal with RMDATA messages
  * embedded in struct iucv_message as well.
  *
+ * Locking:     no locking
+ *
  * Returns the result from the CP IUCV call.
  */
-int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
-                         u8 flags, void *buffer, size_t size, size_t *residual)
+int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
+                           u8 flags, void *buffer, size_t size, size_t *residual)
 {
         union iucv_param *parm;
-        struct iucv_array *array;
-        u8 *rmmsg;
-        size_t copy;
         int rc;
 
-        if (msg->flags & IUCV_IPRMDATA) {
-                /*
-                 * Message is 8 bytes long and has been stored to the
-                 * message descriptor itself.
-                 */
-                rc = (size < 8) ? 5 : 0;
-                if (residual)
-                        *residual = abs(size - 8);
-                rmmsg = msg->rmmsg;
-                if (flags & IUCV_IPBUFLST) {
-                        /* Copy to struct iucv_array. */
-                        size = (size < 8) ? size : 8;
-                        for (array = buffer; size > 0; array++) {
-                                copy = min_t(size_t, size, array->length);
-                                memcpy((u8 *)(addr_t) array->address,
-                                       rmmsg, copy);
-                                rmmsg += copy;
-                                size -= copy;
-                        }
-                } else {
-                        /* Copy to direct buffer. */
-                        memcpy(buffer, rmmsg, min_t(size_t, size, 8));
-                }
-                return 0;
-        }
-
-        local_bh_disable();
+        if (msg->flags & IUCV_IPRMDATA)
+                return iucv_message_receive_iprmdata(path, msg, flags,
+                                                     buffer, size, residual);
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         parm->db.ipbfadr1 = (u32)(addr_t) buffer;
@@ -1022,6 +1045,37 @@ int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
                 if (residual)
                         *residual = parm->db.ipbfln1f;
         }
+        return rc;
+}
+EXPORT_SYMBOL(__iucv_message_receive);
+
+/**
+ * iucv_message_receive
+ * @path: address of iucv path structure
+ * @msg: address of iucv msg structure
+ * @flags: how the message is received (IUCV_IPBUFLST)
+ * @buffer: address of data buffer or address of struct iucv_array
+ * @size: length of data buffer
+ * @residual:
+ *
+ * This function receives messages that are being sent to you over
+ * established paths. This function will deal with RMDATA messages
+ * embedded in struct iucv_message as well.
+ *
+ * Locking:     local_bh_enable/local_bh_disable
+ *
+ * Returns the result from the CP IUCV call.
+ */
+int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
+                         u8 flags, void *buffer, size_t size, size_t *residual)
+{
+        int rc;
+
+        if (msg->flags & IUCV_IPRMDATA)
+                return iucv_message_receive_iprmdata(path, msg, flags,
+                                                     buffer, size, residual);
+        local_bh_disable();
+        rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
         local_bh_enable();
         return rc;
 }
@@ -1101,7 +1155,7 @@ int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
 EXPORT_SYMBOL(iucv_message_reply);
 
 /**
- * iucv_message_send
+ * __iucv_message_send
  * @path: address of iucv path structure
  * @msg: address of iucv msg structure
  * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
@@ -1113,15 +1167,16 @@ EXPORT_SYMBOL(iucv_message_reply);
  * transmitted is in a buffer and this is a one-way message and the
  * receiver will not reply to the message.
  *
+ * Locking:     no locking
+ *
  * Returns the result from the CP IUCV call.
  */
-int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
+int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
                       u8 flags, u32 srccls, void *buffer, size_t size)
 {
         union iucv_param *parm;
         int rc;
 
-        local_bh_disable();
         parm = iucv_param[smp_processor_id()];
         memset(parm, 0, sizeof(union iucv_param));
         if (flags & IUCV_IPRMDATA) {
@@ -1144,6 +1199,34 @@ int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
         rc = iucv_call_b2f0(IUCV_SEND, parm);
         if (!rc)
                 msg->id = parm->db.ipmsgid;
+        return rc;
+}
+EXPORT_SYMBOL(__iucv_message_send);
+
+/**
+ * iucv_message_send
+ * @path: address of iucv path structure
+ * @msg: address of iucv msg structure
+ * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
+ * @srccls: source class of message
+ * @buffer: address of send buffer or address of struct iucv_array
+ * @size: length of send buffer
+ *
+ * This function transmits data to another application. Data to be
+ * transmitted is in a buffer and this is a one-way message and the
+ * receiver will not reply to the message.
+ *
+ * Locking:     local_bh_enable/local_bh_disable
+ *
+ * Returns the result from the CP IUCV call.
+ */
+int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
+                      u8 flags, u32 srccls, void *buffer, size_t size)
+{
+        int rc;
+
+        local_bh_disable();
+        rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
         local_bh_enable();
         return rc;
 }
@@ -1572,7 +1655,7 @@ static void iucv_external_interrupt(u16 code)
         BUG_ON(p->iptype  < 0x01 || p->iptype > 0x09);
         work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
         if (!work) {
-                printk(KERN_WARNING "iucv_external_interrupt: out of memory\n");
+                pr_warning("iucv_external_interrupt: out of memory\n");
                 return;
         }
         memcpy(&work->data, p, sizeof(work->data));