s390/sclp: add timeout for queued requests

This patch adds a timeout option for queued requests and introduces
sclp_sync_request_timeout() to use this timer. With this, blocking the
system too long, e.g. during an SE reboot, can be avoided in critical
situations like CPU and memory hotplug.
Since there is no way to cancel a running request, this timeout only
applies to queued requests that have not yet been started.

Reviewed-by: Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
Signed-off-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

3 files changed, 104 insertions, 4 deletions

diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index 1fe264379e0d..e9ede5980994 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -91,6 +91,9 @@ static struct sclp_req sclp_suspend_req;
 /* Timer for request retries. */
 static struct timer_list sclp_request_timer;
 
+/* Timer for queued requests. */
+static struct timer_list sclp_queue_timer;
+
 /* Internal state: is the driver initialized? */
 static volatile enum sclp_init_state_t {
         sclp_init_state_uninitialized,
@@ -215,6 +218,76 @@ sclp_request_timeout(unsigned long data)
         sclp_process_queue();
 }
 
+/*
+ * Returns the expire value in jiffies of the next pending request timeout,
+ * if any. Needs to be called with sclp_lock.
+ */
+static unsigned long __sclp_req_queue_find_next_timeout(void)
+{
+        unsigned long expires_next = 0;
+        struct sclp_req *req;
+
+        list_for_each_entry(req, &sclp_req_queue, list) {
+                if (!req->queue_expires)
+                        continue;
+                if (!expires_next ||
+                   (time_before(req->queue_expires, expires_next)))
+                                expires_next = req->queue_expires;
+        }
+        return expires_next;
+}
+
+/*
+ * Returns expired request, if any, and removes it from the list.
+ */
+static struct sclp_req *__sclp_req_queue_remove_expired_req(void)
+{
+        unsigned long flags, now;
+        struct sclp_req *req;
+
+        spin_lock_irqsave(&sclp_lock, flags);
+        now = jiffies;
+        /* Don't need list_for_each_safe because we break out after list_del */
+        list_for_each_entry(req, &sclp_req_queue, list) {
+                if (!req->queue_expires)
+                        continue;
+                if (time_before_eq(req->queue_expires, now)) {
+                        if (req->status == SCLP_REQ_QUEUED) {
+                                req->status = SCLP_REQ_QUEUED_TIMEOUT;
+                                list_del(&req->list);
+                                goto out;
+                        }
+                }
+        }
+        req = NULL;
+out:
+        spin_unlock_irqrestore(&sclp_lock, flags);
+        return req;
+}
+
+/*
+ * Timeout handler for queued requests. Removes request from list and
+ * invokes callback. This timer can be set per request in situations where
+ * waiting too long would be harmful to the system, e.g. during SE reboot.
+ */
+static void sclp_req_queue_timeout(unsigned long data)
+{
+        unsigned long flags, expires_next;
+        struct sclp_req *req;
+
+        do {
+                req = __sclp_req_queue_remove_expired_req();
+                if (req && req->callback)
+                        req->callback(req, req->callback_data);
+        } while (req);
+
+        spin_lock_irqsave(&sclp_lock, flags);
+        expires_next = __sclp_req_queue_find_next_timeout();
+        if (expires_next)
+                mod_timer(&sclp_queue_timer, expires_next);
+        spin_unlock_irqrestore(&sclp_lock, flags);
+}
+
 /* Try to start a request. Return zero if the request was successfully
  * started or if it will be started at a later time. Return non-zero otherwise.
  * Called while sclp_lock is locked. */
@@ -317,6 +390,13 @@ sclp_add_request(struct sclp_req *req)
         req->start_count = 0;
         list_add_tail(&req->list, &sclp_req_queue);
         rc = 0;
+        if (req->queue_timeout) {
+                req->queue_expires = jiffies + req->queue_timeout * HZ;
+                if (!timer_pending(&sclp_queue_timer) ||
+                    time_after(sclp_queue_timer.expires, req->queue_expires))
+                        mod_timer(&sclp_queue_timer, req->queue_expires);
+        } else
+                req->queue_expires = 0;
         /* Start if request is first in list */
         if (sclp_running_state == sclp_running_state_idle &&
             req->list.prev == &sclp_req_queue) {
@@ -1113,6 +1193,8 @@ sclp_init(void)
         INIT_LIST_HEAD(&sclp_reg_list);
         list_add(&sclp_state_change_event.list, &sclp_reg_list);
         init_timer(&sclp_request_timer);
+        init_timer(&sclp_queue_timer);
+        sclp_queue_timer.function = sclp_req_queue_timeout;
         /* Check interface */
         spin_unlock_irqrestore(&sclp_lock, flags);
         rc = sclp_check_interface();
diff --git a/drivers/s390/char/sclp.h b/drivers/s390/char/sclp.h
index fea76aed9eea..a68b5ec7d042 100644
--- a/drivers/s390/char/sclp.h
+++ b/drivers/s390/char/sclp.h
@@ -133,6 +133,11 @@ struct sclp_req {
         /* Callback that is called after reaching final status. */
         void (*callback)(struct sclp_req *, void *data);
         void *callback_data;
+        int queue_timeout;              /* request queue timeout (sec), set by
+                                           caller of sclp_add_request(), if
+                                           needed */
+        /* Internal fields */
+        unsigned long queue_expires;    /* request queue timeout (jiffies) */
 };
 
 #define SCLP_REQ_FILLED   0x00  /* request is ready to be processed */
@@ -140,6 +145,9 @@ struct sclp_req {
 #define SCLP_REQ_RUNNING  0x02  /* request is currently running */
 #define SCLP_REQ_DONE     0x03  /* request is completed successfully */
 #define SCLP_REQ_FAILED   0x05  /* request is finally failed */
+#define SCLP_REQ_QUEUED_TIMEOUT 0x06    /* request on queue timed out */
+
+#define SCLP_QUEUE_INTERVAL 5   /* timeout interval for request queue */
 
 /* function pointers that a high level driver has to use for registration */
 /* of some routines it wants to be called from the low level driver */
@@ -173,6 +181,7 @@ int sclp_deactivate(void);
 int sclp_reactivate(void);
 int sclp_service_call(sclp_cmdw_t command, void *sccb);
 int sclp_sync_request(sclp_cmdw_t command, void *sccb);
+int sclp_sync_request_timeout(sclp_cmdw_t command, void *sccb, int timeout);
 
 int sclp_sdias_init(void);
 void sclp_sdias_exit(void);
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index 49af8eeb90ea..6e8f90f84e49 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -37,6 +37,11 @@ static void sclp_sync_callback(struct sclp_req *req, void *data)
 
 int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
 {
+        return sclp_sync_request_timeout(cmd, sccb, 0);
+}
+
+int sclp_sync_request_timeout(sclp_cmdw_t cmd, void *sccb, int timeout)
+{
         struct completion completion;
         struct sclp_req *request;
         int rc;
@@ -44,6 +49,8 @@ int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
         request = kzalloc(sizeof(*request), GFP_KERNEL);
         if (!request)
                 return -ENOMEM;
+        if (timeout)
+                request->queue_timeout = timeout;
         request->command = cmd;
         request->sccb = sccb;
         request->status = SCLP_REQ_FILLED;
@@ -110,7 +117,8 @@ int sclp_get_cpu_info(struct sclp_cpu_info *info)
         if (!sccb)
                 return -ENOMEM;
         sccb->header.length = sizeof(*sccb);
-        rc = sclp_sync_request(SCLP_CMDW_READ_CPU_INFO, sccb);
+        rc = sclp_sync_request_timeout(SCLP_CMDW_READ_CPU_INFO, sccb,
+                                       SCLP_QUEUE_INTERVAL);
         if (rc)
                 goto out;
         if (sccb->header.response_code != 0x0010) {
@@ -144,7 +152,7 @@ static int do_cpu_configure(sclp_cmdw_t cmd)
         if (!sccb)
                 return -ENOMEM;
         sccb->header.length = sizeof(*sccb);
-        rc = sclp_sync_request(cmd, sccb);
+        rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
         if (rc)
                 goto out;
         switch (sccb->header.response_code) {
@@ -214,7 +222,7 @@ static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
                 return -ENOMEM;
         sccb->header.length = PAGE_SIZE;
         sccb->rn = rn;
-        rc = sclp_sync_request(cmd, sccb);
+        rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
         if (rc)
                 goto out;
         switch (sccb->header.response_code) {
@@ -269,7 +277,8 @@ static int sclp_attach_storage(u8 id)
         if (!sccb)
                 return -ENOMEM;
         sccb->header.length = PAGE_SIZE;
-        rc = sclp_sync_request(0x00080001 | id << 8, sccb);
+        rc = sclp_sync_request_timeout(0x00080001 | id << 8, sccb,
+                                       SCLP_QUEUE_INTERVAL);
         if (rc)
                 goto out;
         switch (sccb->header.response_code) {