Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1 | /* |
| 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 |
| 4 | * for more details. |
| 5 | * |
Dean Nelson | 45d9ca4 | 2008-04-22 14:46:56 -0500 | [diff] [blame] | 6 | * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 9 | /* |
| 10 | * Cross Partition Communication (XPC) partition support. |
| 11 | * |
| 12 | * This is the part of XPC that detects the presence/absence of |
| 13 | * other partitions. It provides a heartbeat and monitors the |
| 14 | * heartbeats of other partitions. |
| 15 | * |
| 16 | */ |
| 17 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 18 | #include <linux/kernel.h> |
| 19 | #include <linux/sysctl.h> |
| 20 | #include <linux/cache.h> |
| 21 | #include <linux/mmzone.h> |
| 22 | #include <linux/nodemask.h> |
Jes Sorensen | 65ed0b3 | 2005-06-21 17:15:03 -0700 | [diff] [blame] | 23 | #include <asm/uncached.h> |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 24 | #include <asm/sn/bte.h> |
| 25 | #include <asm/sn/intr.h> |
| 26 | #include <asm/sn/sn_sal.h> |
| 27 | #include <asm/sn/nodepda.h> |
| 28 | #include <asm/sn/addrs.h> |
Dean Nelson | 45d9ca4 | 2008-04-22 14:46:56 -0500 | [diff] [blame] | 29 | #include "xpc.h" |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 30 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 31 | /* XPC is exiting flag */ |
| 32 | int xpc_exiting; |
| 33 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 34 | /* SH_IPI_ACCESS shub register value on startup */ |
| 35 | static u64 xpc_sh1_IPI_access; |
| 36 | static u64 xpc_sh2_IPI_access0; |
| 37 | static u64 xpc_sh2_IPI_access1; |
| 38 | static u64 xpc_sh2_IPI_access2; |
| 39 | static u64 xpc_sh2_IPI_access3; |
| 40 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 41 | /* original protection values for each node */ |
Jack Steiner | 24ee0a6 | 2005-09-12 12:15:43 -0500 | [diff] [blame] | 42 | u64 xpc_prot_vec[MAX_NUMNODES]; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 43 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 44 | /* this partition's reserved page pointers */ |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 45 | struct xpc_rsvd_page *xpc_rsvd_page; |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 46 | static u64 *xpc_part_nasids; |
| 47 | static u64 *xpc_mach_nasids; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 48 | struct xpc_vars *xpc_vars; |
| 49 | struct xpc_vars_part *xpc_vars_part; |
| 50 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 51 | static int xp_nasid_mask_bytes; /* actual size in bytes of nasid mask */ |
| 52 | static int xp_nasid_mask_words; /* actual size in words of nasid mask */ |
| 53 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 54 | /* |
| 55 | * For performance reasons, each entry of xpc_partitions[] is cacheline |
| 56 | * aligned. And xpc_partitions[] is padded with an additional entry at the |
| 57 | * end so that the last legitimate entry doesn't share its cacheline with |
| 58 | * another variable. |
| 59 | */ |
| 60 | struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1]; |
| 61 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 62 | /* |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 63 | * Generic buffer used to store a local copy of portions of a remote |
| 64 | * partition's reserved page (either its header and part_nasids mask, |
| 65 | * or its vars). |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 66 | */ |
Dean Nelson | 7682a4c | 2006-08-08 15:03:29 -0500 | [diff] [blame] | 67 | char *xpc_remote_copy_buffer; |
| 68 | void *xpc_remote_copy_buffer_base; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 69 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 70 | /* |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 71 | * Guarantee that the kmalloc'd memory is cacheline aligned. |
| 72 | */ |
Dean Nelson | 7682a4c | 2006-08-08 15:03:29 -0500 | [diff] [blame] | 73 | void * |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 74 | xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base) |
| 75 | { |
| 76 | /* see if kmalloc will give us cachline aligned memory by default */ |
| 77 | *base = kmalloc(size, flags); |
| 78 | if (*base == NULL) { |
| 79 | return NULL; |
| 80 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 81 | if ((u64)*base == L1_CACHE_ALIGN((u64)*base)) { |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 82 | return *base; |
| 83 | } |
| 84 | kfree(*base); |
| 85 | |
| 86 | /* nope, we'll have to do it ourselves */ |
| 87 | *base = kmalloc(size + L1_CACHE_BYTES, flags); |
| 88 | if (*base == NULL) { |
| 89 | return NULL; |
| 90 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 91 | return (void *)L1_CACHE_ALIGN((u64)*base); |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 92 | } |
| 93 | |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 94 | /* |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 95 | * Given a nasid, get the physical address of the partition's reserved page |
| 96 | * for that nasid. This function returns 0 on any error. |
| 97 | */ |
| 98 | static u64 |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 99 | xpc_get_rsvd_page_pa(int nasid) |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 100 | { |
| 101 | bte_result_t bte_res; |
| 102 | s64 status; |
| 103 | u64 cookie = 0; |
| 104 | u64 rp_pa = nasid; /* seed with nasid */ |
| 105 | u64 len = 0; |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 106 | u64 buf = buf; |
| 107 | u64 buf_len = 0; |
| 108 | void *buf_base = NULL; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 109 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 110 | while (1) { |
| 111 | |
| 112 | status = sn_partition_reserved_page_pa(buf, &cookie, &rp_pa, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 113 | &len); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 114 | |
| 115 | dev_dbg(xpc_part, "SAL returned with status=%li, cookie=" |
| 116 | "0x%016lx, address=0x%016lx, len=0x%016lx\n", |
| 117 | status, cookie, rp_pa, len); |
| 118 | |
| 119 | if (status != SALRET_MORE_PASSES) { |
| 120 | break; |
| 121 | } |
| 122 | |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 123 | if (L1_CACHE_ALIGN(len) > buf_len) { |
Jesper Juhl | cbf283c | 2006-04-20 10:11:09 -0700 | [diff] [blame] | 124 | kfree(buf_base); |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 125 | buf_len = L1_CACHE_ALIGN(len); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 126 | buf = (u64)xpc_kmalloc_cacheline_aligned(buf_len, |
| 127 | GFP_KERNEL, |
| 128 | &buf_base); |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 129 | if (buf_base == NULL) { |
| 130 | dev_err(xpc_part, "unable to kmalloc " |
| 131 | "len=0x%016lx\n", buf_len); |
| 132 | status = SALRET_ERROR; |
| 133 | break; |
| 134 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 135 | } |
| 136 | |
Dean Nelson | 7682a4c | 2006-08-08 15:03:29 -0500 | [diff] [blame] | 137 | bte_res = xp_bte_copy(rp_pa, buf, buf_len, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 138 | (BTE_NOTIFY | BTE_WACQUIRE), NULL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 139 | if (bte_res != BTE_SUCCESS) { |
| 140 | dev_dbg(xpc_part, "xp_bte_copy failed %i\n", bte_res); |
| 141 | status = SALRET_ERROR; |
| 142 | break; |
| 143 | } |
| 144 | } |
| 145 | |
Jesper Juhl | cbf283c | 2006-04-20 10:11:09 -0700 | [diff] [blame] | 146 | kfree(buf_base); |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 147 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 148 | if (status != SALRET_OK) { |
| 149 | rp_pa = 0; |
| 150 | } |
| 151 | dev_dbg(xpc_part, "reserved page at phys address 0x%016lx\n", rp_pa); |
| 152 | return rp_pa; |
| 153 | } |
| 154 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 155 | /* |
| 156 | * Fill the partition reserved page with the information needed by |
| 157 | * other partitions to discover we are alive and establish initial |
| 158 | * communications. |
| 159 | */ |
| 160 | struct xpc_rsvd_page * |
| 161 | xpc_rsvd_page_init(void) |
| 162 | { |
| 163 | struct xpc_rsvd_page *rp; |
| 164 | AMO_t *amos_page; |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 165 | u64 rp_pa, nasid_array = 0; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 166 | int i, ret; |
| 167 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 168 | /* get the local reserved page's address */ |
| 169 | |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 170 | preempt_disable(); |
| 171 | rp_pa = xpc_get_rsvd_page_pa(cpuid_to_nasid(smp_processor_id())); |
| 172 | preempt_enable(); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 173 | if (rp_pa == 0) { |
| 174 | dev_err(xpc_part, "SAL failed to locate the reserved page\n"); |
| 175 | return NULL; |
| 176 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 177 | rp = (struct xpc_rsvd_page *)__va(rp_pa); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 178 | |
| 179 | if (rp->partid != sn_partition_id) { |
| 180 | dev_err(xpc_part, "the reserved page's partid of %d should be " |
| 181 | "%d\n", rp->partid, sn_partition_id); |
| 182 | return NULL; |
| 183 | } |
| 184 | |
| 185 | rp->version = XPC_RP_VERSION; |
| 186 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 187 | /* establish the actual sizes of the nasid masks */ |
| 188 | if (rp->SAL_version == 1) { |
| 189 | /* SAL_version 1 didn't set the nasids_size field */ |
| 190 | rp->nasids_size = 128; |
| 191 | } |
| 192 | xp_nasid_mask_bytes = rp->nasids_size; |
| 193 | xp_nasid_mask_words = xp_nasid_mask_bytes / 8; |
| 194 | |
| 195 | /* setup the pointers to the various items in the reserved page */ |
| 196 | xpc_part_nasids = XPC_RP_PART_NASIDS(rp); |
| 197 | xpc_mach_nasids = XPC_RP_MACH_NASIDS(rp); |
| 198 | xpc_vars = XPC_RP_VARS(rp); |
| 199 | xpc_vars_part = XPC_RP_VARS_PART(rp); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 200 | |
| 201 | /* |
| 202 | * Before clearing xpc_vars, see if a page of AMOs had been previously |
| 203 | * allocated. If not we'll need to allocate one and set permissions |
| 204 | * so that cross-partition AMOs are allowed. |
| 205 | * |
| 206 | * The allocated AMO page needs MCA reporting to remain disabled after |
| 207 | * XPC has unloaded. To make this work, we keep a copy of the pointer |
| 208 | * to this page (i.e., amos_page) in the struct xpc_vars structure, |
| 209 | * which is pointed to by the reserved page, and re-use that saved copy |
| 210 | * on subsequent loads of XPC. This AMO page is never freed, and its |
| 211 | * memory protections are never restricted. |
| 212 | */ |
| 213 | if ((amos_page = xpc_vars->amos_page) == NULL) { |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 214 | amos_page = (AMO_t *)TO_AMO(uncached_alloc_page(0)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 215 | if (amos_page == NULL) { |
| 216 | dev_err(xpc_part, "can't allocate page of AMOs\n"); |
| 217 | return NULL; |
| 218 | } |
| 219 | |
| 220 | /* |
| 221 | * Open up AMO-R/W to cpu. This is done for Shub 1.1 systems |
| 222 | * when xpc_allow_IPI_ops() is called via xpc_hb_init(). |
| 223 | */ |
| 224 | if (!enable_shub_wars_1_1()) { |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 225 | ret = sn_change_memprotect(ia64_tpa((u64)amos_page), |
| 226 | PAGE_SIZE, |
| 227 | SN_MEMPROT_ACCESS_CLASS_1, |
| 228 | &nasid_array); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 229 | if (ret != 0) { |
| 230 | dev_err(xpc_part, "can't change memory " |
| 231 | "protections\n"); |
Jes Sorensen | 65ed0b3 | 2005-06-21 17:15:03 -0700 | [diff] [blame] | 232 | uncached_free_page(__IA64_UNCACHED_OFFSET | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 233 | TO_PHYS((u64)amos_page)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 234 | return NULL; |
| 235 | } |
| 236 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 237 | } else if (!IS_AMO_ADDRESS((u64)amos_page)) { |
Dean Nelson | 3a7d555 | 2005-04-04 13:14:00 -0700 | [diff] [blame] | 238 | /* |
| 239 | * EFI's XPBOOT can also set amos_page in the reserved page, |
| 240 | * but it happens to leave it as an uncached physical address |
| 241 | * and we need it to be an uncached virtual, so we'll have to |
| 242 | * convert it. |
| 243 | */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 244 | if (!IS_AMO_PHYS_ADDRESS((u64)amos_page)) { |
Dean Nelson | 3a7d555 | 2005-04-04 13:14:00 -0700 | [diff] [blame] | 245 | dev_err(xpc_part, "previously used amos_page address " |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 246 | "is bad = 0x%p\n", (void *)amos_page); |
Dean Nelson | 3a7d555 | 2005-04-04 13:14:00 -0700 | [diff] [blame] | 247 | return NULL; |
| 248 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 249 | amos_page = (AMO_t *)TO_AMO((u64)amos_page); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 252 | /* clear xpc_vars */ |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 253 | memset(xpc_vars, 0, sizeof(struct xpc_vars)); |
| 254 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 255 | xpc_vars->version = XPC_V_VERSION; |
| 256 | xpc_vars->act_nasid = cpuid_to_nasid(0); |
| 257 | xpc_vars->act_phys_cpuid = cpu_physical_id(0); |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 258 | xpc_vars->vars_part_pa = __pa(xpc_vars_part); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 259 | xpc_vars->amos_page_pa = ia64_tpa((u64)amos_page); |
| 260 | xpc_vars->amos_page = amos_page; /* save for next load of XPC */ |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 261 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 262 | /* clear xpc_vars_part */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 263 | memset((u64 *)xpc_vars_part, 0, sizeof(struct xpc_vars_part) * |
| 264 | XP_MAX_PARTITIONS); |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 265 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 266 | /* initialize the activate IRQ related AMO variables */ |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 267 | for (i = 0; i < xp_nasid_mask_words; i++) { |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 268 | (void)xpc_IPI_init(XPC_ACTIVATE_IRQ_AMOS + i); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 269 | } |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 270 | |
| 271 | /* initialize the engaged remote partitions related AMO variables */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 272 | (void)xpc_IPI_init(XPC_ENGAGED_PARTITIONS_AMO); |
| 273 | (void)xpc_IPI_init(XPC_DISENGAGE_REQUEST_AMO); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 274 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 275 | /* timestamp of when reserved page was setup by XPC */ |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 276 | rp->stamp = CURRENT_TIME; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 277 | |
| 278 | /* |
| 279 | * This signifies to the remote partition that our reserved |
| 280 | * page is initialized. |
| 281 | */ |
Dave Jones | 821fe94 | 2005-06-25 14:54:29 -0700 | [diff] [blame] | 282 | rp->vars_pa = __pa(xpc_vars); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 283 | |
| 284 | return rp; |
| 285 | } |
| 286 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 287 | /* |
| 288 | * Change protections to allow IPI operations (and AMO operations on |
| 289 | * Shub 1.1 systems). |
| 290 | */ |
| 291 | void |
| 292 | xpc_allow_IPI_ops(void) |
| 293 | { |
| 294 | int node; |
| 295 | int nasid; |
| 296 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 297 | // >>> Change SH_IPI_ACCESS code to use SAL call once it is available. |
| 298 | |
| 299 | if (is_shub2()) { |
| 300 | xpc_sh2_IPI_access0 = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 301 | (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS0)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 302 | xpc_sh2_IPI_access1 = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 303 | (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS1)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 304 | xpc_sh2_IPI_access2 = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 305 | (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS2)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 306 | xpc_sh2_IPI_access3 = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 307 | (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS3)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 308 | |
| 309 | for_each_online_node(node) { |
| 310 | nasid = cnodeid_to_nasid(node); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 311 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), |
| 312 | -1UL); |
| 313 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), |
| 314 | -1UL); |
| 315 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), |
| 316 | -1UL); |
| 317 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), |
| 318 | -1UL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | } else { |
| 322 | xpc_sh1_IPI_access = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 323 | (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH1_IPI_ACCESS)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 324 | |
| 325 | for_each_online_node(node) { |
| 326 | nasid = cnodeid_to_nasid(node); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 327 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), |
| 328 | -1UL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 329 | |
| 330 | /* |
| 331 | * Since the BIST collides with memory operations on |
| 332 | * SHUB 1.1 sn_change_memprotect() cannot be used. |
| 333 | */ |
| 334 | if (enable_shub_wars_1_1()) { |
| 335 | /* open up everything */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 336 | xpc_prot_vec[node] = (u64)HUB_L((u64 *) |
| 337 | GLOBAL_MMR_ADDR |
| 338 | (nasid, |
| 339 | SH1_MD_DQLP_MMR_DIR_PRIVEC0)); |
| 340 | HUB_S((u64 *) |
| 341 | GLOBAL_MMR_ADDR(nasid, |
| 342 | SH1_MD_DQLP_MMR_DIR_PRIVEC0), |
| 343 | -1UL); |
| 344 | HUB_S((u64 *) |
| 345 | GLOBAL_MMR_ADDR(nasid, |
| 346 | SH1_MD_DQRP_MMR_DIR_PRIVEC0), |
| 347 | -1UL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 348 | } |
| 349 | } |
| 350 | } |
| 351 | } |
| 352 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 353 | /* |
| 354 | * Restrict protections to disallow IPI operations (and AMO operations on |
| 355 | * Shub 1.1 systems). |
| 356 | */ |
| 357 | void |
| 358 | xpc_restrict_IPI_ops(void) |
| 359 | { |
| 360 | int node; |
| 361 | int nasid; |
| 362 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 363 | // >>> Change SH_IPI_ACCESS code to use SAL call once it is available. |
| 364 | |
| 365 | if (is_shub2()) { |
| 366 | |
| 367 | for_each_online_node(node) { |
| 368 | nasid = cnodeid_to_nasid(node); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 369 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), |
| 370 | xpc_sh2_IPI_access0); |
| 371 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), |
| 372 | xpc_sh2_IPI_access1); |
| 373 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), |
| 374 | xpc_sh2_IPI_access2); |
| 375 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), |
| 376 | xpc_sh2_IPI_access3); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | } else { |
| 380 | |
| 381 | for_each_online_node(node) { |
| 382 | nasid = cnodeid_to_nasid(node); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 383 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), |
| 384 | xpc_sh1_IPI_access); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 385 | |
| 386 | if (enable_shub_wars_1_1()) { |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 387 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, |
| 388 | SH1_MD_DQLP_MMR_DIR_PRIVEC0), |
| 389 | xpc_prot_vec[node]); |
| 390 | HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, |
| 391 | SH1_MD_DQRP_MMR_DIR_PRIVEC0), |
| 392 | xpc_prot_vec[node]); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 393 | } |
| 394 | } |
| 395 | } |
| 396 | } |
| 397 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 398 | /* |
| 399 | * At periodic intervals, scan through all active partitions and ensure |
| 400 | * their heartbeat is still active. If not, the partition is deactivated. |
| 401 | */ |
| 402 | void |
| 403 | xpc_check_remote_hb(void) |
| 404 | { |
| 405 | struct xpc_vars *remote_vars; |
| 406 | struct xpc_partition *part; |
| 407 | partid_t partid; |
| 408 | bte_result_t bres; |
| 409 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 410 | remote_vars = (struct xpc_vars *)xpc_remote_copy_buffer; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 411 | |
| 412 | for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 413 | |
| 414 | if (xpc_exiting) { |
| 415 | break; |
| 416 | } |
| 417 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 418 | if (partid == sn_partition_id) { |
| 419 | continue; |
| 420 | } |
| 421 | |
| 422 | part = &xpc_partitions[partid]; |
| 423 | |
| 424 | if (part->act_state == XPC_P_INACTIVE || |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 425 | part->act_state == XPC_P_DEACTIVATING) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 426 | continue; |
| 427 | } |
| 428 | |
| 429 | /* pull the remote_hb cache line */ |
| 430 | bres = xp_bte_copy(part->remote_vars_pa, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 431 | (u64)remote_vars, |
| 432 | XPC_RP_VARS_SIZE, |
| 433 | (BTE_NOTIFY | BTE_WACQUIRE), NULL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 434 | if (bres != BTE_SUCCESS) { |
| 435 | XPC_DEACTIVATE_PARTITION(part, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 436 | xpc_map_bte_errors(bres)); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 437 | continue; |
| 438 | } |
| 439 | |
| 440 | dev_dbg(xpc_part, "partid = %d, heartbeat = %ld, last_heartbeat" |
Dean Nelson | 780d09e | 2005-11-09 14:41:57 -0600 | [diff] [blame] | 441 | " = %ld, heartbeat_offline = %ld, HB_mask = 0x%lx\n", |
| 442 | partid, remote_vars->heartbeat, part->last_heartbeat, |
| 443 | remote_vars->heartbeat_offline, |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 444 | remote_vars->heartbeating_to_mask); |
| 445 | |
| 446 | if (((remote_vars->heartbeat == part->last_heartbeat) && |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 447 | (remote_vars->heartbeat_offline == 0)) || |
| 448 | !xpc_hb_allowed(sn_partition_id, remote_vars)) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 449 | |
| 450 | XPC_DEACTIVATE_PARTITION(part, xpcNoHeartbeat); |
| 451 | continue; |
| 452 | } |
| 453 | |
| 454 | part->last_heartbeat = remote_vars->heartbeat; |
| 455 | } |
| 456 | } |
| 457 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 458 | /* |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 459 | * Get a copy of a portion of the remote partition's rsvd page. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 460 | * |
| 461 | * remote_rp points to a buffer that is cacheline aligned for BTE copies and |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 462 | * is large enough to contain a copy of their reserved page header and |
| 463 | * part_nasids mask. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 464 | */ |
| 465 | static enum xpc_retval |
| 466 | xpc_get_remote_rp(int nasid, u64 *discovered_nasids, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 467 | struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa) |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 468 | { |
| 469 | int bres, i; |
| 470 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 471 | /* get the reserved page's physical address */ |
| 472 | |
Dean Nelson | 2792902 | 2005-10-25 14:11:53 -0500 | [diff] [blame] | 473 | *remote_rp_pa = xpc_get_rsvd_page_pa(nasid); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 474 | if (*remote_rp_pa == 0) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 475 | return xpcNoRsvdPageAddr; |
| 476 | } |
| 477 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 478 | /* pull over the reserved page header and part_nasids mask */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 479 | bres = xp_bte_copy(*remote_rp_pa, (u64)remote_rp, |
| 480 | XPC_RP_HEADER_SIZE + xp_nasid_mask_bytes, |
| 481 | (BTE_NOTIFY | BTE_WACQUIRE), NULL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 482 | if (bres != BTE_SUCCESS) { |
| 483 | return xpc_map_bte_errors(bres); |
| 484 | } |
| 485 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 486 | if (discovered_nasids != NULL) { |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 487 | u64 *remote_part_nasids = XPC_RP_PART_NASIDS(remote_rp); |
| 488 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 489 | for (i = 0; i < xp_nasid_mask_words; i++) { |
| 490 | discovered_nasids[i] |= remote_part_nasids[i]; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 491 | } |
| 492 | } |
| 493 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 494 | /* check that the partid is for another partition */ |
| 495 | |
| 496 | if (remote_rp->partid < 1 || |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 497 | remote_rp->partid > (XP_MAX_PARTITIONS - 1)) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 498 | return xpcInvalidPartid; |
| 499 | } |
| 500 | |
| 501 | if (remote_rp->partid == sn_partition_id) { |
| 502 | return xpcLocalPartid; |
| 503 | } |
| 504 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 505 | if (XPC_VERSION_MAJOR(remote_rp->version) != |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 506 | XPC_VERSION_MAJOR(XPC_RP_VERSION)) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 507 | return xpcBadVersion; |
| 508 | } |
| 509 | |
| 510 | return xpcSuccess; |
| 511 | } |
| 512 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 513 | /* |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 514 | * Get a copy of the remote partition's XPC variables from the reserved page. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 515 | * |
| 516 | * remote_vars points to a buffer that is cacheline aligned for BTE copies and |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 517 | * assumed to be of size XPC_RP_VARS_SIZE. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 518 | */ |
| 519 | static enum xpc_retval |
| 520 | xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars) |
| 521 | { |
| 522 | int bres; |
| 523 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 524 | if (remote_vars_pa == 0) { |
| 525 | return xpcVarsNotSet; |
| 526 | } |
| 527 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 528 | /* pull over the cross partition variables */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 529 | bres = xp_bte_copy(remote_vars_pa, (u64)remote_vars, XPC_RP_VARS_SIZE, |
| 530 | (BTE_NOTIFY | BTE_WACQUIRE), NULL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 531 | if (bres != BTE_SUCCESS) { |
| 532 | return xpc_map_bte_errors(bres); |
| 533 | } |
| 534 | |
| 535 | if (XPC_VERSION_MAJOR(remote_vars->version) != |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 536 | XPC_VERSION_MAJOR(XPC_V_VERSION)) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 537 | return xpcBadVersion; |
| 538 | } |
| 539 | |
| 540 | return xpcSuccess; |
| 541 | } |
| 542 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 543 | /* |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 544 | * Update the remote partition's info. |
| 545 | */ |
| 546 | static void |
| 547 | xpc_update_partition_info(struct xpc_partition *part, u8 remote_rp_version, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 548 | struct timespec *remote_rp_stamp, u64 remote_rp_pa, |
| 549 | u64 remote_vars_pa, struct xpc_vars *remote_vars) |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 550 | { |
| 551 | part->remote_rp_version = remote_rp_version; |
Tony Luck | b9ae3bd | 2007-05-10 11:47:38 -0700 | [diff] [blame] | 552 | dev_dbg(xpc_part, " remote_rp_version = 0x%016x\n", |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 553 | part->remote_rp_version); |
| 554 | |
| 555 | part->remote_rp_stamp = *remote_rp_stamp; |
| 556 | dev_dbg(xpc_part, " remote_rp_stamp (tv_sec = 0x%lx tv_nsec = 0x%lx\n", |
| 557 | part->remote_rp_stamp.tv_sec, part->remote_rp_stamp.tv_nsec); |
| 558 | |
| 559 | part->remote_rp_pa = remote_rp_pa; |
| 560 | dev_dbg(xpc_part, " remote_rp_pa = 0x%016lx\n", part->remote_rp_pa); |
| 561 | |
| 562 | part->remote_vars_pa = remote_vars_pa; |
| 563 | dev_dbg(xpc_part, " remote_vars_pa = 0x%016lx\n", |
| 564 | part->remote_vars_pa); |
| 565 | |
| 566 | part->last_heartbeat = remote_vars->heartbeat; |
| 567 | dev_dbg(xpc_part, " last_heartbeat = 0x%016lx\n", |
| 568 | part->last_heartbeat); |
| 569 | |
| 570 | part->remote_vars_part_pa = remote_vars->vars_part_pa; |
| 571 | dev_dbg(xpc_part, " remote_vars_part_pa = 0x%016lx\n", |
| 572 | part->remote_vars_part_pa); |
| 573 | |
| 574 | part->remote_act_nasid = remote_vars->act_nasid; |
| 575 | dev_dbg(xpc_part, " remote_act_nasid = 0x%x\n", |
| 576 | part->remote_act_nasid); |
| 577 | |
| 578 | part->remote_act_phys_cpuid = remote_vars->act_phys_cpuid; |
| 579 | dev_dbg(xpc_part, " remote_act_phys_cpuid = 0x%x\n", |
| 580 | part->remote_act_phys_cpuid); |
| 581 | |
| 582 | part->remote_amos_page_pa = remote_vars->amos_page_pa; |
| 583 | dev_dbg(xpc_part, " remote_amos_page_pa = 0x%lx\n", |
| 584 | part->remote_amos_page_pa); |
| 585 | |
| 586 | part->remote_vars_version = remote_vars->version; |
| 587 | dev_dbg(xpc_part, " remote_vars_version = 0x%x\n", |
| 588 | part->remote_vars_version); |
| 589 | } |
| 590 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 591 | /* |
Dean Nelson | e54af72 | 2005-10-25 14:07:43 -0500 | [diff] [blame] | 592 | * Prior code has determined the nasid which generated an IPI. Inspect |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 593 | * that nasid to determine if its partition needs to be activated or |
| 594 | * deactivated. |
| 595 | * |
| 596 | * A partition is consider "awaiting activation" if our partition |
| 597 | * flags indicate it is not active and it has a heartbeat. A |
| 598 | * partition is considered "awaiting deactivation" if our partition |
| 599 | * flags indicate it is active but it has no heartbeat or it is not |
| 600 | * sending its heartbeat to us. |
| 601 | * |
| 602 | * To determine the heartbeat, the remote nasid must have a properly |
| 603 | * initialized reserved page. |
| 604 | */ |
| 605 | static void |
| 606 | xpc_identify_act_IRQ_req(int nasid) |
| 607 | { |
| 608 | struct xpc_rsvd_page *remote_rp; |
| 609 | struct xpc_vars *remote_vars; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 610 | u64 remote_rp_pa; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 611 | u64 remote_vars_pa; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 612 | int remote_rp_version; |
| 613 | int reactivate = 0; |
| 614 | int stamp_diff; |
| 615 | struct timespec remote_rp_stamp = { 0, 0 }; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 616 | partid_t partid; |
| 617 | struct xpc_partition *part; |
| 618 | enum xpc_retval ret; |
| 619 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 620 | /* pull over the reserved page structure */ |
| 621 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 622 | remote_rp = (struct xpc_rsvd_page *)xpc_remote_copy_buffer; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 623 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 624 | ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rp_pa); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 625 | if (ret != xpcSuccess) { |
| 626 | dev_warn(xpc_part, "unable to get reserved page from nasid %d, " |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 627 | "which sent interrupt, reason=%d\n", nasid, ret); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 628 | return; |
| 629 | } |
| 630 | |
| 631 | remote_vars_pa = remote_rp->vars_pa; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 632 | remote_rp_version = remote_rp->version; |
| 633 | if (XPC_SUPPORTS_RP_STAMP(remote_rp_version)) { |
| 634 | remote_rp_stamp = remote_rp->stamp; |
| 635 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 636 | partid = remote_rp->partid; |
| 637 | part = &xpc_partitions[partid]; |
| 638 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 639 | /* pull over the cross partition variables */ |
| 640 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 641 | remote_vars = (struct xpc_vars *)xpc_remote_copy_buffer; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 642 | |
| 643 | ret = xpc_get_remote_vars(remote_vars_pa, remote_vars); |
| 644 | if (ret != xpcSuccess) { |
| 645 | |
| 646 | dev_warn(xpc_part, "unable to get XPC variables from nasid %d, " |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 647 | "which sent interrupt, reason=%d\n", nasid, ret); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 648 | |
| 649 | XPC_DEACTIVATE_PARTITION(part, ret); |
| 650 | return; |
| 651 | } |
| 652 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 653 | part->act_IRQ_rcvd++; |
| 654 | |
| 655 | dev_dbg(xpc_part, "partid for nasid %d is %d; IRQs = %d; HB = " |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 656 | "%ld:0x%lx\n", (int)nasid, (int)partid, part->act_IRQ_rcvd, |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 657 | remote_vars->heartbeat, remote_vars->heartbeating_to_mask); |
| 658 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 659 | if (xpc_partition_disengaged(part) && part->act_state == XPC_P_INACTIVE) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 660 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 661 | xpc_update_partition_info(part, remote_rp_version, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 662 | &remote_rp_stamp, remote_rp_pa, |
| 663 | remote_vars_pa, remote_vars); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 664 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 665 | if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) { |
| 666 | if (xpc_partition_disengage_requested(1UL << partid)) { |
| 667 | /* |
| 668 | * Other side is waiting on us to disengage, |
| 669 | * even though we already have. |
| 670 | */ |
| 671 | return; |
| 672 | } |
| 673 | } else { |
| 674 | /* other side doesn't support disengage requests */ |
| 675 | xpc_clear_partition_disengage_request(1UL << partid); |
| 676 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 677 | |
| 678 | xpc_activate_partition(part); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 679 | return; |
| 680 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 681 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 682 | DBUG_ON(part->remote_rp_version == 0); |
| 683 | DBUG_ON(part->remote_vars_version == 0); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 684 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 685 | if (!XPC_SUPPORTS_RP_STAMP(part->remote_rp_version)) { |
| 686 | DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(part-> |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 687 | remote_vars_version)); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 688 | |
| 689 | if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) { |
| 690 | DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars-> |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 691 | version)); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 692 | /* see if the other side rebooted */ |
| 693 | if (part->remote_amos_page_pa == |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 694 | remote_vars->amos_page_pa && |
| 695 | xpc_hb_allowed(sn_partition_id, remote_vars)) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 696 | /* doesn't look that way, so ignore the IPI */ |
| 697 | return; |
| 698 | } |
| 699 | } |
| 700 | |
| 701 | /* |
| 702 | * Other side rebooted and previous XPC didn't support the |
| 703 | * disengage request, so we don't need to do anything special. |
| 704 | */ |
| 705 | |
| 706 | xpc_update_partition_info(part, remote_rp_version, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 707 | &remote_rp_stamp, remote_rp_pa, |
| 708 | remote_vars_pa, remote_vars); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 709 | part->reactivate_nasid = nasid; |
| 710 | XPC_DEACTIVATE_PARTITION(part, xpcReactivating); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 711 | return; |
| 712 | } |
| 713 | |
| 714 | DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)); |
| 715 | |
| 716 | if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) { |
| 717 | DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version)); |
| 718 | |
| 719 | /* |
| 720 | * Other side rebooted and previous XPC did support the |
| 721 | * disengage request, but the new one doesn't. |
| 722 | */ |
| 723 | |
| 724 | xpc_clear_partition_engaged(1UL << partid); |
| 725 | xpc_clear_partition_disengage_request(1UL << partid); |
| 726 | |
| 727 | xpc_update_partition_info(part, remote_rp_version, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 728 | &remote_rp_stamp, remote_rp_pa, |
| 729 | remote_vars_pa, remote_vars); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 730 | reactivate = 1; |
| 731 | |
| 732 | } else { |
| 733 | DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version)); |
| 734 | |
| 735 | stamp_diff = xpc_compare_stamps(&part->remote_rp_stamp, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 736 | &remote_rp_stamp); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 737 | if (stamp_diff != 0) { |
| 738 | DBUG_ON(stamp_diff >= 0); |
| 739 | |
| 740 | /* |
| 741 | * Other side rebooted and the previous XPC did support |
| 742 | * the disengage request, as does the new one. |
| 743 | */ |
| 744 | |
| 745 | DBUG_ON(xpc_partition_engaged(1UL << partid)); |
| 746 | DBUG_ON(xpc_partition_disengage_requested(1UL << |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 747 | partid)); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 748 | |
| 749 | xpc_update_partition_info(part, remote_rp_version, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 750 | &remote_rp_stamp, |
| 751 | remote_rp_pa, remote_vars_pa, |
| 752 | remote_vars); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 753 | reactivate = 1; |
| 754 | } |
| 755 | } |
| 756 | |
Dean Nelson | 246c7e3 | 2005-12-22 14:32:56 -0600 | [diff] [blame] | 757 | if (part->disengage_request_timeout > 0 && |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 758 | !xpc_partition_disengaged(part)) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 759 | /* still waiting on other side to disengage from us */ |
| 760 | return; |
| 761 | } |
| 762 | |
| 763 | if (reactivate) { |
| 764 | part->reactivate_nasid = nasid; |
| 765 | XPC_DEACTIVATE_PARTITION(part, xpcReactivating); |
| 766 | |
| 767 | } else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version) && |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 768 | xpc_partition_disengage_requested(1UL << partid)) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 769 | XPC_DEACTIVATE_PARTITION(part, xpcOtherGoingDown); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 770 | } |
| 771 | } |
| 772 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 773 | /* |
| 774 | * Loop through the activation AMO variables and process any bits |
| 775 | * which are set. Each bit indicates a nasid sending a partition |
| 776 | * activation or deactivation request. |
| 777 | * |
| 778 | * Return #of IRQs detected. |
| 779 | */ |
| 780 | int |
| 781 | xpc_identify_act_IRQ_sender(void) |
| 782 | { |
| 783 | int word, bit; |
| 784 | u64 nasid_mask; |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 785 | u64 nasid; /* remote nasid */ |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 786 | int n_IRQs_detected = 0; |
| 787 | AMO_t *act_amos; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 788 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 789 | act_amos = xpc_vars->amos_page + XPC_ACTIVATE_IRQ_AMOS; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 790 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 791 | /* scan through act AMO variable looking for non-zero entries */ |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 792 | for (word = 0; word < xp_nasid_mask_words; word++) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 793 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 794 | if (xpc_exiting) { |
| 795 | break; |
| 796 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 797 | |
| 798 | nasid_mask = xpc_IPI_receive(&act_amos[word]); |
| 799 | if (nasid_mask == 0) { |
| 800 | /* no IRQs from nasids in this variable */ |
| 801 | continue; |
| 802 | } |
| 803 | |
| 804 | dev_dbg(xpc_part, "AMO[%d] gave back 0x%lx\n", word, |
| 805 | nasid_mask); |
| 806 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 807 | /* |
| 808 | * If this nasid has been added to the machine since |
| 809 | * our partition was reset, this will retain the |
| 810 | * remote nasid in our reserved pages machine mask. |
| 811 | * This is used in the event of module reload. |
| 812 | */ |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 813 | xpc_mach_nasids[word] |= nasid_mask; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 814 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 815 | /* locate the nasid(s) which sent interrupts */ |
| 816 | |
| 817 | for (bit = 0; bit < (8 * sizeof(u64)); bit++) { |
| 818 | if (nasid_mask & (1UL << bit)) { |
| 819 | n_IRQs_detected++; |
| 820 | nasid = XPC_NASID_FROM_W_B(word, bit); |
| 821 | dev_dbg(xpc_part, "interrupt from nasid %ld\n", |
| 822 | nasid); |
| 823 | xpc_identify_act_IRQ_req(nasid); |
| 824 | } |
| 825 | } |
| 826 | } |
| 827 | return n_IRQs_detected; |
| 828 | } |
| 829 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 830 | /* |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 831 | * See if the other side has responded to a partition disengage request |
| 832 | * from us. |
| 833 | */ |
| 834 | int |
| 835 | xpc_partition_disengaged(struct xpc_partition *part) |
| 836 | { |
| 837 | partid_t partid = XPC_PARTID(part); |
| 838 | int disengaged; |
| 839 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 840 | disengaged = (xpc_partition_engaged(1UL << partid) == 0); |
| 841 | if (part->disengage_request_timeout) { |
| 842 | if (!disengaged) { |
Robert P. J. Day | d167cb8 | 2008-03-29 10:05:30 -0400 | [diff] [blame] | 843 | if (time_before(jiffies, part->disengage_request_timeout)) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 844 | /* timelimit hasn't been reached yet */ |
| 845 | return 0; |
| 846 | } |
| 847 | |
| 848 | /* |
| 849 | * Other side hasn't responded to our disengage |
| 850 | * request in a timely fashion, so assume it's dead. |
| 851 | */ |
| 852 | |
Dean Nelson | 1ecaded | 2006-01-06 09:48:21 -0600 | [diff] [blame] | 853 | dev_info(xpc_part, "disengage from remote partition %d " |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 854 | "timed out\n", partid); |
Dean Nelson | 1ecaded | 2006-01-06 09:48:21 -0600 | [diff] [blame] | 855 | xpc_disengage_request_timedout = 1; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 856 | xpc_clear_partition_engaged(1UL << partid); |
| 857 | disengaged = 1; |
| 858 | } |
| 859 | part->disengage_request_timeout = 0; |
| 860 | |
| 861 | /* cancel the timer function, provided it's not us */ |
| 862 | if (!in_interrupt()) { |
| 863 | del_singleshot_timer_sync(&part-> |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 864 | disengage_request_timer); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 865 | } |
| 866 | |
| 867 | DBUG_ON(part->act_state != XPC_P_DEACTIVATING && |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 868 | part->act_state != XPC_P_INACTIVE); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 869 | if (part->act_state != XPC_P_INACTIVE) { |
| 870 | xpc_wakeup_channel_mgr(part); |
| 871 | } |
| 872 | |
| 873 | if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) { |
| 874 | xpc_cancel_partition_disengage_request(part); |
| 875 | } |
| 876 | } |
| 877 | return disengaged; |
| 878 | } |
| 879 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 880 | /* |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 881 | * Mark specified partition as active. |
| 882 | */ |
| 883 | enum xpc_retval |
| 884 | xpc_mark_partition_active(struct xpc_partition *part) |
| 885 | { |
| 886 | unsigned long irq_flags; |
| 887 | enum xpc_retval ret; |
| 888 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 889 | dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part)); |
| 890 | |
| 891 | spin_lock_irqsave(&part->act_lock, irq_flags); |
| 892 | if (part->act_state == XPC_P_ACTIVATING) { |
| 893 | part->act_state = XPC_P_ACTIVE; |
| 894 | ret = xpcSuccess; |
| 895 | } else { |
| 896 | DBUG_ON(part->reason == xpcSuccess); |
| 897 | ret = part->reason; |
| 898 | } |
| 899 | spin_unlock_irqrestore(&part->act_lock, irq_flags); |
| 900 | |
| 901 | return ret; |
| 902 | } |
| 903 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 904 | /* |
| 905 | * Notify XPC that the partition is down. |
| 906 | */ |
| 907 | void |
| 908 | xpc_deactivate_partition(const int line, struct xpc_partition *part, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 909 | enum xpc_retval reason) |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 910 | { |
| 911 | unsigned long irq_flags; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 912 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 913 | spin_lock_irqsave(&part->act_lock, irq_flags); |
| 914 | |
| 915 | if (part->act_state == XPC_P_INACTIVE) { |
| 916 | XPC_SET_REASON(part, reason, line); |
| 917 | spin_unlock_irqrestore(&part->act_lock, irq_flags); |
| 918 | if (reason == xpcReactivating) { |
| 919 | /* we interrupt ourselves to reactivate partition */ |
| 920 | xpc_IPI_send_reactivate(part); |
| 921 | } |
| 922 | return; |
| 923 | } |
| 924 | if (part->act_state == XPC_P_DEACTIVATING) { |
| 925 | if ((part->reason == xpcUnloading && reason != xpcUnloading) || |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 926 | reason == xpcReactivating) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 927 | XPC_SET_REASON(part, reason, line); |
| 928 | } |
| 929 | spin_unlock_irqrestore(&part->act_lock, irq_flags); |
| 930 | return; |
| 931 | } |
| 932 | |
| 933 | part->act_state = XPC_P_DEACTIVATING; |
| 934 | XPC_SET_REASON(part, reason, line); |
| 935 | |
| 936 | spin_unlock_irqrestore(&part->act_lock, irq_flags); |
| 937 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 938 | if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) { |
| 939 | xpc_request_partition_disengage(part); |
| 940 | xpc_IPI_send_disengage(part); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 941 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 942 | /* set a timelimit on the disengage request */ |
| 943 | part->disengage_request_timeout = jiffies + |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 944 | (xpc_disengage_request_timelimit * HZ); |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 945 | part->disengage_request_timer.expires = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 946 | part->disengage_request_timeout; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 947 | add_timer(&part->disengage_request_timer); |
| 948 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 949 | |
Dean Nelson | e54af72 | 2005-10-25 14:07:43 -0500 | [diff] [blame] | 950 | dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n", |
| 951 | XPC_PARTID(part), reason); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 952 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 953 | xpc_partition_going_down(part, reason); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 954 | } |
| 955 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 956 | /* |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 957 | * Mark specified partition as inactive. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 958 | */ |
| 959 | void |
| 960 | xpc_mark_partition_inactive(struct xpc_partition *part) |
| 961 | { |
| 962 | unsigned long irq_flags; |
| 963 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 964 | dev_dbg(xpc_part, "setting partition %d to INACTIVE\n", |
| 965 | XPC_PARTID(part)); |
| 966 | |
| 967 | spin_lock_irqsave(&part->act_lock, irq_flags); |
| 968 | part->act_state = XPC_P_INACTIVE; |
| 969 | spin_unlock_irqrestore(&part->act_lock, irq_flags); |
| 970 | part->remote_rp_pa = 0; |
| 971 | } |
| 972 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 973 | /* |
| 974 | * SAL has provided a partition and machine mask. The partition mask |
| 975 | * contains a bit for each even nasid in our partition. The machine |
| 976 | * mask contains a bit for each even nasid in the entire machine. |
| 977 | * |
| 978 | * Using those two bit arrays, we can determine which nasids are |
| 979 | * known in the machine. Each should also have a reserved page |
| 980 | * initialized if they are available for partitioning. |
| 981 | */ |
| 982 | void |
| 983 | xpc_discovery(void) |
| 984 | { |
| 985 | void *remote_rp_base; |
| 986 | struct xpc_rsvd_page *remote_rp; |
| 987 | struct xpc_vars *remote_vars; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 988 | u64 remote_rp_pa; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 989 | u64 remote_vars_pa; |
| 990 | int region; |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 991 | int region_size; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 992 | int max_regions; |
| 993 | int nasid; |
| 994 | struct xpc_rsvd_page *rp; |
| 995 | partid_t partid; |
| 996 | struct xpc_partition *part; |
| 997 | u64 *discovered_nasids; |
| 998 | enum xpc_retval ret; |
| 999 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1000 | remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE + |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1001 | xp_nasid_mask_bytes, |
| 1002 | GFP_KERNEL, &remote_rp_base); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1003 | if (remote_rp == NULL) { |
| 1004 | return; |
| 1005 | } |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1006 | remote_vars = (struct xpc_vars *)remote_rp; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1007 | |
Jes Sorensen | 7aa6ba4 | 2006-02-17 05:18:43 -0500 | [diff] [blame] | 1008 | discovered_nasids = kzalloc(sizeof(u64) * xp_nasid_mask_words, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1009 | GFP_KERNEL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1010 | if (discovered_nasids == NULL) { |
| 1011 | kfree(remote_rp_base); |
| 1012 | return; |
| 1013 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1014 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1015 | rp = (struct xpc_rsvd_page *)xpc_rsvd_page; |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1016 | |
| 1017 | /* |
| 1018 | * The term 'region' in this context refers to the minimum number of |
| 1019 | * nodes that can comprise an access protection grouping. The access |
| 1020 | * protection is in regards to memory, IOI and IPI. |
| 1021 | */ |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1022 | max_regions = 64; |
| 1023 | region_size = sn_region_size; |
| 1024 | |
| 1025 | switch (region_size) { |
| 1026 | case 128: |
| 1027 | max_regions *= 2; |
| 1028 | case 64: |
| 1029 | max_regions *= 2; |
| 1030 | case 32: |
| 1031 | max_regions *= 2; |
| 1032 | region_size = 16; |
| 1033 | DBUG_ON(!is_shub2()); |
| 1034 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1035 | |
| 1036 | for (region = 0; region < max_regions; region++) { |
| 1037 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1038 | if ((volatile int)xpc_exiting) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1039 | break; |
| 1040 | } |
| 1041 | |
| 1042 | dev_dbg(xpc_part, "searching region %d\n", region); |
| 1043 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1044 | for (nasid = (region * region_size * 2); |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1045 | nasid < ((region + 1) * region_size * 2); nasid += 2) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1046 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1047 | if ((volatile int)xpc_exiting) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1048 | break; |
| 1049 | } |
| 1050 | |
| 1051 | dev_dbg(xpc_part, "checking nasid %d\n", nasid); |
| 1052 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1053 | if (XPC_NASID_IN_ARRAY(nasid, xpc_part_nasids)) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1054 | dev_dbg(xpc_part, "PROM indicates Nasid %d is " |
| 1055 | "part of the local partition; skipping " |
| 1056 | "region\n", nasid); |
| 1057 | break; |
| 1058 | } |
| 1059 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1060 | if (!(XPC_NASID_IN_ARRAY(nasid, xpc_mach_nasids))) { |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1061 | dev_dbg(xpc_part, "PROM indicates Nasid %d was " |
| 1062 | "not on Numa-Link network at reset\n", |
| 1063 | nasid); |
| 1064 | continue; |
| 1065 | } |
| 1066 | |
| 1067 | if (XPC_NASID_IN_ARRAY(nasid, discovered_nasids)) { |
| 1068 | dev_dbg(xpc_part, "Nasid %d is part of a " |
| 1069 | "partition which was previously " |
| 1070 | "discovered\n", nasid); |
| 1071 | continue; |
| 1072 | } |
| 1073 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1074 | /* pull over the reserved page structure */ |
| 1075 | |
| 1076 | ret = xpc_get_remote_rp(nasid, discovered_nasids, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1077 | remote_rp, &remote_rp_pa); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1078 | if (ret != xpcSuccess) { |
| 1079 | dev_dbg(xpc_part, "unable to get reserved page " |
| 1080 | "from nasid %d, reason=%d\n", nasid, |
| 1081 | ret); |
| 1082 | |
| 1083 | if (ret == xpcLocalPartid) { |
| 1084 | break; |
| 1085 | } |
| 1086 | continue; |
| 1087 | } |
| 1088 | |
| 1089 | remote_vars_pa = remote_rp->vars_pa; |
| 1090 | |
| 1091 | partid = remote_rp->partid; |
| 1092 | part = &xpc_partitions[partid]; |
| 1093 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1094 | /* pull over the cross partition variables */ |
| 1095 | |
| 1096 | ret = xpc_get_remote_vars(remote_vars_pa, remote_vars); |
| 1097 | if (ret != xpcSuccess) { |
| 1098 | dev_dbg(xpc_part, "unable to get XPC variables " |
| 1099 | "from nasid %d, reason=%d\n", nasid, |
| 1100 | ret); |
| 1101 | |
| 1102 | XPC_DEACTIVATE_PARTITION(part, ret); |
| 1103 | continue; |
| 1104 | } |
| 1105 | |
| 1106 | if (part->act_state != XPC_P_INACTIVE) { |
| 1107 | dev_dbg(xpc_part, "partition %d on nasid %d is " |
| 1108 | "already activating\n", partid, nasid); |
| 1109 | break; |
| 1110 | } |
| 1111 | |
| 1112 | /* |
| 1113 | * Register the remote partition's AMOs with SAL so it |
| 1114 | * can handle and cleanup errors within that address |
| 1115 | * range should the remote partition go down. We don't |
| 1116 | * unregister this range because it is difficult to |
| 1117 | * tell when outstanding writes to the remote partition |
| 1118 | * are finished and thus when it is thus safe to |
| 1119 | * unregister. This should not result in wasted space |
| 1120 | * in the SAL xp_addr_region table because we should |
| 1121 | * get the same page for remote_act_amos_pa after |
| 1122 | * module reloads and system reboots. |
| 1123 | */ |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1124 | if (sn_register_xp_addr_region |
| 1125 | (remote_vars->amos_page_pa, PAGE_SIZE, 1) < 0) { |
| 1126 | dev_dbg(xpc_part, |
| 1127 | "partition %d failed to " |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1128 | "register xp_addr region 0x%016lx\n", |
| 1129 | partid, remote_vars->amos_page_pa); |
| 1130 | |
| 1131 | XPC_SET_REASON(part, xpcPhysAddrRegFailed, |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1132 | __LINE__); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1133 | break; |
| 1134 | } |
| 1135 | |
| 1136 | /* |
| 1137 | * The remote nasid is valid and available. |
| 1138 | * Send an interrupt to that nasid to notify |
| 1139 | * it that we are ready to begin activation. |
| 1140 | */ |
| 1141 | dev_dbg(xpc_part, "sending an interrupt to AMO 0x%lx, " |
| 1142 | "nasid %d, phys_cpuid 0x%x\n", |
| 1143 | remote_vars->amos_page_pa, |
| 1144 | remote_vars->act_nasid, |
| 1145 | remote_vars->act_phys_cpuid); |
| 1146 | |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 1147 | if (XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars-> |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1148 | version)) { |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 1149 | part->remote_amos_page_pa = |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1150 | remote_vars->amos_page_pa; |
Dean Nelson | a607c38 | 2005-09-01 14:01:37 -0500 | [diff] [blame] | 1151 | xpc_mark_partition_disengaged(part); |
| 1152 | xpc_cancel_partition_disengage_request(part); |
| 1153 | } |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1154 | xpc_IPI_send_activate(remote_vars); |
| 1155 | } |
| 1156 | } |
| 1157 | |
| 1158 | kfree(discovered_nasids); |
| 1159 | kfree(remote_rp_base); |
| 1160 | } |
| 1161 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1162 | /* |
| 1163 | * Given a partid, get the nasids owned by that partition from the |
Dean Nelson | 3a7d555 | 2005-04-04 13:14:00 -0700 | [diff] [blame] | 1164 | * remote partition's reserved page. |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1165 | */ |
| 1166 | enum xpc_retval |
| 1167 | xpc_initiate_partid_to_nasids(partid_t partid, void *nasid_mask) |
| 1168 | { |
| 1169 | struct xpc_partition *part; |
| 1170 | u64 part_nasid_pa; |
| 1171 | int bte_res; |
| 1172 | |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1173 | part = &xpc_partitions[partid]; |
| 1174 | if (part->remote_rp_pa == 0) { |
| 1175 | return xpcPartitionDown; |
| 1176 | } |
| 1177 | |
Dean Nelson | 4b38fcd | 2005-10-25 14:09:51 -0500 | [diff] [blame] | 1178 | memset(nasid_mask, 0, XP_NASID_MASK_BYTES); |
| 1179 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1180 | part_nasid_pa = (u64)XPC_RP_PART_NASIDS(part->remote_rp_pa); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1181 | |
Dean Nelson | 4a3ad2d | 2008-04-22 14:48:01 -0500 | [diff] [blame^] | 1182 | bte_res = xp_bte_copy(part_nasid_pa, (u64)nasid_mask, |
| 1183 | xp_nasid_mask_bytes, (BTE_NOTIFY | BTE_WACQUIRE), |
| 1184 | NULL); |
Dean Nelson | 89eb8eb | 2005-03-23 19:50:00 -0700 | [diff] [blame] | 1185 | |
| 1186 | return xpc_map_bte_errors(bte_res); |
| 1187 | } |