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 * 6 * (C) Copyright 2020 Hewlett Packard Enterprise Development LP 7 * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. 8 */ 9 10 /* 11 * Cross Partition Communication (XPC) partition support. 12 * 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. 16 * 17 */ 18 19 #include <linux/device.h> 20 #include <linux/hardirq.h> 21 #include <linux/slab.h> 22 #include "xpc.h" 23 #include <asm/uv/uv_hub.h> 24 25 /* XPC is exiting flag */ 26 int xpc_exiting; 27 28 /* this partition's reserved page pointers */ 29 struct xpc_rsvd_page *xpc_rsvd_page; 30 static unsigned long *xpc_part_nasids; 31 unsigned long *xpc_mach_nasids; 32 33 static int xpc_nasid_mask_nbytes; /* #of bytes in nasid mask */ 34 int xpc_nasid_mask_nlongs; /* #of longs in nasid mask */ 35 36 struct xpc_partition *xpc_partitions; 37 38 /* 39 * Guarantee that the kmalloc'd memory is cacheline aligned. 40 */ 41 void * 42 xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base) 43 { 44 /* see if kmalloc will give us cachline aligned memory by default */ 45 *base = kmalloc(size, flags); 46 if (*base == NULL) 47 return NULL; 48 49 if ((u64)*base == L1_CACHE_ALIGN((u64)*base)) 50 return *base; 51 52 kfree(*base); 53 54 /* nope, we'll have to do it ourselves */ 55 *base = kmalloc(size + L1_CACHE_BYTES, flags); 56 if (*base == NULL) 57 return NULL; 58 59 return (void *)L1_CACHE_ALIGN((u64)*base); 60 } 61 62 /* 63 * Given a nasid, get the physical address of the partition's reserved page 64 * for that nasid. This function returns 0 on any error. 65 */ 66 static unsigned long 67 xpc_get_rsvd_page_pa(int nasid) 68 { 69 enum xp_retval ret; 70 u64 cookie = 0; 71 unsigned long rp_pa = nasid; /* seed with nasid */ 72 size_t len = 0; 73 size_t buf_len = 0; 74 void *buf = NULL; 75 void *buf_base = NULL; 76 enum xp_retval (*get_partition_rsvd_page_pa) 77 (void *, u64 *, unsigned long *, size_t *) = 78 xpc_arch_ops.get_partition_rsvd_page_pa; 79 80 while (1) { 81 82 /* !!! rp_pa will need to be _gpa on UV. 83 * ??? So do we save it into the architecture specific parts 84 * ??? of the xpc_partition structure? Do we rename this 85 * ??? function or have two versions? Rename rp_pa for UV to 86 * ??? rp_gpa? 87 */ 88 ret = get_partition_rsvd_page_pa(buf, &cookie, &rp_pa, &len); 89 90 dev_dbg(xpc_part, "SAL returned with ret=%d, cookie=0x%016lx, " 91 "address=0x%016lx, len=0x%016lx\n", ret, 92 (unsigned long)cookie, rp_pa, len); 93 94 if (ret != xpNeedMoreInfo) 95 break; 96 97 if (len > buf_len) { 98 kfree(buf_base); 99 buf_len = L1_CACHE_ALIGN(len); 100 buf = xpc_kmalloc_cacheline_aligned(buf_len, GFP_KERNEL, 101 &buf_base); 102 if (buf_base == NULL) { 103 dev_err(xpc_part, "unable to kmalloc " 104 "len=0x%016lx\n", buf_len); 105 ret = xpNoMemory; 106 break; 107 } 108 } 109 110 ret = xp_remote_memcpy(xp_pa(buf), rp_pa, len); 111 if (ret != xpSuccess) { 112 dev_dbg(xpc_part, "xp_remote_memcpy failed %d\n", ret); 113 break; 114 } 115 } 116 117 kfree(buf_base); 118 119 if (ret != xpSuccess) 120 rp_pa = 0; 121 122 dev_dbg(xpc_part, "reserved page at phys address 0x%016lx\n", rp_pa); 123 return rp_pa; 124 } 125 126 /* 127 * Fill the partition reserved page with the information needed by 128 * other partitions to discover we are alive and establish initial 129 * communications. 130 */ 131 int 132 xpc_setup_rsvd_page(void) 133 { 134 int ret; 135 struct xpc_rsvd_page *rp; 136 unsigned long rp_pa; 137 unsigned long new_ts_jiffies; 138 139 /* get the local reserved page's address */ 140 141 preempt_disable(); 142 rp_pa = xpc_get_rsvd_page_pa(xp_cpu_to_nasid(smp_processor_id())); 143 preempt_enable(); 144 if (rp_pa == 0) { 145 dev_err(xpc_part, "SAL failed to locate the reserved page\n"); 146 return -ESRCH; 147 } 148 rp = (struct xpc_rsvd_page *)__va(xp_socket_pa(rp_pa)); 149 150 if (rp->SAL_version < 3) { 151 /* SAL_versions < 3 had a SAL_partid defined as a u8 */ 152 rp->SAL_partid &= 0xff; 153 } 154 BUG_ON(rp->SAL_partid != xp_partition_id); 155 156 if (rp->SAL_partid < 0 || rp->SAL_partid >= xp_max_npartitions) { 157 dev_err(xpc_part, "the reserved page's partid of %d is outside " 158 "supported range (< 0 || >= %d)\n", rp->SAL_partid, 159 xp_max_npartitions); 160 return -EINVAL; 161 } 162 163 rp->version = XPC_RP_VERSION; 164 rp->max_npartitions = xp_max_npartitions; 165 166 /* establish the actual sizes of the nasid masks */ 167 if (rp->SAL_version == 1) { 168 /* SAL_version 1 didn't set the nasids_size field */ 169 rp->SAL_nasids_size = 128; 170 } 171 xpc_nasid_mask_nbytes = rp->SAL_nasids_size; 172 xpc_nasid_mask_nlongs = BITS_TO_LONGS(rp->SAL_nasids_size * 173 BITS_PER_BYTE); 174 175 /* setup the pointers to the various items in the reserved page */ 176 xpc_part_nasids = XPC_RP_PART_NASIDS(rp); 177 xpc_mach_nasids = XPC_RP_MACH_NASIDS(rp); 178 179 ret = xpc_arch_ops.setup_rsvd_page(rp); 180 if (ret != 0) 181 return ret; 182 183 /* 184 * Set timestamp of when reserved page was setup by XPC. 185 * This signifies to the remote partition that our reserved 186 * page is initialized. 187 */ 188 new_ts_jiffies = jiffies; 189 if (new_ts_jiffies == 0 || new_ts_jiffies == rp->ts_jiffies) 190 new_ts_jiffies++; 191 rp->ts_jiffies = new_ts_jiffies; 192 193 xpc_rsvd_page = rp; 194 return 0; 195 } 196 197 void 198 xpc_teardown_rsvd_page(void) 199 { 200 /* a zero timestamp indicates our rsvd page is not initialized */ 201 xpc_rsvd_page->ts_jiffies = 0; 202 } 203 204 /* 205 * Get a copy of a portion of the remote partition's rsvd page. 206 * 207 * remote_rp points to a buffer that is cacheline aligned for BTE copies and 208 * is large enough to contain a copy of their reserved page header and 209 * part_nasids mask. 210 */ 211 enum xp_retval 212 xpc_get_remote_rp(int nasid, unsigned long *discovered_nasids, 213 struct xpc_rsvd_page *remote_rp, unsigned long *remote_rp_pa) 214 { 215 int l; 216 enum xp_retval ret; 217 218 /* get the reserved page's physical address */ 219 220 *remote_rp_pa = xpc_get_rsvd_page_pa(nasid); 221 if (*remote_rp_pa == 0) 222 return xpNoRsvdPageAddr; 223 224 /* pull over the reserved page header and part_nasids mask */ 225 ret = xp_remote_memcpy(xp_pa(remote_rp), *remote_rp_pa, 226 XPC_RP_HEADER_SIZE + xpc_nasid_mask_nbytes); 227 if (ret != xpSuccess) 228 return ret; 229 230 if (discovered_nasids != NULL) { 231 unsigned long *remote_part_nasids = 232 XPC_RP_PART_NASIDS(remote_rp); 233 234 for (l = 0; l < xpc_nasid_mask_nlongs; l++) 235 discovered_nasids[l] |= remote_part_nasids[l]; 236 } 237 238 /* zero timestamp indicates the reserved page has not been setup */ 239 if (remote_rp->ts_jiffies == 0) 240 return xpRsvdPageNotSet; 241 242 if (XPC_VERSION_MAJOR(remote_rp->version) != 243 XPC_VERSION_MAJOR(XPC_RP_VERSION)) { 244 return xpBadVersion; 245 } 246 247 /* check that both remote and local partids are valid for each side */ 248 if (remote_rp->SAL_partid < 0 || 249 remote_rp->SAL_partid >= xp_max_npartitions || 250 remote_rp->max_npartitions <= xp_partition_id) { 251 return xpInvalidPartid; 252 } 253 254 if (remote_rp->SAL_partid == xp_partition_id) 255 return xpLocalPartid; 256 257 return xpSuccess; 258 } 259 260 /* 261 * See if the other side has responded to a partition deactivate request 262 * from us. Though we requested the remote partition to deactivate with regard 263 * to us, we really only need to wait for the other side to disengage from us. 264 */ 265 int 266 xpc_partition_disengaged(struct xpc_partition *part) 267 { 268 short partid = XPC_PARTID(part); 269 int disengaged; 270 271 disengaged = !xpc_arch_ops.partition_engaged(partid); 272 if (part->disengage_timeout) { 273 if (!disengaged) { 274 if (time_is_after_jiffies(part->disengage_timeout)) { 275 /* timelimit hasn't been reached yet */ 276 return 0; 277 } 278 279 /* 280 * Other side hasn't responded to our deactivate 281 * request in a timely fashion, so assume it's dead. 282 */ 283 284 dev_info(xpc_part, "deactivate request to remote " 285 "partition %d timed out\n", partid); 286 xpc_disengage_timedout = 1; 287 xpc_arch_ops.assume_partition_disengaged(partid); 288 disengaged = 1; 289 } 290 part->disengage_timeout = 0; 291 292 /* cancel the timer function, provided it's not us */ 293 if (!in_interrupt()) 294 del_singleshot_timer_sync(&part->disengage_timer); 295 296 DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING && 297 part->act_state != XPC_P_AS_INACTIVE); 298 if (part->act_state != XPC_P_AS_INACTIVE) 299 xpc_wakeup_channel_mgr(part); 300 301 xpc_arch_ops.cancel_partition_deactivation_request(part); 302 } 303 return disengaged; 304 } 305 306 /* 307 * Mark specified partition as active. 308 */ 309 enum xp_retval 310 xpc_mark_partition_active(struct xpc_partition *part) 311 { 312 unsigned long irq_flags; 313 enum xp_retval ret; 314 315 dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part)); 316 317 spin_lock_irqsave(&part->act_lock, irq_flags); 318 if (part->act_state == XPC_P_AS_ACTIVATING) { 319 part->act_state = XPC_P_AS_ACTIVE; 320 ret = xpSuccess; 321 } else { 322 DBUG_ON(part->reason == xpSuccess); 323 ret = part->reason; 324 } 325 spin_unlock_irqrestore(&part->act_lock, irq_flags); 326 327 return ret; 328 } 329 330 /* 331 * Start the process of deactivating the specified partition. 332 */ 333 void 334 xpc_deactivate_partition(const int line, struct xpc_partition *part, 335 enum xp_retval reason) 336 { 337 unsigned long irq_flags; 338 339 spin_lock_irqsave(&part->act_lock, irq_flags); 340 341 if (part->act_state == XPC_P_AS_INACTIVE) { 342 XPC_SET_REASON(part, reason, line); 343 spin_unlock_irqrestore(&part->act_lock, irq_flags); 344 if (reason == xpReactivating) { 345 /* we interrupt ourselves to reactivate partition */ 346 xpc_arch_ops.request_partition_reactivation(part); 347 } 348 return; 349 } 350 if (part->act_state == XPC_P_AS_DEACTIVATING) { 351 if ((part->reason == xpUnloading && reason != xpUnloading) || 352 reason == xpReactivating) { 353 XPC_SET_REASON(part, reason, line); 354 } 355 spin_unlock_irqrestore(&part->act_lock, irq_flags); 356 return; 357 } 358 359 part->act_state = XPC_P_AS_DEACTIVATING; 360 XPC_SET_REASON(part, reason, line); 361 362 spin_unlock_irqrestore(&part->act_lock, irq_flags); 363 364 /* ask remote partition to deactivate with regard to us */ 365 xpc_arch_ops.request_partition_deactivation(part); 366 367 /* set a timelimit on the disengage phase of the deactivation request */ 368 part->disengage_timeout = jiffies + (xpc_disengage_timelimit * HZ); 369 part->disengage_timer.expires = part->disengage_timeout; 370 add_timer(&part->disengage_timer); 371 372 dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n", 373 XPC_PARTID(part), reason); 374 375 xpc_partition_going_down(part, reason); 376 } 377 378 /* 379 * Mark specified partition as inactive. 380 */ 381 void 382 xpc_mark_partition_inactive(struct xpc_partition *part) 383 { 384 unsigned long irq_flags; 385 386 dev_dbg(xpc_part, "setting partition %d to INACTIVE\n", 387 XPC_PARTID(part)); 388 389 spin_lock_irqsave(&part->act_lock, irq_flags); 390 part->act_state = XPC_P_AS_INACTIVE; 391 spin_unlock_irqrestore(&part->act_lock, irq_flags); 392 part->remote_rp_pa = 0; 393 } 394 395 /* 396 * SAL has provided a partition and machine mask. The partition mask 397 * contains a bit for each even nasid in our partition. The machine 398 * mask contains a bit for each even nasid in the entire machine. 399 * 400 * Using those two bit arrays, we can determine which nasids are 401 * known in the machine. Each should also have a reserved page 402 * initialized if they are available for partitioning. 403 */ 404 void 405 xpc_discovery(void) 406 { 407 void *remote_rp_base; 408 struct xpc_rsvd_page *remote_rp; 409 unsigned long remote_rp_pa; 410 int region; 411 int region_size; 412 int max_regions; 413 int nasid; 414 unsigned long *discovered_nasids; 415 enum xp_retval ret; 416 417 remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE + 418 xpc_nasid_mask_nbytes, 419 GFP_KERNEL, &remote_rp_base); 420 if (remote_rp == NULL) 421 return; 422 423 discovered_nasids = kcalloc(xpc_nasid_mask_nlongs, sizeof(long), 424 GFP_KERNEL); 425 if (discovered_nasids == NULL) { 426 kfree(remote_rp_base); 427 return; 428 } 429 430 /* 431 * The term 'region' in this context refers to the minimum number of 432 * nodes that can comprise an access protection grouping. The access 433 * protection is in regards to memory, IOI and IPI. 434 */ 435 region_size = xp_region_size; 436 437 if (is_uv_system()) 438 max_regions = 256; 439 else { 440 max_regions = 64; 441 442 switch (region_size) { 443 case 128: 444 max_regions *= 2; 445 fallthrough; 446 case 64: 447 max_regions *= 2; 448 fallthrough; 449 case 32: 450 max_regions *= 2; 451 region_size = 16; 452 } 453 } 454 455 for (region = 0; region < max_regions; region++) { 456 457 if (xpc_exiting) 458 break; 459 460 dev_dbg(xpc_part, "searching region %d\n", region); 461 462 for (nasid = (region * region_size * 2); 463 nasid < ((region + 1) * region_size * 2); nasid += 2) { 464 465 if (xpc_exiting) 466 break; 467 468 dev_dbg(xpc_part, "checking nasid %d\n", nasid); 469 470 if (test_bit(nasid / 2, xpc_part_nasids)) { 471 dev_dbg(xpc_part, "PROM indicates Nasid %d is " 472 "part of the local partition; skipping " 473 "region\n", nasid); 474 break; 475 } 476 477 if (!(test_bit(nasid / 2, xpc_mach_nasids))) { 478 dev_dbg(xpc_part, "PROM indicates Nasid %d was " 479 "not on Numa-Link network at reset\n", 480 nasid); 481 continue; 482 } 483 484 if (test_bit(nasid / 2, discovered_nasids)) { 485 dev_dbg(xpc_part, "Nasid %d is part of a " 486 "partition which was previously " 487 "discovered\n", nasid); 488 continue; 489 } 490 491 /* pull over the rsvd page header & part_nasids mask */ 492 493 ret = xpc_get_remote_rp(nasid, discovered_nasids, 494 remote_rp, &remote_rp_pa); 495 if (ret != xpSuccess) { 496 dev_dbg(xpc_part, "unable to get reserved page " 497 "from nasid %d, reason=%d\n", nasid, 498 ret); 499 500 if (ret == xpLocalPartid) 501 break; 502 503 continue; 504 } 505 506 xpc_arch_ops.request_partition_activation(remote_rp, 507 remote_rp_pa, nasid); 508 } 509 } 510 511 kfree(discovered_nasids); 512 kfree(remote_rp_base); 513 } 514 515 /* 516 * Given a partid, get the nasids owned by that partition from the 517 * remote partition's reserved page. 518 */ 519 enum xp_retval 520 xpc_initiate_partid_to_nasids(short partid, void *nasid_mask) 521 { 522 struct xpc_partition *part; 523 unsigned long part_nasid_pa; 524 525 part = &xpc_partitions[partid]; 526 if (part->remote_rp_pa == 0) 527 return xpPartitionDown; 528 529 memset(nasid_mask, 0, xpc_nasid_mask_nbytes); 530 531 part_nasid_pa = (unsigned long)XPC_RP_PART_NASIDS(part->remote_rp_pa); 532 533 return xp_remote_memcpy(xp_pa(nasid_mask), part_nasid_pa, 534 xpc_nasid_mask_nbytes); 535 } 536