4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
27 * Page Retire - Big Theory Statement.
29 * This file handles removing sections of faulty memory from use when the
30 * user land FMA Diagnosis Engine requests that a page be removed or when
31 * a CE or UE is detected by the hardware.
33 * In the bad old days, the kernel side of Page Retire did a lot of the work
34 * on its own. Now, with the DE keeping track of errors, the kernel side is
35 * rather simple minded on most platforms.
37 * Errors are all reflected to the DE, and after digesting the error and
38 * looking at all previously reported errors, the DE decides what should
39 * be done about the current error. If the DE wants a particular page to
40 * be retired, then the kernel page retire code is invoked via an ioctl.
41 * On non-FMA platforms, the ue_drain and ce_drain paths ends up calling
42 * page retire to handle the error. Since page retire is just a simple
43 * mechanism it doesn't need to differentiate between the different callers.
45 * The p_toxic field in the page_t is used to indicate which errors have
46 * occurred and what action has been taken on a given page. Because errors are
47 * reported without regard to the locked state of a page, no locks are used
48 * to SET the error bits in p_toxic. However, in order to clear the error
49 * bits, the page_t must be held exclusively locked.
51 * When page_retire() is called, it must be able to acquire locks, sleep, etc.
52 * It must not be called from high-level interrupt context.
54 * Depending on how the requested page is being used at the time of the retire
55 * request (and on the availability of sufficient system resources), the page
56 * may be retired immediately, or just marked for retirement later. For
57 * example, locked pages are marked, while free pages are retired. Multiple
58 * requests may be made to retire the same page, although there is no need
59 * to: once the p_toxic flags are set, the page will be retired as soon as it
60 * can be exclusively locked.
62 * The retire mechanism is driven centrally out of page_unlock(). To expedite
63 * the retirement of pages, further requests for SE_SHARED locks are denied
64 * as long as a page retirement is pending. In addition, as long as pages are
65 * pending retirement a background thread runs periodically trying to retire
66 * those pages. Pages which could not be retired while the system is running
67 * are scrubbed prior to rebooting to avoid latent errors on the next boot.
69 * UE pages without persistent errors are scrubbed and returned to service.
70 * Recidivist pages, as well as FMA-directed requests for retirement, result
71 * in the page being taken out of service. Once the decision is made to take
72 * a page out of service, the page is cleared, hashed onto the retired_pages
73 * vnode, marked as retired, and it is unlocked. No other requesters (except
74 * for unretire) are allowed to lock retired pages.
76 * The public routines return (sadly) 0 if they worked and a non-zero error
77 * value if something went wrong. This is done for the ioctl side of the
78 * world to allow errors to be reflected all the way out to user land. The
79 * non-zero values are explained in comments atop each function.
85 * 1. Trying to retire non-relocatable kvp pages may result in a
86 * quagmire. This is because seg_kmem() no longer keeps its pages locked,
87 * and calls page_lookup() in the free path; since kvp pages are modified
88 * and don't have a usable backing store, page_retire() can't do anything
89 * with them, and we'll keep denying the lock to seg_kmem_free() in a
90 * vicious cycle. To prevent that, we don't deny locks to kvp pages, and
91 * hence only try to retire a page from page_unlock() in the free path.
92 * Since most kernel pages are indefinitely held anyway, and don't
93 * participate in I/O, this is of little consequence.
95 * 2. Low memory situations will be interesting. If we don't have
96 * enough memory for page_relocate() to succeed, we won't be able to
97 * retire dirty pages; nobody will be able to push them out to disk
98 * either, since we aggressively deny the page lock. We could change
99 * fsflush so it can recognize this situation, grab the lock, and push
100 * the page out, where we'll catch it in the free path and retire it.
102 * 3. Beware of places that have code like this in them:
104 * if (! page_tryupgrade(pp)) {
106 * while (! page_lock(pp, SE_EXCL, NULL, P_RECLAIM)) {
112 * The problem is that pp can change identity right after the
113 * page_unlock() call. In particular, page_retire() can step in
114 * there, change pp's identity, and hash pp onto the retired_vnode.
116 * Of course, other functions besides page_retire() can have the
117 * same effect. A kmem reader can waltz by, set up a mapping to the
118 * page, and then unlock the page. Page_free() will then go castors
119 * up. So if anybody is doing this, it's already a bug.
121 * 4. mdboot()'s call into page_retire_mdboot() should probably be
122 * moved lower. Where the call is made now, we can get into trouble
123 * by scrubbing a kernel page that is then accessed later.
126 #include <sys/types.h>
127 #include <sys/param.h>
128 #include <sys/systm.h>
129 #include <sys/mman.h>
130 #include <sys/vnode.h>
131 #include <sys/vfs_opreg.h>
132 #include <sys/cmn_err.h>
133 #include <sys/ksynch.h>
134 #include <sys/thread.h>
135 #include <sys/disp.h>
136 #include <sys/ontrap.h>
137 #include <sys/vmsystm.h>
138 #include <sys/mem_config.h>
139 #include <sys/atomic.h>
140 #include <sys/callb.h>
141 #include <sys/kobj.h>
143 #include <vm/vm_dep.h>
146 #include <vm/seg_kmem.h>
149 * vnode for all pages which are retired from the VM system;
151 vnode_t
*retired_pages
;
153 static int page_retire_pp_finish(page_t
*, void *, uint_t
);
156 * Make a list of all of the pages that have been marked for retirement
157 * but are not yet retired. At system shutdown, we will scrub all of the
158 * pages in the list in case there are outstanding UEs. Then, we
159 * cross-check this list against the number of pages that are yet to be
160 * retired, and if we find inconsistencies, we scan every page_t in the
161 * whole system looking for any pages that need to be scrubbed for UEs.
162 * The background thread also uses this queue to determine which pages
163 * it should keep trying to retire.
166 #define PR_PENDING_QMAX 32
168 #define PR_PENDING_QMAX 256
170 page_t
*pr_pending_q
[PR_PENDING_QMAX
];
174 * Page retire global kstats
176 struct page_retire_kstat
{
177 kstat_named_t pr_retired
;
178 kstat_named_t pr_requested
;
179 kstat_named_t pr_requested_free
;
180 kstat_named_t pr_enqueue_fail
;
181 kstat_named_t pr_dequeue_fail
;
182 kstat_named_t pr_pending
;
183 kstat_named_t pr_pending_kas
;
184 kstat_named_t pr_failed
;
185 kstat_named_t pr_failed_kernel
;
186 kstat_named_t pr_limit
;
187 kstat_named_t pr_limit_exceeded
;
188 kstat_named_t pr_fma
;
189 kstat_named_t pr_mce
;
191 kstat_named_t pr_ue_cleared_retire
;
192 kstat_named_t pr_ue_cleared_free
;
193 kstat_named_t pr_ue_persistent
;
194 kstat_named_t pr_unretired
;
197 static struct page_retire_kstat page_retire_kstat
= {
198 { "pages_retired", KSTAT_DATA_UINT64
},
199 { "pages_retire_request", KSTAT_DATA_UINT64
},
200 { "pages_retire_request_free", KSTAT_DATA_UINT64
},
201 { "pages_notenqueued", KSTAT_DATA_UINT64
},
202 { "pages_notdequeued", KSTAT_DATA_UINT64
},
203 { "pages_pending", KSTAT_DATA_UINT64
},
204 { "pages_pending_kas", KSTAT_DATA_UINT64
},
205 { "pages_deferred", KSTAT_DATA_UINT64
},
206 { "pages_deferred_kernel", KSTAT_DATA_UINT64
},
207 { "pages_limit", KSTAT_DATA_UINT64
},
208 { "pages_limit_exceeded", KSTAT_DATA_UINT64
},
209 { "pages_fma", KSTAT_DATA_UINT64
},
210 { "pages_multiple_ce", KSTAT_DATA_UINT64
},
211 { "pages_ue", KSTAT_DATA_UINT64
},
212 { "pages_ue_cleared_retired", KSTAT_DATA_UINT64
},
213 { "pages_ue_cleared_freed", KSTAT_DATA_UINT64
},
214 { "pages_ue_persistent", KSTAT_DATA_UINT64
},
215 { "pages_unretired", KSTAT_DATA_UINT64
},
218 static kstat_t
*page_retire_ksp
= NULL
;
220 #define PR_INCR_KSTAT(stat) \
221 atomic_inc_64(&(page_retire_kstat.stat.value.ui64))
222 #define PR_DECR_KSTAT(stat) \
223 atomic_dec_64(&(page_retire_kstat.stat.value.ui64))
225 #define PR_KSTAT_RETIRED_CE (page_retire_kstat.pr_mce.value.ui64)
226 #define PR_KSTAT_RETIRED_FMA (page_retire_kstat.pr_fma.value.ui64)
227 #define PR_KSTAT_RETIRED_NOTUE (PR_KSTAT_RETIRED_CE + PR_KSTAT_RETIRED_FMA)
228 #define PR_KSTAT_PENDING (page_retire_kstat.pr_pending.value.ui64)
229 #define PR_KSTAT_PENDING_KAS (page_retire_kstat.pr_pending_kas.value.ui64)
230 #define PR_KSTAT_EQFAIL (page_retire_kstat.pr_enqueue_fail.value.ui64)
231 #define PR_KSTAT_DQFAIL (page_retire_kstat.pr_dequeue_fail.value.ui64)
234 * page retire kstats to list all retired pages
236 static int pr_list_kstat_update(kstat_t
*ksp
, int rw
);
237 static int pr_list_kstat_snapshot(kstat_t
*ksp
, void *buf
, int rw
);
238 kmutex_t pr_list_kstat_mutex
;
241 * Limit the number of multiple CE page retires.
242 * The default is 0.1% of physmem, or 1 in 1000 pages. This is set in
243 * basis points, where 100 basis points equals one percent.
246 uint64_t max_pages_retired_bps
= MCE_BPT
;
247 #define PAGE_RETIRE_LIMIT ((physmem * max_pages_retired_bps) / 10000)
250 * Control over the verbosity of page retirement.
252 * When set to zero (the default), no messages will be printed.
253 * When set to one, summary messages will be printed.
254 * When set > one, all messages will be printed.
256 * A value of one will trigger detailed messages for retirement operations,
257 * and is intended as a platform tunable for processors where FMA's DE does
258 * not run (e.g., spitfire). Values > one are intended for debugging only.
260 int page_retire_messages
= 0;
263 * Control whether or not we return scrubbed UE pages to service.
264 * By default we do not since FMA wants to run its diagnostics first
265 * and then ask us to unretire the page if it passes. Non-FMA platforms
266 * may set this to zero so we will only retire recidivist pages. It should
267 * not be changed by the user.
269 int page_retire_first_ue
= 1;
272 * Master enable for page retire. This prevents a CE or UE early in boot
273 * from trying to retire a page before page_retire_init() has finished
274 * setting things up. This is internal only and is not a tunable!
276 static int pr_enable
= 0;
278 static void (*memscrub_notify_func
)(uint64_t);
281 struct page_retire_debug
{
301 int prd_uenotscrubbed
;
313 int prd_checkmiss_pend
;
314 int prd_checkmiss_noerr
;
321 int prd_nofreedemote
;
326 #define PR_DEBUG(foo) ((pr_debug.foo)++)
329 * A type histogram. We record the incidence of the various toxic
330 * flag combinations along with the interesting page attributes. The
331 * goal is to get as many combinations as we can while driving all
332 * pr_debug values nonzero (indicating we've exercised all possible
333 * code paths across all possible page types). Not all combinations
334 * will make sense -- e.g. PRT_MOD|PRT_KERNEL.
336 * pr_type offset bit encoding (when examining with a debugger):
347 #define PRT_NAMED 0x01
348 #define PRT_KERNEL 0x02
349 #define PRT_FREE 0x04
351 #define PRT_FMA 0x00 /* yes, this is not a mistake */
356 int pr_types
[PRT_ALL
+1];
358 #define PR_TYPES(pp) { \
361 whichtype |= PRT_NAMED; \
363 whichtype |= PRT_KERNEL; \
365 whichtype |= PRT_FREE; \
367 whichtype |= PRT_MOD; \
368 if (pp->p_toxic & PR_UE) \
369 whichtype |= PRT_UE; \
370 if (pp->p_toxic & PR_MCE) \
371 whichtype |= PRT_MCE; \
372 pr_types[whichtype]++; \
382 #define MTBF(v, f) (((++(v)) & (f)) != (f))
386 #define PR_DEBUG(foo) /* nothing */
387 #define PR_TYPES(foo) /* nothing */
388 #define MTBF(v, f) (1)
393 * page_retire_done() - completion processing
395 * Used by the page_retire code for common completion processing.
396 * It keeps track of how many times a given result has happened,
397 * and writes out an occasional message.
399 * May be called with a NULL pp (PRD_INVALID_PA case).
401 #define PRD_INVALID_KEY -1
402 #define PRD_SUCCESS 0
403 #define PRD_PENDING 1
405 #define PRD_DUPLICATE 3
406 #define PRD_INVALID_PA 4
408 #define PRD_UE_SCRUBBED 6
409 #define PRD_UNR_SUCCESS 7
410 #define PRD_UNR_CANTLOCK 8
411 #define PRD_UNR_NOT 9
413 typedef struct page_retire_op
{
414 int pr_key
; /* one of the PRD_* defines from above */
415 int pr_count
; /* How many times this has happened */
416 int pr_retval
; /* return value */
417 int pr_msglvl
; /* message level - when to print */
418 char *pr_message
; /* Cryptic message for field service */
421 static page_retire_op_t page_retire_ops
[] = {
422 /* key count retval msglvl message */
423 {PRD_SUCCESS
, 0, 0, 1,
424 "Page 0x%08x.%08x removed from service"},
425 {PRD_PENDING
, 0, EAGAIN
, 2,
426 "Page 0x%08x.%08x will be retired on free"},
427 {PRD_FAILED
, 0, EAGAIN
, 0, NULL
},
428 {PRD_DUPLICATE
, 0, EIO
, 2,
429 "Page 0x%08x.%08x already retired or pending"},
430 {PRD_INVALID_PA
, 0, EINVAL
, 2,
431 "PA 0x%08x.%08x is not a relocatable page"},
433 "Page 0x%08x.%08x not retired due to limit exceeded"},
434 {PRD_UE_SCRUBBED
, 0, 0, 1,
435 "Previously reported error on page 0x%08x.%08x cleared"},
436 {PRD_UNR_SUCCESS
, 0, 0, 1,
437 "Page 0x%08x.%08x returned to service"},
438 {PRD_UNR_CANTLOCK
, 0, EAGAIN
, 2,
439 "Page 0x%08x.%08x could not be unretired"},
440 {PRD_UNR_NOT
, 0, EIO
, 2,
441 "Page 0x%08x.%08x is not retired"},
442 {PRD_INVALID_KEY
, 0, 0, 0, NULL
} /* MUST BE LAST! */
446 * print a message if page_retire_messages is true.
448 #define PR_MESSAGE(debuglvl, msglvl, msg, pa) \
450 uint64_t p = (uint64_t)pa; \
451 if (page_retire_messages >= msglvl && msg != NULL) { \
452 cmn_err(debuglvl, msg, \
453 (uint32_t)(p >> 32), (uint32_t)p); \
458 * Note that multiple bits may be set in a single settoxic operation.
459 * May be called without the page locked.
462 page_settoxic(page_t
*pp
, uchar_t bits
)
464 atomic_or_8(&pp
->p_toxic
, bits
);
468 * Note that multiple bits may cleared in a single clrtoxic operation.
469 * Must be called with the page exclusively locked to prevent races which
470 * may attempt to retire a page without any toxic bits set.
471 * Note that the PR_CAPTURE bit can be cleared without the exclusive lock
472 * being held as there is a separate mutex which protects that bit.
475 page_clrtoxic(page_t
*pp
, uchar_t bits
)
477 ASSERT((bits
& PR_CAPTURE
) || PAGE_EXCL(pp
));
478 atomic_and_8(&pp
->p_toxic
, ~bits
);
482 * Prints any page retire messages to the user, and decides what
483 * error code is appropriate for the condition reported.
486 page_retire_done(page_t
*pp
, int code
)
488 page_retire_op_t
*prop
;
493 pa
= mmu_ptob((uint64_t)pp
->p_pagenum
);
497 for (i
= 0; page_retire_ops
[i
].pr_key
!= PRD_INVALID_KEY
; i
++) {
498 if (page_retire_ops
[i
].pr_key
== code
) {
499 prop
= &page_retire_ops
[i
];
505 if (page_retire_ops
[i
].pr_key
== PRD_INVALID_KEY
) {
506 cmn_err(CE_PANIC
, "page_retire_done: Invalid opcode %d", code
);
510 ASSERT(prop
->pr_key
== code
);
514 PR_MESSAGE(CE_NOTE
, prop
->pr_msglvl
, prop
->pr_message
, pa
);
516 page_settoxic(pp
, PR_MSG
);
519 return (prop
->pr_retval
);
523 * Act like page_destroy(), but instead of freeing the page, hash it onto
524 * the retired_pages vnode, and mark it retired.
526 * For fun, we try to scrub the page until it's squeaky clean.
527 * availrmem is adjusted here.
530 page_retire_destroy(page_t
*pp
)
532 u_offset_t off
= (u_offset_t
)((uintptr_t)pp
);
534 ASSERT(PAGE_EXCL(pp
));
535 ASSERT(!PP_ISFREE(pp
));
536 ASSERT(pp
->p_szc
== 0);
537 ASSERT(!hat_page_is_mapped(pp
));
538 ASSERT(!pp
->p_vnode
);
540 page_clr_all_props(pp
);
541 pagescrub(pp
, 0, MMU_PAGESIZE
);
545 if (page_hashin(pp
, retired_pages
, off
, NULL
) == 0) {
546 cmn_err(CE_PANIC
, "retired page %p hashin failed", (void *)pp
);
549 page_settoxic(pp
, PR_RETIRED
);
550 PR_INCR_KSTAT(pr_retired
);
552 if (pp
->p_toxic
& PR_FMA
) {
553 PR_INCR_KSTAT(pr_fma
);
554 } else if (pp
->p_toxic
& PR_UE
) {
555 PR_INCR_KSTAT(pr_ue
);
557 PR_INCR_KSTAT(pr_mce
);
560 mutex_enter(&freemem_lock
);
562 mutex_exit(&freemem_lock
);
568 * Check whether the number of pages which have been retired already exceeds
569 * the maximum allowable percentage of memory which may be retired.
571 * Returns 1 if the limit has been exceeded.
574 page_retire_limit(void)
576 if (PR_KSTAT_RETIRED_NOTUE
>= (uint64_t)PAGE_RETIRE_LIMIT
) {
577 PR_INCR_KSTAT(pr_limit_exceeded
);
584 #define MSG_DM "Data Mismatch occurred at PA 0x%08x.%08x" \
585 "[ 0x%x != 0x%x ] while attempting to clear previously " \
586 "reported error; page removed from service"
588 #define MSG_UE "Uncorrectable Error occurred at PA 0x%08x.%08x while " \
589 "attempting to clear previously reported error; page removed " \
593 * Attempt to clear a UE from a page.
594 * Returns 1 if the error has been successfully cleared.
597 page_clear_transient_ue(page_t
*pp
)
602 uint32_t pa_hi
, pa_lo
;
607 ASSERT(PAGE_EXCL(pp
));
608 ASSERT(PP_PR_REQ(pp
));
609 ASSERT(pp
->p_szc
== 0);
610 ASSERT(!hat_page_is_mapped(pp
));
613 * Clear the page and attempt to clear the UE. If we trap
614 * on the next access to the page, we know the UE has recurred.
616 pagescrub(pp
, 0, PAGESIZE
);
619 * Map the page and write a bunch of bit patterns to compare
620 * what we wrote with what we read back. This isn't a perfect
621 * test but it should be good enough to catch most of the
622 * recurring UEs. If this fails to catch a recurrent UE, we'll
623 * retire the page the next time we see a UE on the page.
625 kaddr
= ppmapin(pp
, PROT_READ
|PROT_WRITE
, (caddr_t
)-1);
627 pa
= ptob((uint64_t)page_pptonum(pp
));
628 pa_hi
= (uint32_t)(pa
>> 32);
629 pa_lo
= (uint32_t)pa
;
632 * Disable preemption to prevent the off chance that
633 * we migrate while in the middle of running through
634 * the bit pattern and run on a different processor
635 * than what we started on.
640 * Fill the page with each (0x00 - 0xFF] bit pattern, flushing
641 * the cache in between reading and writing. We do this under
642 * on_trap() protection to avoid recursion.
644 if (on_trap(&otd
, OT_DATA_EC
)) {
645 PR_MESSAGE(CE_WARN
, 1, MSG_UE
, pa
);
648 for (wb
= 0xff; wb
> 0; wb
--) {
649 for (i
= 0; i
< PAGESIZE
; i
++) {
653 sync_data_memory(kaddr
, PAGESIZE
);
655 for (i
= 0; i
< PAGESIZE
; i
++) {
659 * We had a mismatch without a trap.
660 * Uh-oh. Something is really wrong
663 if (page_retire_messages
) {
664 cmn_err(CE_WARN
, MSG_DM
,
665 pa_hi
, pa_lo
, rb
, wb
);
668 goto out
; /* double break */
678 return (errors
? 0 : 1);
682 * Try to clear a page_t with a single UE. If the UE was transient, it is
683 * returned to service, and we return 1. Otherwise we return 0 meaning
684 * that further processing is required to retire the page.
687 page_retire_transient_ue(page_t
*pp
)
689 ASSERT(PAGE_EXCL(pp
));
690 ASSERT(!hat_page_is_mapped(pp
));
693 * If this page is a repeat offender, retire him under the
694 * "two strikes and you're out" rule. The caller is responsible
695 * for scrubbing the page to try to clear the error.
697 if (pp
->p_toxic
& PR_UE_SCRUBBED
) {
698 PR_INCR_KSTAT(pr_ue_persistent
);
702 if (page_clear_transient_ue(pp
)) {
704 * We set the PR_SCRUBBED_UE bit; if we ever see this
705 * page again, we will retire it, no questions asked.
707 page_settoxic(pp
, PR_UE_SCRUBBED
);
709 if (page_retire_first_ue
) {
710 PR_INCR_KSTAT(pr_ue_cleared_retire
);
713 PR_INCR_KSTAT(pr_ue_cleared_free
);
715 page_clrtoxic(pp
, PR_UE
| PR_MCE
| PR_MSG
);
717 /* LINTED: CONSTCOND */
718 VN_DISPOSE(pp
, B_FREE
, 1, kcred
);
723 PR_INCR_KSTAT(pr_ue_persistent
);
728 * Update the statistics dynamically when our kstat is read.
731 page_retire_kstat_update(kstat_t
*ksp
, int rw
)
733 struct page_retire_kstat
*pr
;
741 pr
= (struct page_retire_kstat
*)ksp
->ks_data
;
742 ASSERT(pr
== &page_retire_kstat
);
743 pr
->pr_limit
.value
.ui64
= PAGE_RETIRE_LIMIT
;
756 pr_list_kstat_update(kstat_t
*ksp
, int rw
)
762 if (rw
== KSTAT_WRITE
)
765 vphm
= page_vnode_mutex(retired_pages
);
767 /* Needs to be under a lock so that for loop will work right */
768 if (retired_pages
->v_pages
== NULL
) {
771 ksp
->ks_data_size
= 0;
776 for (pp
= retired_pages
->v_pages
->p_vpnext
;
777 pp
!= retired_pages
->v_pages
; pp
= pp
->p_vpnext
) {
782 ksp
->ks_ndata
= count
;
783 ksp
->ks_data_size
= count
* 2 * sizeof (uint64_t);
789 * all spans will be pagesize and no coalescing will be done with the
793 pr_list_kstat_snapshot(kstat_t
*ksp
, void *buf
, int rw
)
802 if (rw
== KSTAT_WRITE
)
805 ksp
->ks_snaptime
= gethrtime();
807 kspmem
= (struct memunit
*)buf
;
809 vphm
= page_vnode_mutex(retired_pages
);
811 pp
= retired_pages
->v_pages
;
812 if (((caddr_t
)kspmem
>= (caddr_t
)buf
+ ksp
->ks_data_size
) ||
817 kspmem
->address
= ptob(pp
->p_pagenum
);
818 kspmem
->size
= PAGESIZE
;
820 for (pp
= pp
->p_vpnext
; pp
!= retired_pages
->v_pages
;
821 pp
= pp
->p_vpnext
, kspmem
++) {
822 if ((caddr_t
)kspmem
>= (caddr_t
)buf
+ ksp
->ks_data_size
)
824 kspmem
->address
= ptob(pp
->p_pagenum
);
825 kspmem
->size
= PAGESIZE
;
833 * page_retire_pend_count -- helper function for page_capture_thread,
834 * returns the number of pages pending retirement.
837 page_retire_pend_count(void)
839 return (PR_KSTAT_PENDING
);
843 page_retire_pend_kas_count(void)
845 return (PR_KSTAT_PENDING_KAS
);
849 page_retire_incr_pend_count(void *datap
)
851 PR_INCR_KSTAT(pr_pending
);
853 if ((datap
== &kvp
) || (datap
== &zvp
)) {
854 PR_INCR_KSTAT(pr_pending_kas
);
859 page_retire_decr_pend_count(void *datap
)
861 PR_DECR_KSTAT(pr_pending
);
863 if ((datap
== &kvp
) || (datap
== &zvp
)) {
864 PR_DECR_KSTAT(pr_pending_kas
);
869 * Initialize the page retire mechanism:
871 * - Establish the correctable error retire limit.
872 * - Initialize locks.
873 * - Build the retired_pages vnode.
874 * - Set up the kstats.
875 * - Fire off the background thread.
876 * - Tell page_retire() it's OK to start retiring pages.
879 page_retire_init(void)
881 const fs_operation_def_t retired_vnodeops_template
[] = {
884 struct vnodeops
*vops
;
887 const uint_t page_retire_ndata
=
888 sizeof (page_retire_kstat
) / sizeof (kstat_named_t
);
890 ASSERT(page_retire_ksp
== NULL
);
892 if (max_pages_retired_bps
<= 0) {
893 max_pages_retired_bps
= MCE_BPT
;
896 mutex_init(&pr_q_mutex
, NULL
, MUTEX_DEFAULT
, NULL
);
898 retired_pages
= vn_alloc(KM_SLEEP
);
899 if (vn_make_ops("retired_pages", retired_vnodeops_template
, &vops
)) {
901 "page_retired_init: can't make retired vnodeops");
903 vn_setops(retired_pages
, vops
);
905 if ((page_retire_ksp
= kstat_create("unix", 0, "page_retire",
906 "misc", KSTAT_TYPE_NAMED
, page_retire_ndata
,
907 KSTAT_FLAG_VIRTUAL
)) == NULL
) {
908 cmn_err(CE_WARN
, "kstat_create for page_retire failed");
910 page_retire_ksp
->ks_data
= (void *)&page_retire_kstat
;
911 page_retire_ksp
->ks_update
= page_retire_kstat_update
;
912 kstat_install(page_retire_ksp
);
915 mutex_init(&pr_list_kstat_mutex
, NULL
, MUTEX_DEFAULT
, NULL
);
916 ksp
= kstat_create("unix", 0, "page_retire_list", "misc",
917 KSTAT_TYPE_RAW
, 0, KSTAT_FLAG_VAR_SIZE
| KSTAT_FLAG_VIRTUAL
);
919 ksp
->ks_update
= pr_list_kstat_update
;
920 ksp
->ks_snapshot
= pr_list_kstat_snapshot
;
921 ksp
->ks_lock
= &pr_list_kstat_mutex
;
925 memscrub_notify_func
=
926 (void(*)(uint64_t))kobj_getsymvalue("memscrub_notify", 0);
928 page_capture_register_callback(PC_RETIRE
, -1, page_retire_pp_finish
);
933 * page_retire_hunt() callback for the retire thread.
936 page_retire_thread_cb(page_t
*pp
)
939 if (!PP_ISKAS(pp
) && page_trylock(pp
, SE_EXCL
)) {
940 PR_DEBUG(prd_tclocked
);
946 * Callback used by page_trycapture() to finish off retiring a page.
947 * The page has already been cleaned and we've been given sole access to
949 * Always returns 0 to indicate that callback succeded as the callback never
950 * fails to finish retiring the given page.
954 page_retire_pp_finish(page_t
*pp
, void *notused
, uint_t flags
)
958 ASSERT(PAGE_EXCL(pp
));
959 ASSERT(pp
->p_iolock_state
== 0);
960 ASSERT(pp
->p_szc
== 0);
965 * The problem page is locked, demoted, unmapped, not free,
966 * hashed out, and not COW or mlocked (whew!).
968 * Now we select our ammunition, take it around back, and shoot it.
972 if (page_retire_transient_ue(pp
)) {
973 PR_DEBUG(prd_uescrubbed
);
974 (void) page_retire_done(pp
, PRD_UE_SCRUBBED
);
976 PR_DEBUG(prd_uenotscrubbed
);
977 page_retire_destroy(pp
);
978 (void) page_retire_done(pp
, PRD_SUCCESS
);
981 } else if (toxic
& PR_FMA
) {
983 page_retire_destroy(pp
);
984 (void) page_retire_done(pp
, PRD_SUCCESS
);
986 } else if (toxic
& PR_MCE
) {
988 page_retire_destroy(pp
);
989 (void) page_retire_done(pp
, PRD_SUCCESS
);
994 * When page_retire_first_ue is set to zero and a UE occurs which is
995 * transient, it's possible that we clear some flags set by a second
996 * UE error on the page which occurs while the first is currently being
997 * handled and thus we need to handle the case where none of the above
998 * are set. In this instance, PR_UE_SCRUBBED should be set and thus
999 * we should execute the UE code above.
1001 if (toxic
& PR_UE_SCRUBBED
) {
1006 * It's impossible to get here.
1008 panic("bad toxic flags 0x%x in page_retire_pp_finish\n", toxic
);
1013 * page_retire() - the front door in to retire a page.
1015 * Ideally, page_retire() would instantly retire the requested page.
1016 * Unfortunately, some pages are locked or otherwise tied up and cannot be
1017 * retired right away. We use the page capture logic to deal with this
1018 * situation as it will continuously try to retire the page in the background
1019 * if the first attempt fails. Success is determined by looking to see whether
1020 * the page has been retired after the page_trycapture() attempt.
1025 * - EINVAL when the PA is whacko,
1026 * - EIO if the page is already retired or already pending retirement, or
1027 * - EAGAIN if the page could not be _immediately_ retired but is pending.
1030 page_retire(uint64_t pa
, uchar_t reason
)
1034 ASSERT(reason
& PR_REASONS
); /* there must be a reason */
1035 ASSERT(!(reason
& ~PR_REASONS
)); /* but no other bits */
1037 pp
= page_numtopp_nolock(mmu_btop(pa
));
1039 PR_MESSAGE(CE_WARN
, 1, "Cannot schedule clearing of error on"
1040 " page 0x%08x.%08x; page is not relocatable memory", pa
);
1041 return (page_retire_done(pp
, PRD_INVALID_PA
));
1043 if (PP_RETIRED(pp
)) {
1045 return (page_retire_done(pp
, PRD_DUPLICATE
));
1048 if (memscrub_notify_func
!= NULL
) {
1049 (void) memscrub_notify_func(pa
);
1052 if ((reason
& PR_UE
) && !PP_TOXIC(pp
)) {
1053 PR_MESSAGE(CE_NOTE
, 1, "Scheduling clearing of error on"
1054 " page 0x%08x.%08x", pa
);
1055 } else if (PP_PR_REQ(pp
)) {
1057 return (page_retire_done(pp
, PRD_DUPLICATE
));
1059 PR_MESSAGE(CE_NOTE
, 1, "Scheduling removal of"
1060 " page 0x%08x.%08x", pa
);
1063 /* Avoid setting toxic bits in the first place */
1064 if ((reason
& (PR_FMA
| PR_MCE
)) && !(reason
& PR_UE
) &&
1065 page_retire_limit()) {
1066 return (page_retire_done(pp
, PRD_LIMIT
));
1069 if (MTBF(pr_calls
, pr_mtbf
)) {
1070 page_settoxic(pp
, reason
);
1071 if (page_trycapture(pp
, 0, CAPTURE_RETIRE
, pp
->p_vnode
) == 0) {
1072 PR_DEBUG(prd_prlocked
);
1074 PR_DEBUG(prd_prnotlocked
);
1077 PR_DEBUG(prd_prnotlocked
);
1080 if (PP_RETIRED(pp
)) {
1081 PR_DEBUG(prd_prretired
);
1085 PR_INCR_KSTAT(pr_failed
);
1087 if (pp
->p_toxic
& PR_MSG
) {
1088 return (page_retire_done(pp
, PRD_FAILED
));
1090 return (page_retire_done(pp
, PRD_PENDING
));
1096 * Take a retired page off the retired-pages vnode and clear the toxic flags.
1097 * If "free" is nonzero, lock it and put it back on the freelist. If "free"
1098 * is zero, the caller already holds SE_EXCL lock so we simply unretire it
1099 * and don't do anything else with it.
1101 * Any unretire messages are printed from this routine.
1103 * Returns 0 if page pp was unretired; else an error code.
1106 * PR_UNR_FREE - lock the page, clear the toxic flags and free it
1108 * PR_UNR_TEMP - lock the page, unretire it, leave the toxic
1109 * bits set as is and return it to the caller.
1110 * PR_UNR_CLEAN - page is SE_EXCL locked, unretire it, clear the
1111 * toxic flags and return it to caller as is.
1114 page_unretire_pp(page_t
*pp
, int flags
)
1117 * To be retired, a page has to be hashed onto the retired_pages vnode
1118 * and have PR_RETIRED set in p_toxic.
1120 if (flags
== PR_UNR_CLEAN
||
1121 page_try_reclaim_lock(pp
, SE_EXCL
, SE_RETIRED
)) {
1122 ASSERT(PAGE_EXCL(pp
));
1123 PR_DEBUG(prd_ulocked
);
1124 if (!PP_RETIRED(pp
)) {
1125 PR_DEBUG(prd_unotretired
);
1127 return (page_retire_done(pp
, PRD_UNR_NOT
));
1130 PR_MESSAGE(CE_NOTE
, 1, "unretiring retired"
1131 " page 0x%08x.%08x", mmu_ptob((uint64_t)pp
->p_pagenum
));
1132 if (pp
->p_toxic
& PR_FMA
) {
1133 PR_DECR_KSTAT(pr_fma
);
1134 } else if (pp
->p_toxic
& PR_UE
) {
1135 PR_DECR_KSTAT(pr_ue
);
1137 PR_DECR_KSTAT(pr_mce
);
1140 if (flags
== PR_UNR_TEMP
)
1141 page_clrtoxic(pp
, PR_RETIRED
);
1143 page_clrtoxic(pp
, PR_TOXICFLAGS
);
1145 if (flags
== PR_UNR_FREE
) {
1146 PR_DEBUG(prd_udestroy
);
1147 page_destroy(pp
, 0);
1149 PR_DEBUG(prd_uhashout
);
1150 page_hashout(pp
, NULL
);
1153 mutex_enter(&freemem_lock
);
1155 mutex_exit(&freemem_lock
);
1157 PR_DEBUG(prd_uunretired
);
1158 PR_DECR_KSTAT(pr_retired
);
1159 PR_INCR_KSTAT(pr_unretired
);
1160 return (page_retire_done(pp
, PRD_UNR_SUCCESS
));
1162 PR_DEBUG(prd_unotlocked
);
1163 return (page_retire_done(pp
, PRD_UNR_CANTLOCK
));
1167 * Return a page to service by moving it from the retired_pages vnode
1168 * onto the freelist.
1170 * Called from mmioctl_page_retire() on behalf of the FMA DE.
1174 * - 0 if the page is unretired,
1175 * - EAGAIN if the pp can not be locked,
1176 * - EINVAL if the PA is whacko, and
1177 * - EIO if the pp is not retired.
1180 page_unretire(uint64_t pa
)
1184 pp
= page_numtopp_nolock(mmu_btop(pa
));
1186 return (page_retire_done(pp
, PRD_INVALID_PA
));
1189 return (page_unretire_pp(pp
, PR_UNR_FREE
));
1193 * Test a page to see if it is retired. If errors is non-NULL, the toxic
1194 * bits of the page are returned. Returns 0 on success, error code on failure.
1197 page_retire_check_pp(page_t
*pp
, uint64_t *errors
)
1201 if (PP_RETIRED(pp
)) {
1202 PR_DEBUG(prd_checkhit
);
1204 } else if (PP_PR_REQ(pp
)) {
1205 PR_DEBUG(prd_checkmiss_pend
);
1208 PR_DEBUG(prd_checkmiss_noerr
);
1213 * We have magically arranged the bit values returned to fmd(1M)
1214 * to line up with the FMA, MCE, and UE bits of the page_t.
1217 uint64_t toxic
= (uint64_t)(pp
->p_toxic
& PR_ERRMASK
);
1218 if (toxic
& PR_UE_SCRUBBED
) {
1219 toxic
&= ~PR_UE_SCRUBBED
;
1229 * Test to see if the page_t for a given PA is retired, and return the
1230 * hardware errors we have seen on the page if requested.
1232 * Called from mmioctl_page_retire on behalf of the FMA DE.
1236 * - 0 if the page is retired,
1237 * - EIO if the page is not retired and has no errors,
1238 * - EAGAIN if the page is not retired but is pending; and
1239 * - EINVAL if the PA is whacko.
1242 page_retire_check(uint64_t pa
, uint64_t *errors
)
1250 pp
= page_numtopp_nolock(mmu_btop(pa
));
1252 return (page_retire_done(pp
, PRD_INVALID_PA
));
1255 return (page_retire_check_pp(pp
, errors
));
1259 * Page retire self-test. For now, it always returns 0.
1262 page_retire_test(void)
1264 page_t
*first
, *pp
, *cpp
, *cpp2
, *lpp
;
1267 * Tests the corner case where a large page can't be retired
1268 * because one of the constituent pages is locked. We mark
1269 * one page to be retired and try to retire it, and mark the
1270 * other page to be retired but don't try to retire it, so
1271 * that page_unlock() in the failure path will recurse and try
1272 * to retire THAT page. This is the worst possible situation
1273 * we can get ourselves into.
1276 pp
= first
= page_first();
1278 if (pp
->p_szc
&& PP_PAGEROOT(pp
) == pp
) {
1280 lpp
= PP_ISFREE(pp
)? pp
: pp
+ 2;
1282 if (!page_trylock(lpp
, pp
== lpp
? SE_EXCL
: SE_SHARED
))
1284 if (!page_trylock(cpp
, SE_EXCL
)) {
1290 (void) page_retire(ptob(cpp
->p_pagenum
), PR_FMA
);
1294 (void) page_retire(ptob(cpp
->p_pagenum
), PR_FMA
);
1295 (void) page_retire(ptob(cpp2
->p_pagenum
), PR_FMA
);
1297 } while ((pp
= page_next(pp
)) != first
);