~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/suspend.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Suspend support specific for s390.
  3  *
  4  * Copyright IBM Corp. 2009
  5  *
  6  * Author(s): Hans-Joachim Picht <hans@linux.vnet.ibm.com>
  7  */
  8 
  9 #include <linux/pfn.h>
 10 #include <linux/suspend.h>
 11 #include <linux/mm.h>
 12 #include <asm/ctl_reg.h>
 13 #include <asm/ipl.h>
 14 #include <asm/cio.h>
 15 #include <asm/pci.h>
 16 #include "entry.h"
 17 
 18 /*
 19  * References to section boundaries
 20  */
 21 extern const void __nosave_begin, __nosave_end;
 22 
 23 /*
 24  * The restore of the saved pages in an hibernation image will set
 25  * the change and referenced bits in the storage key for each page.
 26  * Overindication of the referenced bits after an hibernation cycle
 27  * does not cause any harm but the overindication of the change bits
 28  * would cause trouble.
 29  * Use the ARCH_SAVE_PAGE_KEYS hooks to save the storage key of each
 30  * page to the most significant byte of the associated page frame
 31  * number in the hibernation image.
 32  */
 33 
 34 /*
 35  * Key storage is allocated as a linked list of pages.
 36  * The size of the keys array is (PAGE_SIZE - sizeof(long))
 37  */
 38 struct page_key_data {
 39         struct page_key_data *next;
 40         unsigned char data[];
 41 };
 42 
 43 #define PAGE_KEY_DATA_SIZE      (PAGE_SIZE - sizeof(struct page_key_data *))
 44 
 45 static struct page_key_data *page_key_data;
 46 static struct page_key_data *page_key_rp, *page_key_wp;
 47 static unsigned long page_key_rx, page_key_wx;
 48 unsigned long suspend_zero_pages;
 49 
 50 /*
 51  * For each page in the hibernation image one additional byte is
 52  * stored in the most significant byte of the page frame number.
 53  * On suspend no additional memory is required but on resume the
 54  * keys need to be memorized until the page data has been restored.
 55  * Only then can the storage keys be set to their old state.
 56  */
 57 unsigned long page_key_additional_pages(unsigned long pages)
 58 {
 59         return DIV_ROUND_UP(pages, PAGE_KEY_DATA_SIZE);
 60 }
 61 
 62 /*
 63  * Free page_key_data list of arrays.
 64  */
 65 void page_key_free(void)
 66 {
 67         struct page_key_data *pkd;
 68 
 69         while (page_key_data) {
 70                 pkd = page_key_data;
 71                 page_key_data = pkd->next;
 72                 free_page((unsigned long) pkd);
 73         }
 74 }
 75 
 76 /*
 77  * Allocate page_key_data list of arrays with enough room to store
 78  * one byte for each page in the hibernation image.
 79  */
 80 int page_key_alloc(unsigned long pages)
 81 {
 82         struct page_key_data *pk;
 83         unsigned long size;
 84 
 85         size = DIV_ROUND_UP(pages, PAGE_KEY_DATA_SIZE);
 86         while (size--) {
 87                 pk = (struct page_key_data *) get_zeroed_page(GFP_KERNEL);
 88                 if (!pk) {
 89                         page_key_free();
 90                         return -ENOMEM;
 91                 }
 92                 pk->next = page_key_data;
 93                 page_key_data = pk;
 94         }
 95         page_key_rp = page_key_wp = page_key_data;
 96         page_key_rx = page_key_wx = 0;
 97         return 0;
 98 }
 99 
100 /*
101  * Save the storage key into the upper 8 bits of the page frame number.
102  */
103 void page_key_read(unsigned long *pfn)
104 {
105         unsigned long addr;
106 
107         addr = (unsigned long) page_address(pfn_to_page(*pfn));
108         *(unsigned char *) pfn = (unsigned char) page_get_storage_key(addr);
109 }
110 
111 /*
112  * Extract the storage key from the upper 8 bits of the page frame number
113  * and store it in the page_key_data list of arrays.
114  */
115 void page_key_memorize(unsigned long *pfn)
116 {
117         page_key_wp->data[page_key_wx] = *(unsigned char *) pfn;
118         *(unsigned char *) pfn = 0;
119         if (++page_key_wx < PAGE_KEY_DATA_SIZE)
120                 return;
121         page_key_wp = page_key_wp->next;
122         page_key_wx = 0;
123 }
124 
125 /*
126  * Get the next key from the page_key_data list of arrays and set the
127  * storage key of the page referred by @address. If @address refers to
128  * a "safe" page the swsusp_arch_resume code will transfer the storage
129  * key from the buffer page to the original page.
130  */
131 void page_key_write(void *address)
132 {
133         page_set_storage_key((unsigned long) address,
134                              page_key_rp->data[page_key_rx], 0);
135         if (++page_key_rx >= PAGE_KEY_DATA_SIZE)
136                 return;
137         page_key_rp = page_key_rp->next;
138         page_key_rx = 0;
139 }
140 
141 int pfn_is_nosave(unsigned long pfn)
142 {
143         unsigned long nosave_begin_pfn = PFN_DOWN(__pa(&__nosave_begin));
144         unsigned long nosave_end_pfn = PFN_DOWN(__pa(&__nosave_end));
145 
146         /* Always save lowcore pages (LC protection might be enabled). */
147         if (pfn <= LC_PAGES)
148                 return 0;
149         if (pfn >= nosave_begin_pfn && pfn < nosave_end_pfn)
150                 return 1;
151         /* Skip memory holes and read-only pages (NSS, DCSS, ...). */
152         if (tprot(PFN_PHYS(pfn)))
153                 return 1;
154         return 0;
155 }
156 
157 /*
158  * PM notifier callback for suspend
159  */
160 static int suspend_pm_cb(struct notifier_block *nb, unsigned long action,
161                          void *ptr)
162 {
163         switch (action) {
164         case PM_SUSPEND_PREPARE:
165         case PM_HIBERNATION_PREPARE:
166                 suspend_zero_pages = __get_free_pages(GFP_KERNEL, LC_ORDER);
167                 if (!suspend_zero_pages)
168                         return NOTIFY_BAD;
169                 break;
170         case PM_POST_SUSPEND:
171         case PM_POST_HIBERNATION:
172                 free_pages(suspend_zero_pages, LC_ORDER);
173                 break;
174         default:
175                 return NOTIFY_DONE;
176         }
177         return NOTIFY_OK;
178 }
179 
180 static int __init suspend_pm_init(void)
181 {
182         pm_notifier(suspend_pm_cb, 0);
183         return 0;
184 }
185 arch_initcall(suspend_pm_init);
186 
187 void save_processor_state(void)
188 {
189         /* swsusp_arch_suspend() actually saves all cpu register contents.
190          * Machine checks must be disabled since swsusp_arch_suspend() stores
191          * register contents to their lowcore save areas. That's the same
192          * place where register contents on machine checks would be saved.
193          * To avoid register corruption disable machine checks.
194          * We must also disable machine checks in the new psw mask for
195          * program checks, since swsusp_arch_suspend() may generate program
196          * checks. Disabling machine checks for all other new psw masks is
197          * just paranoia.
198          */
199         local_mcck_disable();
200         /* Disable lowcore protection */
201         __ctl_clear_bit(0,28);
202         S390_lowcore.external_new_psw.mask &= ~PSW_MASK_MCHECK;
203         S390_lowcore.svc_new_psw.mask &= ~PSW_MASK_MCHECK;
204         S390_lowcore.io_new_psw.mask &= ~PSW_MASK_MCHECK;
205         S390_lowcore.program_new_psw.mask &= ~PSW_MASK_MCHECK;
206 }
207 
208 void restore_processor_state(void)
209 {
210         S390_lowcore.external_new_psw.mask |= PSW_MASK_MCHECK;
211         S390_lowcore.svc_new_psw.mask |= PSW_MASK_MCHECK;
212         S390_lowcore.io_new_psw.mask |= PSW_MASK_MCHECK;
213         S390_lowcore.program_new_psw.mask |= PSW_MASK_MCHECK;
214         /* Enable lowcore protection */
215         __ctl_set_bit(0,28);
216         local_mcck_enable();
217 }
218 
219 /* Called at the end of swsusp_arch_resume */
220 void s390_early_resume(void)
221 {
222         lgr_info_log();
223         channel_subsystem_reinit();
224         zpci_rescan();
225 }
226 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp