drivers/misc/sgi-xp/xpc_partition.c

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