6 files changed, 207 insertions, 9 deletions

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index ed5cb5af5281..6b99fc3f9b63 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -91,6 +91,7 @@ config S390
         select HAVE_ARCH_MUTEX_CPU_RELAX
         select HAVE_ARCH_JUMP_LABEL if !MARCH_G5
         select HAVE_RCU_TABLE_FREE if SMP
+        select ARCH_SAVE_PAGE_KEYS if HIBERNATION
         select ARCH_INLINE_SPIN_TRYLOCK
         select ARCH_INLINE_SPIN_TRYLOCK_BH
         select ARCH_INLINE_SPIN_LOCK
diff --git a/arch/s390/hypfs/hypfs_diag.c b/arch/s390/hypfs/hypfs_diag.c
index 6023c6dc1fb7..74c8f5e76ce4 100644
--- a/arch/s390/hypfs/hypfs_diag.c
+++ b/arch/s390/hypfs/hypfs_diag.c
@@ -562,10 +562,9 @@ static int dbfs_d204_create(void **data, void **data_free_ptr, size_t *size)
         void *base;
 
         buf_size = PAGE_SIZE * (diag204_buf_pages + 1) + sizeof(d204->hdr);
-        base = vmalloc(buf_size);
+        base = vzalloc(buf_size);
         if (!base)
                 return -ENOMEM;
-        memset(base, 0, buf_size);
         d204 = page_align_ptr(base + sizeof(d204->hdr)) - sizeof(d204->hdr);
         rc = diag204_do_store(d204->buf, diag204_buf_pages);
         if (rc) {
diff --git a/arch/s390/include/asm/qdio.h b/arch/s390/include/asm/qdio.h
index 15c97625df8d..21993623da9a 100644
--- a/arch/s390/include/asm/qdio.h
+++ b/arch/s390/include/asm/qdio.h
@@ -123,6 +123,40 @@ struct slibe {
 };
 
 /**
+ * struct qaob - queue asynchronous operation block
+ * @res0: reserved parameters
+ * @res1: reserved parameter
+ * @res2: reserved parameter
+ * @res3: reserved parameter
+ * @aorc: asynchronous operation return code
+ * @flags: internal flags
+ * @cbtbs: control block type
+ * @sb_count: number of storage blocks
+ * @sba: storage block element addresses
+ * @dcount: size of storage block elements
+ * @user0: user defineable value
+ * @res4: reserved paramater
+ * @user1: user defineable value
+ * @user2: user defineable value
+ */
+struct qaob {
+        u64 res0[6];
+        u8 res1;
+        u8 res2;
+        u8 res3;
+        u8 aorc;
+        u8 flags;
+        u16 cbtbs;
+        u8 sb_count;
+        u64 sba[QDIO_MAX_ELEMENTS_PER_BUFFER];
+        u16 dcount[QDIO_MAX_ELEMENTS_PER_BUFFER];
+        u64 user0;
+        u64 res4[2];
+        u64 user1;
+        u64 user2;
+} __attribute__ ((packed, aligned(256)));
+
+/**
  * struct slib - storage list information block (SLIB)
  * @nsliba: next SLIB address (if any)
  * @sla: SL address
@@ -225,6 +259,41 @@ struct slsb {
 #define CHSC_AC2_DATA_DIV_AVAILABLE     0x0010
 #define CHSC_AC2_DATA_DIV_ENABLED       0x0002
 
+/**
+ * struct qdio_outbuf_state - SBAL related asynchronous operation information
+ *   (for communication with upper layer programs)
+ *   (only required for use with completion queues)
+ * @flags: flags indicating state of buffer
+ * @aob: pointer to QAOB used for the particular SBAL
+ * @user: pointer to upper layer program's state information related to SBAL
+ *        (stored in user1 data of QAOB)
+ */
+struct qdio_outbuf_state {
+        u8 flags;
+        struct qaob *aob;
+        void *user;
+};
+
+#define QDIO_OUTBUF_STATE_FLAG_NONE     0x00
+#define QDIO_OUTBUF_STATE_FLAG_PENDING  0x01
+
+#define CHSC_AC1_INITIATE_INPUTQ        0x80
+
+
+/* qdio adapter-characteristics-1 flag */
+#define AC1_SIGA_INPUT_NEEDED           0x40    /* process input queues */
+#define AC1_SIGA_OUTPUT_NEEDED          0x20    /* process output queues */
+#define AC1_SIGA_SYNC_NEEDED            0x10    /* ask hypervisor to sync */
+#define AC1_AUTOMATIC_SYNC_ON_THININT   0x08    /* set by hypervisor */
+#define AC1_AUTOMATIC_SYNC_ON_OUT_PCI   0x04    /* set by hypervisor */
+#define AC1_SC_QEBSM_AVAILABLE          0x02    /* available for subchannel */
+#define AC1_SC_QEBSM_ENABLED            0x01    /* enabled for subchannel */
+
+#define CHSC_AC2_DATA_DIV_AVAILABLE     0x0010
+#define CHSC_AC2_DATA_DIV_ENABLED       0x0002
+
+#define CHSC_AC3_FORMAT2_CQ_AVAILABLE   0x8000
+
 struct qdio_ssqd_desc {
         u8 flags;
         u8:8;
@@ -243,8 +312,7 @@ struct qdio_ssqd_desc {
         u64 sch_token;
         u8 mro;
         u8 mri;
-        u8:8;
-        u8 sbalic;
+        u16 qdioac3;
         u16:16;
         u8:8;
         u8 mmwc;
@@ -280,9 +348,11 @@ typedef void qdio_handler_t(struct ccw_device *, unsigned int, int,
  * @no_output_qs: number of output queues
  * @input_handler: handler to be called for input queues
  * @output_handler: handler to be called for output queues
+ * @queue_start_poll: polling handlers (one per input queue or NULL)
  * @int_parm: interruption parameter
  * @input_sbal_addr_array:  address of no_input_qs * 128 pointers
  * @output_sbal_addr_array: address of no_output_qs * 128 pointers
+ * @output_sbal_state_array: no_output_qs * 128 state info (for CQ or NULL)
  */
 struct qdio_initialize {
         struct ccw_device *cdev;
@@ -297,11 +367,12 @@ struct qdio_initialize {
         unsigned int no_output_qs;
         qdio_handler_t *input_handler;
         qdio_handler_t *output_handler;
-        void (*queue_start_poll) (struct ccw_device *, int, unsigned long);
+        void (**queue_start_poll) (struct ccw_device *, int, unsigned long);
         int scan_threshold;
         unsigned long int_parm;
         void **input_sbal_addr_array;
         void **output_sbal_addr_array;
+        struct qdio_outbuf_state *output_sbal_state_array;
 };
 
 #define QDIO_STATE_INACTIVE             0x00000002 /* after qdio_cleanup */
@@ -316,6 +387,7 @@ struct qdio_initialize {
 extern int qdio_allocate(struct qdio_initialize *);
 extern int qdio_establish(struct qdio_initialize *);
 extern int qdio_activate(struct ccw_device *);
+extern void qdio_release_aob(struct qaob *);
 extern int do_QDIO(struct ccw_device *, unsigned int, int, unsigned int,
                    unsigned int);
 extern int qdio_start_irq(struct ccw_device *, int);
diff --git a/arch/s390/kernel/suspend.c b/arch/s390/kernel/suspend.c
index cf9e5c6d5527..b6f9afed74ec 100644
--- a/arch/s390/kernel/suspend.c
+++ b/arch/s390/kernel/suspend.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/pfn.h>
+#include <linux/mm.h>
 #include <asm/system.h>
 
 /*
@@ -14,6 +15,123 @@
  */
 extern const void __nosave_begin, __nosave_end;
 
+/*
+ * The restore of the saved pages in an hibernation image will set
+ * the change and referenced bits in the storage key for each page.
+ * Overindication of the referenced bits after an hibernation cycle
+ * does not cause any harm but the overindication of the change bits
+ * would cause trouble.
+ * Use the ARCH_SAVE_PAGE_KEYS hooks to save the storage key of each
+ * page to the most significant byte of the associated page frame
+ * number in the hibernation image.
+ */
+
+/*
+ * Key storage is allocated as a linked list of pages.
+ * The size of the keys array is (PAGE_SIZE - sizeof(long))
+ */
+struct page_key_data {
+        struct page_key_data *next;
+        unsigned char data[];
+};
+
+#define PAGE_KEY_DATA_SIZE      (PAGE_SIZE - sizeof(struct page_key_data *))
+
+static struct page_key_data *page_key_data;
+static struct page_key_data *page_key_rp, *page_key_wp;
+static unsigned long page_key_rx, page_key_wx;
+
+/*
+ * For each page in the hibernation image one additional byte is
+ * stored in the most significant byte of the page frame number.
+ * On suspend no additional memory is required but on resume the
+ * keys need to be memorized until the page data has been restored.
+ * Only then can the storage keys be set to their old state.
+ */
+unsigned long page_key_additional_pages(unsigned long pages)
+{
+        return DIV_ROUND_UP(pages, PAGE_KEY_DATA_SIZE);
+}
+
+/*
+ * Free page_key_data list of arrays.
+ */
+void page_key_free(void)
+{
+        struct page_key_data *pkd;
+
+        while (page_key_data) {
+                pkd = page_key_data;
+                page_key_data = pkd->next;
+                free_page((unsigned long) pkd);
+        }
+}
+
+/*
+ * Allocate page_key_data list of arrays with enough room to store
+ * one byte for each page in the hibernation image.
+ */
+int page_key_alloc(unsigned long pages)
+{
+        struct page_key_data *pk;
+        unsigned long size;
+
+        size = DIV_ROUND_UP(pages, PAGE_KEY_DATA_SIZE);
+        while (size--) {
+                pk = (struct page_key_data *) get_zeroed_page(GFP_KERNEL);
+                if (!pk) {
+                        page_key_free();
+                        return -ENOMEM;
+                }
+                pk->next = page_key_data;
+                page_key_data = pk;
+        }
+        page_key_rp = page_key_wp = page_key_data;
+        page_key_rx = page_key_wx = 0;
+        return 0;
+}
+
+/*
+ * Save the storage key into the upper 8 bits of the page frame number.
+ */
+void page_key_read(unsigned long *pfn)
+{
+        unsigned long addr;
+
+        addr = (unsigned long) page_address(pfn_to_page(*pfn));
+        *(unsigned char *) pfn = (unsigned char) page_get_storage_key(addr);
+}
+
+/*
+ * Extract the storage key from the upper 8 bits of the page frame number
+ * and store it in the page_key_data list of arrays.
+ */
+void page_key_memorize(unsigned long *pfn)
+{
+        page_key_wp->data[page_key_wx] = *(unsigned char *) pfn;
+        *(unsigned char *) pfn = 0;
+        if (++page_key_wx < PAGE_KEY_DATA_SIZE)
+                return;
+        page_key_wp = page_key_wp->next;
+        page_key_wx = 0;
+}
+
+/*
+ * Get the next key from the page_key_data list of arrays and set the
+ * storage key of the page referred by @address. If @address refers to
+ * a "safe" page the swsusp_arch_resume code will transfer the storage
+ * key from the buffer page to the original page.
+ */
+void page_key_write(void *address)
+{
+        page_set_storage_key((unsigned long) address,
+                             page_key_rp->data[page_key_rx], 0);
+        if (++page_key_rx >= PAGE_KEY_DATA_SIZE)
+                return;
+        page_key_rp = page_key_rp->next;
+        page_key_rx = 0;
+}
+
 int pfn_is_nosave(unsigned long pfn)
 {
         unsigned long nosave_begin_pfn = PFN_DOWN(__pa(&__nosave_begin));
diff --git a/arch/s390/kernel/swsusp_asm64.S b/arch/s390/kernel/swsusp_asm64.S
index 51bcdb50a230..acb78cdee896 100644
--- a/arch/s390/kernel/swsusp_asm64.S
+++ b/arch/s390/kernel/swsusp_asm64.S
@@ -136,11 +136,14 @@ ENTRY(swsusp_arch_resume)
 0:
         lg      %r2,8(%r1)
         lg      %r4,0(%r1)
+        iske    %r0,%r4
         lghi    %r3,PAGE_SIZE
         lghi    %r5,PAGE_SIZE
 1:
         mvcle   %r2,%r4,0
         jo      1b
+        lg      %r2,8(%r1)
+        sske    %r0,%r2
         lg      %r1,16(%r1)
         ltgr    %r1,%r1
         jnz     0b
diff --git a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c
index dff933065ab6..8d65bd0383fc 100644
--- a/arch/s390/kernel/time.c
+++ b/arch/s390/kernel/time.c
@@ -109,10 +109,14 @@ static void fixup_clock_comparator(unsigned long long delta)
         set_clock_comparator(S390_lowcore.clock_comparator);
 }
 
-static int s390_next_event(unsigned long delta,
+static int s390_next_ktime(ktime_t expires,
                            struct clock_event_device *evt)
 {
-        S390_lowcore.clock_comparator = get_clock() + delta;
+        u64 nsecs;
+
+        nsecs = ktime_to_ns(ktime_sub(expires, ktime_get_monotonic_offset()));
+        do_div(nsecs, 125);
+        S390_lowcore.clock_comparator = TOD_UNIX_EPOCH + (nsecs << 9);
         set_clock_comparator(S390_lowcore.clock_comparator);
         return 0;
 }
@@ -137,14 +141,15 @@ void init_cpu_timer(void)
         cpu = smp_processor_id();
         cd = &per_cpu(comparators, cpu);
         cd->name                = "comparator";
-        cd->features            = CLOCK_EVT_FEAT_ONESHOT;
+        cd->features            = CLOCK_EVT_FEAT_ONESHOT |
+                                  CLOCK_EVT_FEAT_KTIME;
         cd->mult                = 16777;
         cd->shift               = 12;
         cd->min_delta_ns        = 1;
         cd->max_delta_ns        = LONG_MAX;
         cd->rating              = 400;
         cd->cpumask             = cpumask_of(cpu);
-        cd->set_next_event      = s390_next_event;
+        cd->set_next_ktime      = s390_next_ktime;
         cd->set_mode            = s390_set_mode;
 
         clockevents_register_device(cd);