12 files changed, 106 insertions, 85 deletions

diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
index c71d89dba302..83b4615a3b62 100644
--- a/drivers/s390/block/dasd_eer.c
+++ b/drivers/s390/block/dasd_eer.c
@@ -17,7 +17,6 @@
 #include <linux/device.h>
 #include <linux/poll.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index eb28fb01a38a..f6489eb7e976 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -14,7 +14,6 @@
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/types.h>
-#include <linux/smp_lock.h>
 
 #include <asm/compat.h>
 #include <asm/ccwdev.h>
diff --git a/drivers/s390/char/tape_char.c b/drivers/s390/char/tape_char.c
index 883e2db02bd3..e090a307fdee 100644
--- a/drivers/s390/char/tape_char.c
+++ b/drivers/s390/char/tape_char.c
@@ -17,7 +17,6 @@
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/mtio.h>
-#include <linux/smp_lock.h>
 #include <linux/compat.h>
 
 #include <asm/uaccess.h>
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index 6c408670e08d..b3a3e8e8656e 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -209,29 +209,79 @@ tape_state_set(struct tape_device *device, enum tape_state newstate)
         wake_up(&device->state_change_wq);
 }
 
+struct tape_med_state_work_data {
+        struct tape_device *device;
+        enum tape_medium_state state;
+        struct work_struct  work;
+};
+
+static void
+tape_med_state_work_handler(struct work_struct *work)
+{
+        static char env_state_loaded[] = "MEDIUM_STATE=LOADED";
+        static char env_state_unloaded[] = "MEDIUM_STATE=UNLOADED";
+        struct tape_med_state_work_data *p =
+                container_of(work, struct tape_med_state_work_data, work);
+        struct tape_device *device = p->device;
+        char *envp[] = { NULL, NULL };
+
+        switch (p->state) {
+        case MS_UNLOADED:
+                pr_info("%s: The tape cartridge has been successfully "
+                        "unloaded\n", dev_name(&device->cdev->dev));
+                envp[0] = env_state_unloaded;
+                kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
+                break;
+        case MS_LOADED:
+                pr_info("%s: A tape cartridge has been mounted\n",
+                        dev_name(&device->cdev->dev));
+                envp[0] = env_state_loaded;
+                kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
+                break;
+        default:
+                break;
+        }
+        tape_put_device(device);
+        kfree(p);
+}
+
+static void
+tape_med_state_work(struct tape_device *device, enum tape_medium_state state)
+{
+        struct tape_med_state_work_data *p;
+
+        p = kzalloc(sizeof(*p), GFP_ATOMIC);
+        if (p) {
+                INIT_WORK(&p->work, tape_med_state_work_handler);
+                p->device = tape_get_device(device);
+                p->state = state;
+                schedule_work(&p->work);
+        }
+}
+
 void
 tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
 {
-        if (device->medium_state == newstate)
+        enum tape_medium_state oldstate;
+
+        oldstate = device->medium_state;
+        if (oldstate == newstate)
                 return;
+        device->medium_state = newstate;
         switch(newstate){
         case MS_UNLOADED:
                 device->tape_generic_status |= GMT_DR_OPEN(~0);
-                if (device->medium_state == MS_LOADED)
-                        pr_info("%s: The tape cartridge has been successfully "
-                                "unloaded\n", dev_name(&device->cdev->dev));
+                if (oldstate == MS_LOADED)
+                        tape_med_state_work(device, MS_UNLOADED);
                 break;
         case MS_LOADED:
                 device->tape_generic_status &= ~GMT_DR_OPEN(~0);
-                if (device->medium_state == MS_UNLOADED)
-                        pr_info("%s: A tape cartridge has been mounted\n",
-                                dev_name(&device->cdev->dev));
+                if (oldstate == MS_UNLOADED)
+                        tape_med_state_work(device, MS_LOADED);
                 break;
         default:
-                // print nothing
                 break;
         }
-        device->medium_state = newstate;
         wake_up(&device->state_change_wq);
 }
 
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index 9f661426e4a1..c837d7419a6a 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -30,7 +30,6 @@
 #include <linux/kmod.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
-#include <linux/smp_lock.h>
 #include <linux/string.h>
 
 MODULE_AUTHOR
@@ -249,27 +248,25 @@ static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
         char cp_command[80];
         char cp_response[160];
         char *onoff, *qid_string;
+        int rc;
 
-        memset(cp_command, 0x00, sizeof(cp_command));
-        memset(cp_response, 0x00, sizeof(cp_response));
-
-        onoff = ((action == 1) ? "ON" : "OFF");
+        onoff = ((action == 1) ? "ON" : "OFF");
         qid_string = ((recording_class_AB == 1) ? " QID * " : "");
 
-        /*
+        /*
          * The recording commands needs to be called with option QID
          * for guests that have previlege classes A or B.
          * Purging has to be done as separate step, because recording
          * can't be switched on as long as records are on the queue.
          * Doing both at the same time doesn't work.
          */
-
-        if (purge) {
+        if (purge && (action == 1)) {
+                memset(cp_command, 0x00, sizeof(cp_command));
+                memset(cp_response, 0x00, sizeof(cp_response));
                 snprintf(cp_command, sizeof(cp_command),
                          "RECORDING %s PURGE %s",
                          logptr->recording_name,
                          qid_string);
-
                 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
         }
 
@@ -279,19 +276,33 @@ static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
                 logptr->recording_name,
                 onoff,
                 qid_string);
-
         cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
         /* The recording command will usually answer with 'Command complete'
          * on success, but when the specific service was never connected
          * before then there might be an additional informational message
          * 'HCPCRC8072I Recording entry not found' before the
-         * 'Command complete'. So I use strstr rather then the strncmp.
+         * 'Command complete'. So I use strstr rather then the strncmp.
          */
         if (strstr(cp_response,"Command complete"))
-                return 0;
+                rc = 0;
         else
-                return -EIO;
+                rc = -EIO;
+        /*
+         * If we turn recording off, we have to purge any remaining records
+         * afterwards, as a large number of queued records may impact z/VM
+         * performance.
+         */
+        if (purge && (action == 0)) {
+                memset(cp_command, 0x00, sizeof(cp_command));
+                memset(cp_response, 0x00, sizeof(cp_response));
+                snprintf(cp_command, sizeof(cp_command),
+                         "RECORDING %s PURGE %s",
+                         logptr->recording_name,
+                         qid_string);
+                cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
+        }
 
+        return rc;
 }
 
 
diff --git a/drivers/s390/char/vmur.c b/drivers/s390/char/vmur.c
index 1de672f21037..f7e4ae6bf15a 100644
--- a/drivers/s390/char/vmur.c
+++ b/drivers/s390/char/vmur.c
@@ -13,7 +13,6 @@
 
 #include <linux/cdev.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 #include <asm/cio.h>
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 2ff8a22d4257..e8391b89eff4 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -1455,7 +1455,16 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
                 break;
         case IO_SCH_UNREG_ATTACH:
         case IO_SCH_UNREG:
-                if (cdev)
+                if (!cdev)
+                        break;
+                if (cdev->private->state == DEV_STATE_SENSE_ID) {
+                        /*
+                         * Note: delayed work triggered by this event
+                         * and repeated calls to sch_event are synchronized
+                         * by the above check for work_pending(cdev).
+                         */
+                        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
+                } else
                         ccw_device_set_notoper(cdev);
                 break;
         case IO_SCH_NOP:
diff --git a/drivers/s390/cio/qdio_thinint.c b/drivers/s390/cio/qdio_thinint.c
index 752dbee06af5..5d9c66627b6e 100644
--- a/drivers/s390/cio/qdio_thinint.c
+++ b/drivers/s390/cio/qdio_thinint.c
@@ -292,8 +292,8 @@ void qdio_shutdown_thinint(struct qdio_irq *irq_ptr)
                 return;
 
         /* reset adapter interrupt indicators */
-        put_indicator(irq_ptr->dsci);
         set_subchannel_ind(irq_ptr, 1);
+        put_indicator(irq_ptr->dsci);
 }
 
 void __exit tiqdio_unregister_thinints(void)
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index f5221749d180..7fca9c10ffcf 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -35,7 +35,6 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/compat.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index 6be43eb126b4..f47a714538db 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -440,7 +440,6 @@ struct qeth_qdio_out_q {
          * index of buffer to be filled by driver; state EMPTY or PACKING
          */
         int next_buf_to_fill;
-        int sync_iqdio_error;
         /*
          * number of buffers that are currently filled (PRIMED)
          * -> these buffers are hardware-owned
@@ -695,14 +694,6 @@ struct qeth_mc_mac {
         int is_vmac;
 };
 
-struct qeth_skb_data {
-        __u32 magic;
-        int count;
-};
-
-#define QETH_SKB_MAGIC 0x71657468
-#define QETH_SIGA_CC2_RETRIES 3
-
 struct qeth_rx {
         int b_count;
         int b_index;
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index 764267062601..e6b2df0e73f5 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -877,8 +877,8 @@ out:
         return;
 }
 
-static void __qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
-                 struct qeth_qdio_out_buffer *buf, unsigned int qeth_skip_skb)
+static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
+                struct qeth_qdio_out_buffer *buf)
 {
         int i;
         struct sk_buff *skb;
@@ -887,13 +887,11 @@ static void __qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
         if (buf->buffer->element[0].flags & 0x40)
                 atomic_dec(&queue->set_pci_flags_count);
 
-        if (!qeth_skip_skb) {
+        skb = skb_dequeue(&buf->skb_list);
+        while (skb) {
+                atomic_dec(&skb->users);
+                dev_kfree_skb_any(skb);
                 skb = skb_dequeue(&buf->skb_list);
-                while (skb) {
-                        atomic_dec(&skb->users);
-                        dev_kfree_skb_any(skb);
-                        skb = skb_dequeue(&buf->skb_list);
-                }
         }
         for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(queue->card); ++i) {
                 if (buf->buffer->element[i].addr && buf->is_header[i])
@@ -909,12 +907,6 @@ static void __qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
         atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);
 }
 
-static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
-                struct qeth_qdio_out_buffer *buf)
-{
-        __qeth_clear_output_buffer(queue, buf, 0);
-}
-
 void qeth_clear_qdio_buffers(struct qeth_card *card)
 {
         int i, j;
@@ -2833,7 +2825,6 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                 }
         }
 
-        queue->sync_iqdio_error = 0;
         queue->card->dev->trans_start = jiffies;
         if (queue->card->options.performance_stats) {
                 queue->card->perf_stats.outbound_do_qdio_cnt++;
@@ -2849,10 +2840,6 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                 queue->card->perf_stats.outbound_do_qdio_time +=
                         qeth_get_micros() -
                         queue->card->perf_stats.outbound_do_qdio_start_time;
-        if (rc > 0) {
-                if (!(rc & QDIO_ERROR_SIGA_BUSY))
-                        queue->sync_iqdio_error = rc & 3;
-        }
         if (rc) {
                 queue->card->stats.tx_errors += count;
                 /* ignore temporary SIGA errors without busy condition */
@@ -2916,7 +2903,7 @@ void qeth_qdio_start_poll(struct ccw_device *ccwdev, int queue,
 {
         struct qeth_card *card = (struct qeth_card *)card_ptr;
 
-        if (card->dev)
+        if (card->dev && (card->dev->flags & IFF_UP))
                 napi_schedule(&card->napi);
 }
 EXPORT_SYMBOL_GPL(qeth_qdio_start_poll);
@@ -2940,7 +2927,6 @@ void qeth_qdio_output_handler(struct ccw_device *ccwdev,
         struct qeth_qdio_out_q *queue = card->qdio.out_qs[__queue];
         struct qeth_qdio_out_buffer *buffer;
         int i;
-        unsigned qeth_send_err;
 
         QETH_CARD_TEXT(card, 6, "qdouhdl");
         if (qdio_error & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
@@ -2956,9 +2942,8 @@ void qeth_qdio_output_handler(struct ccw_device *ccwdev,
         }
         for (i = first_element; i < (first_element + count); ++i) {
                 buffer = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q];
-                qeth_send_err = qeth_handle_send_error(card, buffer, qdio_error);
-                __qeth_clear_output_buffer(queue, buffer,
-                        (qeth_send_err == QETH_SEND_ERROR_RETRY) ? 1 : 0);
+                qeth_handle_send_error(card, buffer, qdio_error);
+                qeth_clear_output_buffer(queue, buffer);
         }
         atomic_sub(count, &queue->used_buffers);
         /* check if we need to do something on this outbound queue */
@@ -3183,10 +3168,7 @@ int qeth_do_send_packet_fast(struct qeth_card *card,
                 int offset, int hd_len)
 {
         struct qeth_qdio_out_buffer *buffer;
-        struct sk_buff *skb1;
-        struct qeth_skb_data *retry_ctrl;
         int index;
-        int rc;
 
         /* spin until we get the queue ... */
         while (atomic_cmpxchg(&queue->state, QETH_OUT_Q_UNLOCKED,
@@ -3205,25 +3187,6 @@ int qeth_do_send_packet_fast(struct qeth_card *card,
         atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);
         qeth_fill_buffer(queue, buffer, skb, hdr, offset, hd_len);
         qeth_flush_buffers(queue, index, 1);
-        if (queue->sync_iqdio_error == 2) {
-                skb1 = skb_dequeue(&buffer->skb_list);
-                while (skb1) {
-                        atomic_dec(&skb1->users);
-                        skb1 = skb_dequeue(&buffer->skb_list);
-                }
-                retry_ctrl = (struct qeth_skb_data *) &skb->cb[16];
-                if (retry_ctrl->magic != QETH_SKB_MAGIC) {
-                        retry_ctrl->magic = QETH_SKB_MAGIC;
-                        retry_ctrl->count = 0;
-                }
-                if (retry_ctrl->count < QETH_SIGA_CC2_RETRIES) {
-                        retry_ctrl->count++;
-                        rc = dev_queue_xmit(skb);
-                } else {
-                        dev_kfree_skb_any(skb);
-                        QETH_CARD_TEXT(card, 2, "qrdrop");
-                }
-        }
         return 0;
 out:
         atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 50286d8707f3..6bd2dbc4c316 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -76,7 +76,7 @@ static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
         scpnt->scsi_done(scpnt);
 }
 
-static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
+static int zfcp_scsi_queuecommand_lck(struct scsi_cmnd *scpnt,
                                   void (*done) (struct scsi_cmnd *))
 {
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
@@ -127,6 +127,8 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
         return ret;
 }
 
+static DEF_SCSI_QCMD(zfcp_scsi_queuecommand)
+
 static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
 {
         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));