7 files changed, 38 insertions, 51 deletions

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 8ba3f135da22..1a4025683362 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -63,6 +63,7 @@ static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *);
  */
 static wait_queue_head_t dasd_init_waitq;
 static wait_queue_head_t dasd_flush_wq;
+static wait_queue_head_t generic_waitq;
 
 /*
  * Allocate memory for a new device structure.
@@ -1151,11 +1152,15 @@ static void __dasd_device_process_final_queue(struct dasd_device *device,
         struct list_head *l, *n;
         struct dasd_ccw_req *cqr;
         struct dasd_block *block;
+        void (*callback)(struct dasd_ccw_req *, void *data);
+        void *callback_data;
 
         list_for_each_safe(l, n, final_queue) {
                 cqr = list_entry(l, struct dasd_ccw_req, devlist);
                 list_del_init(&cqr->devlist);
                 block = cqr->block;
+                callback = cqr->callback;
+                callback_data = cqr->callback_data;
                 if (block)
                         spin_lock_bh(&block->queue_lock);
                 switch (cqr->status) {
@@ -1176,7 +1181,7 @@ static void __dasd_device_process_final_queue(struct dasd_device *device,
                         BUG();
                 }
                 if (cqr->callback != NULL)
-                        (cqr->callback)(cqr, cqr->callback_data);
+                        (callback)(cqr, callback_data);
                 if (block)
                         spin_unlock_bh(&block->queue_lock);
         }
@@ -1406,17 +1411,15 @@ static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr)
  */
 int dasd_sleep_on(struct dasd_ccw_req *cqr)
 {
-        wait_queue_head_t wait_q;
         struct dasd_device *device;
         int rc;
 
         device = cqr->startdev;
 
-        init_waitqueue_head (&wait_q);
         cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &wait_q;
+        cqr->callback_data = (void *) &generic_waitq;
         dasd_add_request_tail(cqr);
-        wait_event(wait_q, _wait_for_wakeup(cqr));
+        wait_event(generic_waitq, _wait_for_wakeup(cqr));
 
         /* Request status is either done or failed. */
         rc = (cqr->status == DASD_CQR_DONE) ? 0 : -EIO;
@@ -1429,20 +1432,18 @@ int dasd_sleep_on(struct dasd_ccw_req *cqr)
  */
 int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr)
 {
-        wait_queue_head_t wait_q;
         struct dasd_device *device;
         int rc;
 
         device = cqr->startdev;
-        init_waitqueue_head (&wait_q);
         cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &wait_q;
+        cqr->callback_data = (void *) &generic_waitq;
         dasd_add_request_tail(cqr);
-        rc = wait_event_interruptible(wait_q, _wait_for_wakeup(cqr));
+        rc = wait_event_interruptible(generic_waitq, _wait_for_wakeup(cqr));
         if (rc == -ERESTARTSYS) {
                 dasd_cancel_req(cqr);
                 /* wait (non-interruptible) for final status */
-                wait_event(wait_q, _wait_for_wakeup(cqr));
+                wait_event(generic_waitq, _wait_for_wakeup(cqr));
         }
         rc = (cqr->status == DASD_CQR_DONE) ? 0 : -EIO;
         return rc;
@@ -1466,7 +1467,6 @@ static inline int _dasd_term_running_cqr(struct dasd_device *device)
 
 int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
 {
-        wait_queue_head_t wait_q;
         struct dasd_device *device;
         int rc;
 
@@ -1478,9 +1478,8 @@ int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
                 return rc;
         }
 
-        init_waitqueue_head (&wait_q);
         cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &wait_q;
+        cqr->callback_data = (void *) &generic_waitq;
         cqr->status = DASD_CQR_QUEUED;
         list_add(&cqr->devlist, &device->ccw_queue);
 
@@ -1489,7 +1488,7 @@ int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
 
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 
-        wait_event(wait_q, _wait_for_wakeup(cqr));
+        wait_event(generic_waitq, _wait_for_wakeup(cqr));
 
         /* Request status is either done or failed. */
         rc = (cqr->status == DASD_CQR_DONE) ? 0 : -EIO;
@@ -2430,6 +2429,7 @@ static int __init dasd_init(void)
 
         init_waitqueue_head(&dasd_init_waitq);
         init_waitqueue_head(&dasd_flush_wq);
+        init_waitqueue_head(&generic_waitq);
 
         /* register 'common' DASD debug area, used for all DBF_XXX calls */
         dasd_debug_area = debug_register("dasd", 1, 1, 8 * sizeof(long));
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 0d98f1ff2edd..848ef7e8523f 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -549,7 +549,6 @@ raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
                    struct raw3270_request *rq)
 {
         unsigned long flags;
-        wait_queue_head_t wq;
         int rc;
 
 #ifdef CONFIG_TN3270_CONSOLE
@@ -566,20 +565,20 @@ raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
                 return rq->rc;
         }
 #endif
-        init_waitqueue_head(&wq);
         rq->callback = raw3270_wake_init;
-        rq->callback_data = &wq;
+        rq->callback_data = &raw3270_wait_queue;
         spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
         rc = __raw3270_start(rp, view, rq);
         spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
         if (rc)
                 return rc;
         /* Now wait for the completion. */
-        rc = wait_event_interruptible(wq, raw3270_request_final(rq));
+        rc = wait_event_interruptible(raw3270_wait_queue,
+                                      raw3270_request_final(rq));
         if (rc == -ERESTARTSYS) {       /* Interrupted by a signal. */
                 raw3270_halt_io(view->dev, rq);
                 /* No wait for the halt to complete. */
-                wait_event(wq, raw3270_request_final(rq));
+                wait_event(raw3270_wait_queue, raw3270_request_final(rq));
                 return -ERESTARTSYS;
         }
         return rq->rc;
diff --git a/drivers/s390/char/sclp_config.c b/drivers/s390/char/sclp_config.c
index 9e784d5f7f57..ad05a87bc480 100644
--- a/drivers/s390/char/sclp_config.c
+++ b/drivers/s390/char/sclp_config.c
@@ -40,7 +40,7 @@ static void sclp_cpu_capability_notify(struct work_struct *work)
         put_online_cpus();
 }
 
-static void sclp_cpu_change_notify(struct work_struct *work)
+static void __ref sclp_cpu_change_notify(struct work_struct *work)
 {
         smp_rescan_cpus();
 }
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index 35707c04e613..62576af36f47 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -71,9 +71,6 @@ static struct list_head sclp_vt220_outqueue;
 /* Number of requests in outqueue */
 static int sclp_vt220_outqueue_count;
 
-/* Wait queue used to delay write requests while we've run out of buffers */
-static wait_queue_head_t sclp_vt220_waitq;
-
 /* Timer used for delaying write requests to merge subsequent messages into
  * a single buffer */
 static struct timer_list sclp_vt220_timer;
@@ -133,7 +130,6 @@ sclp_vt220_process_queue(struct sclp_vt220_request *request)
         } while (request && __sclp_vt220_emit(request));
         if (request == NULL && sclp_vt220_flush_later)
                 sclp_vt220_emit_current();
-        wake_up(&sclp_vt220_waitq);
         /* Check if the tty needs a wake up call */
         if (sclp_vt220_tty != NULL) {
                 tty_wakeup(sclp_vt220_tty);
@@ -383,7 +379,7 @@ sclp_vt220_timeout(unsigned long data)
  */
 static int
 __sclp_vt220_write(const unsigned char *buf, int count, int do_schedule,
-                   int convertlf, int may_schedule)
+                   int convertlf, int may_fail)
 {
         unsigned long flags;
         void *page;
@@ -395,15 +391,14 @@ __sclp_vt220_write(const unsigned char *buf, int count, int do_schedule,
         overall_written = 0;
         spin_lock_irqsave(&sclp_vt220_lock, flags);
         do {
-                /* Create a sclp output buffer if none exists yet */
+                /* Create an sclp output buffer if none exists yet */
                 if (sclp_vt220_current_request == NULL) {
                         while (list_empty(&sclp_vt220_empty)) {
                                 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
-                                if (in_interrupt() || !may_schedule)
-                                        sclp_sync_wait();
+                                if (may_fail)
+                                        goto out;
                                 else
-                                        wait_event(sclp_vt220_waitq,
-                                                !list_empty(&sclp_vt220_empty));
+                                        sclp_sync_wait();
                                 spin_lock_irqsave(&sclp_vt220_lock, flags);
                         }
                         page = (void *) sclp_vt220_empty.next;
@@ -437,6 +432,7 @@ __sclp_vt220_write(const unsigned char *buf, int count, int do_schedule,
                 add_timer(&sclp_vt220_timer);
         }
         spin_unlock_irqrestore(&sclp_vt220_lock, flags);
+out:
         return overall_written;
 }
 
@@ -520,19 +516,11 @@ sclp_vt220_close(struct tty_struct *tty, struct file *filp)
  * character to the tty device.  If the kernel uses this routine,
  * it must call the flush_chars() routine (if defined) when it is
  * done stuffing characters into the driver.
- *
- * NOTE: include/linux/tty_driver.h specifies that a character should be
- * ignored if there is no room in the queue. This driver implements a different
- * semantic in that it will block when there is no more room left.
- *
- * FIXME: putchar can currently be called from BH and other non blocking
- * handlers so  this semantic isn't a good idea.
  */
 static int
 sclp_vt220_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        __sclp_vt220_write(&ch, 1, 0, 0, 1);
-        return 1;
+        return __sclp_vt220_write(&ch, 1, 0, 0, 1);
 }
 
 /*
@@ -653,7 +641,6 @@ static int __init __sclp_vt220_init(void)
         spin_lock_init(&sclp_vt220_lock);
         INIT_LIST_HEAD(&sclp_vt220_empty);
         INIT_LIST_HEAD(&sclp_vt220_outqueue);
-        init_waitqueue_head(&sclp_vt220_waitq);
         init_timer(&sclp_vt220_timer);
         sclp_vt220_current_request = NULL;
         sclp_vt220_buffered_chars = 0;
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index dddf8d62c153..d0d565a05dfe 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -231,6 +231,9 @@ struct tape_device {
         /* Request queue. */
         struct list_head                req_queue;
 
+        /* Request wait queue. */
+        wait_queue_head_t               wait_queue;
+
         /* Each tape device has (currently) two minor numbers. */
         int                             first_minor;
 
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index ddc4a114e7f4..95da72bc17e8 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -179,11 +179,11 @@ tapeblock_requeue(struct work_struct *work) {
                         tapeblock_end_request(req, -EIO);
                         continue;
                 }
+                blkdev_dequeue_request(req);
+                nr_queued++;
                 spin_unlock_irq(&device->blk_data.request_queue_lock);
                 rc = tapeblock_start_request(device, req);
                 spin_lock_irq(&device->blk_data.request_queue_lock);
-                blkdev_dequeue_request(req);
-                nr_queued++;
         }
         spin_unlock_irq(&device->blk_data.request_queue_lock);
         atomic_set(&device->blk_data.requeue_scheduled, 0);
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index 76e44eb7c47f..c20e3c548343 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -449,6 +449,7 @@ tape_alloc_device(void)
         INIT_LIST_HEAD(&device->req_queue);
         INIT_LIST_HEAD(&device->node);
         init_waitqueue_head(&device->state_change_wq);
+        init_waitqueue_head(&device->wait_queue);
         device->tape_state = TS_INIT;
         device->medium_state = MS_UNKNOWN;
         *device->modeset_byte = 0;
@@ -954,21 +955,19 @@ __tape_wake_up(struct tape_request *request, void *data)
 int
 tape_do_io(struct tape_device *device, struct tape_request *request)
 {
-        wait_queue_head_t wq;
         int rc;
 
-        init_waitqueue_head(&wq);
         spin_lock_irq(get_ccwdev_lock(device->cdev));
         /* Setup callback */
         request->callback = __tape_wake_up;
-        request->callback_data = &wq;
+        request->callback_data = &device->wait_queue;
         /* Add request to request queue and try to start it. */
         rc = __tape_start_request(device, request);
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
         if (rc)
                 return rc;
         /* Request added to the queue. Wait for its completion. */
-        wait_event(wq, (request->callback == NULL));
+        wait_event(device->wait_queue, (request->callback == NULL));
         /* Get rc from request */
         return request->rc;
 }
@@ -989,20 +988,19 @@ int
 tape_do_io_interruptible(struct tape_device *device,
                          struct tape_request *request)
 {
-        wait_queue_head_t wq;
         int rc;
 
-        init_waitqueue_head(&wq);
         spin_lock_irq(get_ccwdev_lock(device->cdev));
         /* Setup callback */
         request->callback = __tape_wake_up_interruptible;
-        request->callback_data = &wq;
+        request->callback_data = &device->wait_queue;
         rc = __tape_start_request(device, request);
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
         if (rc)
                 return rc;
         /* Request added to the queue. Wait for its completion. */
-        rc = wait_event_interruptible(wq, (request->callback == NULL));
+        rc = wait_event_interruptible(device->wait_queue,
+                                      (request->callback == NULL));
         if (rc != -ERESTARTSYS)
                 /* Request finished normally. */
                 return request->rc;
@@ -1015,7 +1013,7 @@ tape_do_io_interruptible(struct tape_device *device,
                 /* Wait for the interrupt that acknowledges the halt. */
                 do {
                         rc = wait_event_interruptible(
-                                wq,
+                                device->wait_queue,
                                 (request->callback == NULL)
                         );
                 } while (rc == -ERESTARTSYS);