2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * Copyright (c) 2004-2006 Silicon Graphics, Inc. All Rights Reserved.
11 * Cross Partition Communication (XPC) partition support.
13 * This is the part of XPC that detects the presence/absence of
14 * other partitions. It provides a heartbeat and monitors the
15 * heartbeats of other partitions.
20 #include <linux/kernel.h>
21 #include <linux/sysctl.h>
22 #include <linux/cache.h>
23 #include <linux/mmzone.h>
24 #include <linux/nodemask.h>
25 #include <asm/uncached.h>
26 #include <asm/sn/bte.h>
27 #include <asm/sn/intr.h>
28 #include <asm/sn/sn_sal.h>
29 #include <asm/sn/nodepda.h>
30 #include <asm/sn/addrs.h>
31 #include <asm/sn/xpc.h>
34 /* XPC is exiting flag */
38 /* SH_IPI_ACCESS shub register value on startup */
39 static u64 xpc_sh1_IPI_access
;
40 static u64 xpc_sh2_IPI_access0
;
41 static u64 xpc_sh2_IPI_access1
;
42 static u64 xpc_sh2_IPI_access2
;
43 static u64 xpc_sh2_IPI_access3
;
46 /* original protection values for each node */
47 u64 xpc_prot_vec
[MAX_NUMNODES
];
50 /* this partition's reserved page pointers */
51 struct xpc_rsvd_page
*xpc_rsvd_page
;
52 static u64
*xpc_part_nasids
;
53 static u64
*xpc_mach_nasids
;
54 struct xpc_vars
*xpc_vars
;
55 struct xpc_vars_part
*xpc_vars_part
;
57 static int xp_nasid_mask_bytes
; /* actual size in bytes of nasid mask */
58 static int xp_nasid_mask_words
; /* actual size in words of nasid mask */
62 * For performance reasons, each entry of xpc_partitions[] is cacheline
63 * aligned. And xpc_partitions[] is padded with an additional entry at the
64 * end so that the last legitimate entry doesn't share its cacheline with
67 struct xpc_partition xpc_partitions
[XP_MAX_PARTITIONS
+ 1];
71 * Generic buffer used to store a local copy of portions of a remote
72 * partition's reserved page (either its header and part_nasids mask,
75 * xpc_discovery runs only once and is a seperate thread that is
76 * very likely going to be processing in parallel with receiving
79 char ____cacheline_aligned xpc_remote_copy_buffer
[XPC_RP_HEADER_SIZE
+
84 * Guarantee that the kmalloc'd memory is cacheline aligned.
87 xpc_kmalloc_cacheline_aligned(size_t size
, gfp_t flags
, void **base
)
89 /* see if kmalloc will give us cachline aligned memory by default */
90 *base
= kmalloc(size
, flags
);
94 if ((u64
) *base
== L1_CACHE_ALIGN((u64
) *base
)) {
99 /* nope, we'll have to do it ourselves */
100 *base
= kmalloc(size
+ L1_CACHE_BYTES
, flags
);
104 return (void *) L1_CACHE_ALIGN((u64
) *base
);
109 * Given a nasid, get the physical address of the partition's reserved page
110 * for that nasid. This function returns 0 on any error.
113 xpc_get_rsvd_page_pa(int nasid
)
115 bte_result_t bte_res
;
118 u64 rp_pa
= nasid
; /* seed with nasid */
122 void *buf_base
= NULL
;
127 status
= sn_partition_reserved_page_pa(buf
, &cookie
, &rp_pa
,
130 dev_dbg(xpc_part
, "SAL returned with status=%li, cookie="
131 "0x%016lx, address=0x%016lx, len=0x%016lx\n",
132 status
, cookie
, rp_pa
, len
);
134 if (status
!= SALRET_MORE_PASSES
) {
138 if (L1_CACHE_ALIGN(len
) > buf_len
) {
140 buf_len
= L1_CACHE_ALIGN(len
);
141 buf
= (u64
) xpc_kmalloc_cacheline_aligned(buf_len
,
142 GFP_KERNEL
, &buf_base
);
143 if (buf_base
== NULL
) {
144 dev_err(xpc_part
, "unable to kmalloc "
145 "len=0x%016lx\n", buf_len
);
146 status
= SALRET_ERROR
;
151 bte_res
= xp_bte_copy(rp_pa
, ia64_tpa(buf
), buf_len
,
152 (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
153 if (bte_res
!= BTE_SUCCESS
) {
154 dev_dbg(xpc_part
, "xp_bte_copy failed %i\n", bte_res
);
155 status
= SALRET_ERROR
;
162 if (status
!= SALRET_OK
) {
165 dev_dbg(xpc_part
, "reserved page at phys address 0x%016lx\n", rp_pa
);
171 * Fill the partition reserved page with the information needed by
172 * other partitions to discover we are alive and establish initial
175 struct xpc_rsvd_page
*
176 xpc_rsvd_page_init(void)
178 struct xpc_rsvd_page
*rp
;
180 u64 rp_pa
, nasid_array
= 0;
184 /* get the local reserved page's address */
187 rp_pa
= xpc_get_rsvd_page_pa(cpuid_to_nasid(smp_processor_id()));
190 dev_err(xpc_part
, "SAL failed to locate the reserved page\n");
193 rp
= (struct xpc_rsvd_page
*) __va(rp_pa
);
195 if (rp
->partid
!= sn_partition_id
) {
196 dev_err(xpc_part
, "the reserved page's partid of %d should be "
197 "%d\n", rp
->partid
, sn_partition_id
);
201 rp
->version
= XPC_RP_VERSION
;
203 /* establish the actual sizes of the nasid masks */
204 if (rp
->SAL_version
== 1) {
205 /* SAL_version 1 didn't set the nasids_size field */
206 rp
->nasids_size
= 128;
208 xp_nasid_mask_bytes
= rp
->nasids_size
;
209 xp_nasid_mask_words
= xp_nasid_mask_bytes
/ 8;
211 /* setup the pointers to the various items in the reserved page */
212 xpc_part_nasids
= XPC_RP_PART_NASIDS(rp
);
213 xpc_mach_nasids
= XPC_RP_MACH_NASIDS(rp
);
214 xpc_vars
= XPC_RP_VARS(rp
);
215 xpc_vars_part
= XPC_RP_VARS_PART(rp
);
218 * Before clearing xpc_vars, see if a page of AMOs had been previously
219 * allocated. If not we'll need to allocate one and set permissions
220 * so that cross-partition AMOs are allowed.
222 * The allocated AMO page needs MCA reporting to remain disabled after
223 * XPC has unloaded. To make this work, we keep a copy of the pointer
224 * to this page (i.e., amos_page) in the struct xpc_vars structure,
225 * which is pointed to by the reserved page, and re-use that saved copy
226 * on subsequent loads of XPC. This AMO page is never freed, and its
227 * memory protections are never restricted.
229 if ((amos_page
= xpc_vars
->amos_page
) == NULL
) {
230 amos_page
= (AMO_t
*) TO_AMO(uncached_alloc_page(0));
231 if (amos_page
== NULL
) {
232 dev_err(xpc_part
, "can't allocate page of AMOs\n");
237 * Open up AMO-R/W to cpu. This is done for Shub 1.1 systems
238 * when xpc_allow_IPI_ops() is called via xpc_hb_init().
240 if (!enable_shub_wars_1_1()) {
241 ret
= sn_change_memprotect(ia64_tpa((u64
) amos_page
),
242 PAGE_SIZE
, SN_MEMPROT_ACCESS_CLASS_1
,
245 dev_err(xpc_part
, "can't change memory "
247 uncached_free_page(__IA64_UNCACHED_OFFSET
|
248 TO_PHYS((u64
) amos_page
));
252 } else if (!IS_AMO_ADDRESS((u64
) amos_page
)) {
254 * EFI's XPBOOT can also set amos_page in the reserved page,
255 * but it happens to leave it as an uncached physical address
256 * and we need it to be an uncached virtual, so we'll have to
259 if (!IS_AMO_PHYS_ADDRESS((u64
) amos_page
)) {
260 dev_err(xpc_part
, "previously used amos_page address "
261 "is bad = 0x%p\n", (void *) amos_page
);
264 amos_page
= (AMO_t
*) TO_AMO((u64
) amos_page
);
268 memset(xpc_vars
, 0, sizeof(struct xpc_vars
));
270 xpc_vars
->version
= XPC_V_VERSION
;
271 xpc_vars
->act_nasid
= cpuid_to_nasid(0);
272 xpc_vars
->act_phys_cpuid
= cpu_physical_id(0);
273 xpc_vars
->vars_part_pa
= __pa(xpc_vars_part
);
274 xpc_vars
->amos_page_pa
= ia64_tpa((u64
) amos_page
);
275 xpc_vars
->amos_page
= amos_page
; /* save for next load of XPC */
278 /* clear xpc_vars_part */
279 memset((u64
*) xpc_vars_part
, 0, sizeof(struct xpc_vars_part
) *
282 /* initialize the activate IRQ related AMO variables */
283 for (i
= 0; i
< xp_nasid_mask_words
; i
++) {
284 (void) xpc_IPI_init(XPC_ACTIVATE_IRQ_AMOS
+ i
);
287 /* initialize the engaged remote partitions related AMO variables */
288 (void) xpc_IPI_init(XPC_ENGAGED_PARTITIONS_AMO
);
289 (void) xpc_IPI_init(XPC_DISENGAGE_REQUEST_AMO
);
291 /* timestamp of when reserved page was setup by XPC */
292 rp
->stamp
= CURRENT_TIME
;
295 * This signifies to the remote partition that our reserved
296 * page is initialized.
298 rp
->vars_pa
= __pa(xpc_vars
);
305 * Change protections to allow IPI operations (and AMO operations on
309 xpc_allow_IPI_ops(void)
315 // >>> Change SH_IPI_ACCESS code to use SAL call once it is available.
318 xpc_sh2_IPI_access0
=
319 (u64
) HUB_L((u64
*) LOCAL_MMR_ADDR(SH2_IPI_ACCESS0
));
320 xpc_sh2_IPI_access1
=
321 (u64
) HUB_L((u64
*) LOCAL_MMR_ADDR(SH2_IPI_ACCESS1
));
322 xpc_sh2_IPI_access2
=
323 (u64
) HUB_L((u64
*) LOCAL_MMR_ADDR(SH2_IPI_ACCESS2
));
324 xpc_sh2_IPI_access3
=
325 (u64
) HUB_L((u64
*) LOCAL_MMR_ADDR(SH2_IPI_ACCESS3
));
327 for_each_online_node(node
) {
328 nasid
= cnodeid_to_nasid(node
);
329 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS0
),
331 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS1
),
333 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS2
),
335 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS3
),
341 (u64
) HUB_L((u64
*) LOCAL_MMR_ADDR(SH1_IPI_ACCESS
));
343 for_each_online_node(node
) {
344 nasid
= cnodeid_to_nasid(node
);
345 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH1_IPI_ACCESS
),
349 * Since the BIST collides with memory operations on
350 * SHUB 1.1 sn_change_memprotect() cannot be used.
352 if (enable_shub_wars_1_1()) {
353 /* open up everything */
354 xpc_prot_vec
[node
] = (u64
) HUB_L((u64
*)
355 GLOBAL_MMR_ADDR(nasid
,
356 SH1_MD_DQLP_MMR_DIR_PRIVEC0
));
357 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
,
358 SH1_MD_DQLP_MMR_DIR_PRIVEC0
),
360 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
,
361 SH1_MD_DQRP_MMR_DIR_PRIVEC0
),
370 * Restrict protections to disallow IPI operations (and AMO operations on
374 xpc_restrict_IPI_ops(void)
380 // >>> Change SH_IPI_ACCESS code to use SAL call once it is available.
384 for_each_online_node(node
) {
385 nasid
= cnodeid_to_nasid(node
);
386 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS0
),
387 xpc_sh2_IPI_access0
);
388 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS1
),
389 xpc_sh2_IPI_access1
);
390 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS2
),
391 xpc_sh2_IPI_access2
);
392 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH2_IPI_ACCESS3
),
393 xpc_sh2_IPI_access3
);
398 for_each_online_node(node
) {
399 nasid
= cnodeid_to_nasid(node
);
400 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
, SH1_IPI_ACCESS
),
403 if (enable_shub_wars_1_1()) {
404 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
,
405 SH1_MD_DQLP_MMR_DIR_PRIVEC0
),
407 HUB_S((u64
*) GLOBAL_MMR_ADDR(nasid
,
408 SH1_MD_DQRP_MMR_DIR_PRIVEC0
),
417 * At periodic intervals, scan through all active partitions and ensure
418 * their heartbeat is still active. If not, the partition is deactivated.
421 xpc_check_remote_hb(void)
423 struct xpc_vars
*remote_vars
;
424 struct xpc_partition
*part
;
429 remote_vars
= (struct xpc_vars
*) xpc_remote_copy_buffer
;
431 for (partid
= 1; partid
< XP_MAX_PARTITIONS
; partid
++) {
437 if (partid
== sn_partition_id
) {
441 part
= &xpc_partitions
[partid
];
443 if (part
->act_state
== XPC_P_INACTIVE
||
444 part
->act_state
== XPC_P_DEACTIVATING
) {
448 /* pull the remote_hb cache line */
449 bres
= xp_bte_copy(part
->remote_vars_pa
,
450 ia64_tpa((u64
) remote_vars
),
452 (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
453 if (bres
!= BTE_SUCCESS
) {
454 XPC_DEACTIVATE_PARTITION(part
,
455 xpc_map_bte_errors(bres
));
459 dev_dbg(xpc_part
, "partid = %d, heartbeat = %ld, last_heartbeat"
460 " = %ld, heartbeat_offline = %ld, HB_mask = 0x%lx\n",
461 partid
, remote_vars
->heartbeat
, part
->last_heartbeat
,
462 remote_vars
->heartbeat_offline
,
463 remote_vars
->heartbeating_to_mask
);
465 if (((remote_vars
->heartbeat
== part
->last_heartbeat
) &&
466 (remote_vars
->heartbeat_offline
== 0)) ||
467 !xpc_hb_allowed(sn_partition_id
, remote_vars
)) {
469 XPC_DEACTIVATE_PARTITION(part
, xpcNoHeartbeat
);
473 part
->last_heartbeat
= remote_vars
->heartbeat
;
479 * Get a copy of a portion of the remote partition's rsvd page.
481 * remote_rp points to a buffer that is cacheline aligned for BTE copies and
482 * is large enough to contain a copy of their reserved page header and
485 static enum xpc_retval
486 xpc_get_remote_rp(int nasid
, u64
*discovered_nasids
,
487 struct xpc_rsvd_page
*remote_rp
, u64
*remote_rp_pa
)
492 /* get the reserved page's physical address */
494 *remote_rp_pa
= xpc_get_rsvd_page_pa(nasid
);
495 if (*remote_rp_pa
== 0) {
496 return xpcNoRsvdPageAddr
;
500 /* pull over the reserved page header and part_nasids mask */
502 bres
= xp_bte_copy(*remote_rp_pa
, ia64_tpa((u64
) remote_rp
),
503 XPC_RP_HEADER_SIZE
+ xp_nasid_mask_bytes
,
504 (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
505 if (bres
!= BTE_SUCCESS
) {
506 return xpc_map_bte_errors(bres
);
510 if (discovered_nasids
!= NULL
) {
511 u64
*remote_part_nasids
= XPC_RP_PART_NASIDS(remote_rp
);
514 for (i
= 0; i
< xp_nasid_mask_words
; i
++) {
515 discovered_nasids
[i
] |= remote_part_nasids
[i
];
520 /* check that the partid is for another partition */
522 if (remote_rp
->partid
< 1 ||
523 remote_rp
->partid
> (XP_MAX_PARTITIONS
- 1)) {
524 return xpcInvalidPartid
;
527 if (remote_rp
->partid
== sn_partition_id
) {
528 return xpcLocalPartid
;
532 if (XPC_VERSION_MAJOR(remote_rp
->version
) !=
533 XPC_VERSION_MAJOR(XPC_RP_VERSION
)) {
534 return xpcBadVersion
;
542 * Get a copy of the remote partition's XPC variables from the reserved page.
544 * remote_vars points to a buffer that is cacheline aligned for BTE copies and
545 * assumed to be of size XPC_RP_VARS_SIZE.
547 static enum xpc_retval
548 xpc_get_remote_vars(u64 remote_vars_pa
, struct xpc_vars
*remote_vars
)
553 if (remote_vars_pa
== 0) {
554 return xpcVarsNotSet
;
558 /* pull over the cross partition variables */
560 bres
= xp_bte_copy(remote_vars_pa
, ia64_tpa((u64
) remote_vars
),
562 (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
563 if (bres
!= BTE_SUCCESS
) {
564 return xpc_map_bte_errors(bres
);
567 if (XPC_VERSION_MAJOR(remote_vars
->version
) !=
568 XPC_VERSION_MAJOR(XPC_V_VERSION
)) {
569 return xpcBadVersion
;
577 * Update the remote partition's info.
580 xpc_update_partition_info(struct xpc_partition
*part
, u8 remote_rp_version
,
581 struct timespec
*remote_rp_stamp
, u64 remote_rp_pa
,
582 u64 remote_vars_pa
, struct xpc_vars
*remote_vars
)
584 part
->remote_rp_version
= remote_rp_version
;
585 dev_dbg(xpc_part
, " remote_rp_version = 0x%016lx\n",
586 part
->remote_rp_version
);
588 part
->remote_rp_stamp
= *remote_rp_stamp
;
589 dev_dbg(xpc_part
, " remote_rp_stamp (tv_sec = 0x%lx tv_nsec = 0x%lx\n",
590 part
->remote_rp_stamp
.tv_sec
, part
->remote_rp_stamp
.tv_nsec
);
592 part
->remote_rp_pa
= remote_rp_pa
;
593 dev_dbg(xpc_part
, " remote_rp_pa = 0x%016lx\n", part
->remote_rp_pa
);
595 part
->remote_vars_pa
= remote_vars_pa
;
596 dev_dbg(xpc_part
, " remote_vars_pa = 0x%016lx\n",
597 part
->remote_vars_pa
);
599 part
->last_heartbeat
= remote_vars
->heartbeat
;
600 dev_dbg(xpc_part
, " last_heartbeat = 0x%016lx\n",
601 part
->last_heartbeat
);
603 part
->remote_vars_part_pa
= remote_vars
->vars_part_pa
;
604 dev_dbg(xpc_part
, " remote_vars_part_pa = 0x%016lx\n",
605 part
->remote_vars_part_pa
);
607 part
->remote_act_nasid
= remote_vars
->act_nasid
;
608 dev_dbg(xpc_part
, " remote_act_nasid = 0x%x\n",
609 part
->remote_act_nasid
);
611 part
->remote_act_phys_cpuid
= remote_vars
->act_phys_cpuid
;
612 dev_dbg(xpc_part
, " remote_act_phys_cpuid = 0x%x\n",
613 part
->remote_act_phys_cpuid
);
615 part
->remote_amos_page_pa
= remote_vars
->amos_page_pa
;
616 dev_dbg(xpc_part
, " remote_amos_page_pa = 0x%lx\n",
617 part
->remote_amos_page_pa
);
619 part
->remote_vars_version
= remote_vars
->version
;
620 dev_dbg(xpc_part
, " remote_vars_version = 0x%x\n",
621 part
->remote_vars_version
);
626 * Prior code has determined the nasid which generated an IPI. Inspect
627 * that nasid to determine if its partition needs to be activated or
630 * A partition is consider "awaiting activation" if our partition
631 * flags indicate it is not active and it has a heartbeat. A
632 * partition is considered "awaiting deactivation" if our partition
633 * flags indicate it is active but it has no heartbeat or it is not
634 * sending its heartbeat to us.
636 * To determine the heartbeat, the remote nasid must have a properly
637 * initialized reserved page.
640 xpc_identify_act_IRQ_req(int nasid
)
642 struct xpc_rsvd_page
*remote_rp
;
643 struct xpc_vars
*remote_vars
;
646 int remote_rp_version
;
649 struct timespec remote_rp_stamp
= { 0, 0 };
651 struct xpc_partition
*part
;
655 /* pull over the reserved page structure */
657 remote_rp
= (struct xpc_rsvd_page
*) xpc_remote_copy_buffer
;
659 ret
= xpc_get_remote_rp(nasid
, NULL
, remote_rp
, &remote_rp_pa
);
660 if (ret
!= xpcSuccess
) {
661 dev_warn(xpc_part
, "unable to get reserved page from nasid %d, "
662 "which sent interrupt, reason=%d\n", nasid
, ret
);
666 remote_vars_pa
= remote_rp
->vars_pa
;
667 remote_rp_version
= remote_rp
->version
;
668 if (XPC_SUPPORTS_RP_STAMP(remote_rp_version
)) {
669 remote_rp_stamp
= remote_rp
->stamp
;
671 partid
= remote_rp
->partid
;
672 part
= &xpc_partitions
[partid
];
675 /* pull over the cross partition variables */
677 remote_vars
= (struct xpc_vars
*) xpc_remote_copy_buffer
;
679 ret
= xpc_get_remote_vars(remote_vars_pa
, remote_vars
);
680 if (ret
!= xpcSuccess
) {
682 dev_warn(xpc_part
, "unable to get XPC variables from nasid %d, "
683 "which sent interrupt, reason=%d\n", nasid
, ret
);
685 XPC_DEACTIVATE_PARTITION(part
, ret
);
690 part
->act_IRQ_rcvd
++;
692 dev_dbg(xpc_part
, "partid for nasid %d is %d; IRQs = %d; HB = "
693 "%ld:0x%lx\n", (int) nasid
, (int) partid
, part
->act_IRQ_rcvd
,
694 remote_vars
->heartbeat
, remote_vars
->heartbeating_to_mask
);
696 if (xpc_partition_disengaged(part
) &&
697 part
->act_state
== XPC_P_INACTIVE
) {
699 xpc_update_partition_info(part
, remote_rp_version
,
700 &remote_rp_stamp
, remote_rp_pa
,
701 remote_vars_pa
, remote_vars
);
703 if (XPC_SUPPORTS_DISENGAGE_REQUEST(part
->remote_vars_version
)) {
704 if (xpc_partition_disengage_requested(1UL << partid
)) {
706 * Other side is waiting on us to disengage,
707 * even though we already have.
712 /* other side doesn't support disengage requests */
713 xpc_clear_partition_disengage_request(1UL << partid
);
716 xpc_activate_partition(part
);
720 DBUG_ON(part
->remote_rp_version
== 0);
721 DBUG_ON(part
->remote_vars_version
== 0);
723 if (!XPC_SUPPORTS_RP_STAMP(part
->remote_rp_version
)) {
724 DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(part
->
725 remote_vars_version
));
727 if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version
)) {
728 DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars
->
730 /* see if the other side rebooted */
731 if (part
->remote_amos_page_pa
==
732 remote_vars
->amos_page_pa
&&
733 xpc_hb_allowed(sn_partition_id
,
735 /* doesn't look that way, so ignore the IPI */
741 * Other side rebooted and previous XPC didn't support the
742 * disengage request, so we don't need to do anything special.
745 xpc_update_partition_info(part
, remote_rp_version
,
746 &remote_rp_stamp
, remote_rp_pa
,
747 remote_vars_pa
, remote_vars
);
748 part
->reactivate_nasid
= nasid
;
749 XPC_DEACTIVATE_PARTITION(part
, xpcReactivating
);
753 DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(part
->remote_vars_version
));
755 if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version
)) {
756 DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars
->version
));
759 * Other side rebooted and previous XPC did support the
760 * disengage request, but the new one doesn't.
763 xpc_clear_partition_engaged(1UL << partid
);
764 xpc_clear_partition_disengage_request(1UL << partid
);
766 xpc_update_partition_info(part
, remote_rp_version
,
767 &remote_rp_stamp
, remote_rp_pa
,
768 remote_vars_pa
, remote_vars
);
772 DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars
->version
));
774 stamp_diff
= xpc_compare_stamps(&part
->remote_rp_stamp
,
776 if (stamp_diff
!= 0) {
777 DBUG_ON(stamp_diff
>= 0);
780 * Other side rebooted and the previous XPC did support
781 * the disengage request, as does the new one.
784 DBUG_ON(xpc_partition_engaged(1UL << partid
));
785 DBUG_ON(xpc_partition_disengage_requested(1UL <<
788 xpc_update_partition_info(part
, remote_rp_version
,
789 &remote_rp_stamp
, remote_rp_pa
,
790 remote_vars_pa
, remote_vars
);
795 if (part
->disengage_request_timeout
> 0 &&
796 !xpc_partition_disengaged(part
)) {
797 /* still waiting on other side to disengage from us */
802 part
->reactivate_nasid
= nasid
;
803 XPC_DEACTIVATE_PARTITION(part
, xpcReactivating
);
805 } else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part
->remote_vars_version
) &&
806 xpc_partition_disengage_requested(1UL << partid
)) {
807 XPC_DEACTIVATE_PARTITION(part
, xpcOtherGoingDown
);
813 * Loop through the activation AMO variables and process any bits
814 * which are set. Each bit indicates a nasid sending a partition
815 * activation or deactivation request.
817 * Return #of IRQs detected.
820 xpc_identify_act_IRQ_sender(void)
824 u64 nasid
; /* remote nasid */
825 int n_IRQs_detected
= 0;
829 act_amos
= xpc_vars
->amos_page
+ XPC_ACTIVATE_IRQ_AMOS
;
832 /* scan through act AMO variable looking for non-zero entries */
833 for (word
= 0; word
< xp_nasid_mask_words
; word
++) {
839 nasid_mask
= xpc_IPI_receive(&act_amos
[word
]);
840 if (nasid_mask
== 0) {
841 /* no IRQs from nasids in this variable */
845 dev_dbg(xpc_part
, "AMO[%d] gave back 0x%lx\n", word
,
850 * If this nasid has been added to the machine since
851 * our partition was reset, this will retain the
852 * remote nasid in our reserved pages machine mask.
853 * This is used in the event of module reload.
855 xpc_mach_nasids
[word
] |= nasid_mask
;
858 /* locate the nasid(s) which sent interrupts */
860 for (bit
= 0; bit
< (8 * sizeof(u64
)); bit
++) {
861 if (nasid_mask
& (1UL << bit
)) {
863 nasid
= XPC_NASID_FROM_W_B(word
, bit
);
864 dev_dbg(xpc_part
, "interrupt from nasid %ld\n",
866 xpc_identify_act_IRQ_req(nasid
);
870 return n_IRQs_detected
;
875 * See if the other side has responded to a partition disengage request
879 xpc_partition_disengaged(struct xpc_partition
*part
)
881 partid_t partid
= XPC_PARTID(part
);
885 disengaged
= (xpc_partition_engaged(1UL << partid
) == 0);
886 if (part
->disengage_request_timeout
) {
888 if (jiffies
< part
->disengage_request_timeout
) {
889 /* timelimit hasn't been reached yet */
894 * Other side hasn't responded to our disengage
895 * request in a timely fashion, so assume it's dead.
898 dev_info(xpc_part
, "disengage from remote partition %d "
899 "timed out\n", partid
);
900 xpc_disengage_request_timedout
= 1;
901 xpc_clear_partition_engaged(1UL << partid
);
904 part
->disengage_request_timeout
= 0;
906 /* cancel the timer function, provided it's not us */
907 if (!in_interrupt()) {
908 del_singleshot_timer_sync(&part
->
909 disengage_request_timer
);
912 DBUG_ON(part
->act_state
!= XPC_P_DEACTIVATING
&&
913 part
->act_state
!= XPC_P_INACTIVE
);
914 if (part
->act_state
!= XPC_P_INACTIVE
) {
915 xpc_wakeup_channel_mgr(part
);
918 if (XPC_SUPPORTS_DISENGAGE_REQUEST(part
->remote_vars_version
)) {
919 xpc_cancel_partition_disengage_request(part
);
927 * Mark specified partition as active.
930 xpc_mark_partition_active(struct xpc_partition
*part
)
932 unsigned long irq_flags
;
936 dev_dbg(xpc_part
, "setting partition %d to ACTIVE\n", XPC_PARTID(part
));
938 spin_lock_irqsave(&part
->act_lock
, irq_flags
);
939 if (part
->act_state
== XPC_P_ACTIVATING
) {
940 part
->act_state
= XPC_P_ACTIVE
;
943 DBUG_ON(part
->reason
== xpcSuccess
);
946 spin_unlock_irqrestore(&part
->act_lock
, irq_flags
);
953 * Notify XPC that the partition is down.
956 xpc_deactivate_partition(const int line
, struct xpc_partition
*part
,
957 enum xpc_retval reason
)
959 unsigned long irq_flags
;
962 spin_lock_irqsave(&part
->act_lock
, irq_flags
);
964 if (part
->act_state
== XPC_P_INACTIVE
) {
965 XPC_SET_REASON(part
, reason
, line
);
966 spin_unlock_irqrestore(&part
->act_lock
, irq_flags
);
967 if (reason
== xpcReactivating
) {
968 /* we interrupt ourselves to reactivate partition */
969 xpc_IPI_send_reactivate(part
);
973 if (part
->act_state
== XPC_P_DEACTIVATING
) {
974 if ((part
->reason
== xpcUnloading
&& reason
!= xpcUnloading
) ||
975 reason
== xpcReactivating
) {
976 XPC_SET_REASON(part
, reason
, line
);
978 spin_unlock_irqrestore(&part
->act_lock
, irq_flags
);
982 part
->act_state
= XPC_P_DEACTIVATING
;
983 XPC_SET_REASON(part
, reason
, line
);
985 spin_unlock_irqrestore(&part
->act_lock
, irq_flags
);
987 if (XPC_SUPPORTS_DISENGAGE_REQUEST(part
->remote_vars_version
)) {
988 xpc_request_partition_disengage(part
);
989 xpc_IPI_send_disengage(part
);
991 /* set a timelimit on the disengage request */
992 part
->disengage_request_timeout
= jiffies
+
993 (xpc_disengage_request_timelimit
* HZ
);
994 part
->disengage_request_timer
.expires
=
995 part
->disengage_request_timeout
;
996 add_timer(&part
->disengage_request_timer
);
999 dev_dbg(xpc_part
, "bringing partition %d down, reason = %d\n",
1000 XPC_PARTID(part
), reason
);
1002 xpc_partition_going_down(part
, reason
);
1007 * Mark specified partition as inactive.
1010 xpc_mark_partition_inactive(struct xpc_partition
*part
)
1012 unsigned long irq_flags
;
1015 dev_dbg(xpc_part
, "setting partition %d to INACTIVE\n",
1018 spin_lock_irqsave(&part
->act_lock
, irq_flags
);
1019 part
->act_state
= XPC_P_INACTIVE
;
1020 spin_unlock_irqrestore(&part
->act_lock
, irq_flags
);
1021 part
->remote_rp_pa
= 0;
1026 * SAL has provided a partition and machine mask. The partition mask
1027 * contains a bit for each even nasid in our partition. The machine
1028 * mask contains a bit for each even nasid in the entire machine.
1030 * Using those two bit arrays, we can determine which nasids are
1031 * known in the machine. Each should also have a reserved page
1032 * initialized if they are available for partitioning.
1037 void *remote_rp_base
;
1038 struct xpc_rsvd_page
*remote_rp
;
1039 struct xpc_vars
*remote_vars
;
1046 struct xpc_rsvd_page
*rp
;
1048 struct xpc_partition
*part
;
1049 u64
*discovered_nasids
;
1050 enum xpc_retval ret
;
1053 remote_rp
= xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE
+
1054 xp_nasid_mask_bytes
,
1055 GFP_KERNEL
, &remote_rp_base
);
1056 if (remote_rp
== NULL
) {
1059 remote_vars
= (struct xpc_vars
*) remote_rp
;
1062 discovered_nasids
= kzalloc(sizeof(u64
) * xp_nasid_mask_words
,
1064 if (discovered_nasids
== NULL
) {
1065 kfree(remote_rp_base
);
1069 rp
= (struct xpc_rsvd_page
*) xpc_rsvd_page
;
1072 * The term 'region' in this context refers to the minimum number of
1073 * nodes that can comprise an access protection grouping. The access
1074 * protection is in regards to memory, IOI and IPI.
1077 region_size
= sn_region_size
;
1079 switch (region_size
) {
1087 DBUG_ON(!is_shub2());
1090 for (region
= 0; region
< max_regions
; region
++) {
1092 if ((volatile int) xpc_exiting
) {
1096 dev_dbg(xpc_part
, "searching region %d\n", region
);
1098 for (nasid
= (region
* region_size
* 2);
1099 nasid
< ((region
+ 1) * region_size
* 2);
1102 if ((volatile int) xpc_exiting
) {
1106 dev_dbg(xpc_part
, "checking nasid %d\n", nasid
);
1109 if (XPC_NASID_IN_ARRAY(nasid
, xpc_part_nasids
)) {
1110 dev_dbg(xpc_part
, "PROM indicates Nasid %d is "
1111 "part of the local partition; skipping "
1116 if (!(XPC_NASID_IN_ARRAY(nasid
, xpc_mach_nasids
))) {
1117 dev_dbg(xpc_part
, "PROM indicates Nasid %d was "
1118 "not on Numa-Link network at reset\n",
1123 if (XPC_NASID_IN_ARRAY(nasid
, discovered_nasids
)) {
1124 dev_dbg(xpc_part
, "Nasid %d is part of a "
1125 "partition which was previously "
1126 "discovered\n", nasid
);
1131 /* pull over the reserved page structure */
1133 ret
= xpc_get_remote_rp(nasid
, discovered_nasids
,
1134 remote_rp
, &remote_rp_pa
);
1135 if (ret
!= xpcSuccess
) {
1136 dev_dbg(xpc_part
, "unable to get reserved page "
1137 "from nasid %d, reason=%d\n", nasid
,
1140 if (ret
== xpcLocalPartid
) {
1146 remote_vars_pa
= remote_rp
->vars_pa
;
1148 partid
= remote_rp
->partid
;
1149 part
= &xpc_partitions
[partid
];
1152 /* pull over the cross partition variables */
1154 ret
= xpc_get_remote_vars(remote_vars_pa
, remote_vars
);
1155 if (ret
!= xpcSuccess
) {
1156 dev_dbg(xpc_part
, "unable to get XPC variables "
1157 "from nasid %d, reason=%d\n", nasid
,
1160 XPC_DEACTIVATE_PARTITION(part
, ret
);
1164 if (part
->act_state
!= XPC_P_INACTIVE
) {
1165 dev_dbg(xpc_part
, "partition %d on nasid %d is "
1166 "already activating\n", partid
, nasid
);
1171 * Register the remote partition's AMOs with SAL so it
1172 * can handle and cleanup errors within that address
1173 * range should the remote partition go down. We don't
1174 * unregister this range because it is difficult to
1175 * tell when outstanding writes to the remote partition
1176 * are finished and thus when it is thus safe to
1177 * unregister. This should not result in wasted space
1178 * in the SAL xp_addr_region table because we should
1179 * get the same page for remote_act_amos_pa after
1180 * module reloads and system reboots.
1182 if (sn_register_xp_addr_region(
1183 remote_vars
->amos_page_pa
,
1184 PAGE_SIZE
, 1) < 0) {
1185 dev_dbg(xpc_part
, "partition %d failed to "
1186 "register xp_addr region 0x%016lx\n",
1187 partid
, remote_vars
->amos_page_pa
);
1189 XPC_SET_REASON(part
, xpcPhysAddrRegFailed
,
1195 * The remote nasid is valid and available.
1196 * Send an interrupt to that nasid to notify
1197 * it that we are ready to begin activation.
1199 dev_dbg(xpc_part
, "sending an interrupt to AMO 0x%lx, "
1200 "nasid %d, phys_cpuid 0x%x\n",
1201 remote_vars
->amos_page_pa
,
1202 remote_vars
->act_nasid
,
1203 remote_vars
->act_phys_cpuid
);
1205 if (XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars
->
1207 part
->remote_amos_page_pa
=
1208 remote_vars
->amos_page_pa
;
1209 xpc_mark_partition_disengaged(part
);
1210 xpc_cancel_partition_disengage_request(part
);
1212 xpc_IPI_send_activate(remote_vars
);
1216 kfree(discovered_nasids
);
1217 kfree(remote_rp_base
);
1222 * Given a partid, get the nasids owned by that partition from the
1223 * remote partition's reserved page.
1226 xpc_initiate_partid_to_nasids(partid_t partid
, void *nasid_mask
)
1228 struct xpc_partition
*part
;
1233 part
= &xpc_partitions
[partid
];
1234 if (part
->remote_rp_pa
== 0) {
1235 return xpcPartitionDown
;
1238 memset(nasid_mask
, 0, XP_NASID_MASK_BYTES
);
1240 part_nasid_pa
= (u64
) XPC_RP_PART_NASIDS(part
->remote_rp_pa
);
1242 bte_res
= xp_bte_copy(part_nasid_pa
, ia64_tpa((u64
) nasid_mask
),
1243 xp_nasid_mask_bytes
, (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
1245 return xpc_map_bte_errors(bte_res
);