arch/alpha/kernel/smp.c

   1 /*
   2  *      linux/arch/alpha/kernel/smp.c
   3  *
   4  *      2001-07-09 Phil Ezolt (Phillip.Ezolt@compaq.com)
   5  *            Renamed modified smp_call_function to smp_call_function_on_cpu()
   6  *            Created an function that conforms to the old calling convention
   7  *            of smp_call_function().
   8  *
   9  *            This is helpful for DCPI.
  10  *
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/kernel.h>
  15 #include <linux/kernel_stat.h>
  16 #include <linux/module.h>
  17 #include <linux/sched.h>
  18 #include <linux/mm.h>
  19 #include <linux/threads.h>
  20 #include <linux/smp.h>
  21 #include <linux/smp_lock.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/init.h>
  24 #include <linux/delay.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/irq.h>
  27 #include <linux/cache.h>
  28
  29 #include <asm/hwrpb.h>
  30 #include <asm/ptrace.h>
  31 #include <asm/atomic.h>
  32
  33 #include <asm/io.h>
  34 #include <asm/irq.h>
  35 #include <asm/bitops.h>
  36 #include <asm/pgtable.h>
  37 #include <asm/pgalloc.h>
  38 #include <asm/hardirq.h>
  39 #include <asm/mmu_context.h>
  40 #include <asm/tlbflush.h>
  41
  42 #include "proto.h"
  43 #include "irq_impl.h"
  44
  45
  46 #define DEBUG_SMP 0
  47 #if DEBUG_SMP
  48 #define DBGS(args)      printk args
  49 #else
  50 #define DBGS(args)
  51 #endif
  52
  53 /* A collection of per-processor data.  */
  54 struct cpuinfo_alpha cpu_data[NR_CPUS];
  55
  56 /* A collection of single bit ipi messages.  */
  57 static struct {
  58         unsigned long bits ____cacheline_aligned;
  59 } ipi_data[NR_CPUS] __cacheline_aligned;
  60
  61 enum ipi_message_type {
  62         IPI_RESCHEDULE,
  63         IPI_CALL_FUNC,
  64         IPI_CPU_STOP,
  65 };
  66
  67 /* Set to a secondary's cpuid when it comes online.  */
  68 static int smp_secondary_alive __initdata = 0;
  69
  70 /* Which cpus ids came online.  */
  71 unsigned long cpu_present_mask;
  72 cpumask_t cpu_online_map;
  73
  74 EXPORT_SYMBOL(cpu_online_map);
  75
  76 /* cpus reported in the hwrpb */
  77 static unsigned long hwrpb_cpu_present_mask __initdata = 0;
  78
  79 int smp_num_probed;             /* Internal processor count */
  80 int smp_num_cpus = 1;           /* Number that came online.  */
  81 cycles_t cacheflush_time;
  82 unsigned long cache_decay_ticks;
  83
  84 extern void calibrate_delay(void);
  85
  86 \f
  87
  88 /*
  89  * Called by both boot and secondaries to move global data into
  90  *  per-processor storage.
  91  */
  92 static inline void __init
  93 smp_store_cpu_info(int cpuid)
  94 {
  95         cpu_data[cpuid].loops_per_jiffy = loops_per_jiffy;
  96         cpu_data[cpuid].last_asn = ASN_FIRST_VERSION;
  97         cpu_data[cpuid].need_new_asn = 0;
  98         cpu_data[cpuid].asn_lock = 0;
  99 }
 100
 101 /*
 102  * Ideally sets up per-cpu profiling hooks.  Doesn't do much now...
 103  */
 104 static inline void __init
 105 smp_setup_percpu_timer(int cpuid)
 106 {
 107         cpu_data[cpuid].prof_counter = 1;
 108         cpu_data[cpuid].prof_multiplier = 1;
 109 }
 110
 111 static void __init
 112 wait_boot_cpu_to_stop(int cpuid)
 113 {
 114         unsigned long stop = jiffies + 10*HZ;
 115
 116         while (time_before(jiffies, stop)) {
 117                 if (!smp_secondary_alive)
 118                         return;
 119                 barrier();
 120         }
 121
 122         printk("wait_boot_cpu_to_stop: FAILED on CPU %d, hanging now\n", cpuid);
 123         for (;;)
 124                 barrier();
 125 }
 126
 127 /*
 128  * Where secondaries begin a life of C.
 129  */
 130 void __init
 131 smp_callin(void)
 132 {
 133         int cpuid = hard_smp_processor_id();
 134
 135         if (cpu_test_and_set(cpuid, cpu_online_map)) {
 136                 printk("??, cpu 0x%x already present??\n", cpuid);
 137                 BUG();
 138         }
 139
 140         /* Turn on machine checks.  */
 141         wrmces(7);
 142
 143         /* Set trap vectors.  */
 144         trap_init();
 145
 146         /* Set interrupt vector.  */
 147         wrent(entInt, 0);
 148
 149         /* Get our local ticker going. */
 150         smp_setup_percpu_timer(cpuid);
 151
 152         /* Call platform-specific callin, if specified */
 153         if (alpha_mv.smp_callin) alpha_mv.smp_callin();
 154
 155         /* All kernel threads share the same mm context.  */
 156         atomic_inc(&init_mm.mm_count);
 157         current->active_mm = &init_mm;
 158
 159         /* Must have completely accurate bogos.  */
 160         local_irq_enable();
 161
 162         /* Wait boot CPU to stop with irq enabled before running
 163            calibrate_delay. */
 164         wait_boot_cpu_to_stop(cpuid);
 165         mb();
 166         calibrate_delay();
 167
 168         smp_store_cpu_info(cpuid);
 169         /* Allow master to continue only after we written loops_per_jiffy.  */
 170         wmb();
 171         smp_secondary_alive = 1;
 172
 173         DBGS(("smp_callin: commencing CPU %d current %p active_mm %p\n",
 174               cpuid, current, current->active_mm));
 175
 176         /* Do nothing.  */
 177         cpu_idle();
 178 }
 179
 180
 181 /*
 182  * Rough estimation for SMP scheduling, this is the number of cycles it
 183  * takes for a fully memory-limited process to flush the SMP-local cache.
 184  *
 185  * We are not told how much cache there is, so we have to guess.
 186  */
 187 static void __init
 188 smp_tune_scheduling (int cpuid)
 189 {
 190         struct percpu_struct *cpu;
 191         unsigned long on_chip_cache;    /* kB */
 192         unsigned long freq;             /* Hz */
 193         unsigned long bandwidth = 350;  /* MB/s */
 194
 195         cpu = (struct percpu_struct*)((char*)hwrpb + hwrpb->processor_offset
 196                                       + cpuid * hwrpb->processor_size);
 197         switch (cpu->type)
 198         {
 199         case EV45_CPU:
 200                 on_chip_cache = 16 + 16;
 201                 break;
 202
 203         case EV5_CPU:
 204         case EV56_CPU:
 205                 on_chip_cache = 8 + 8 + 96;
 206                 break;
 207
 208         case PCA56_CPU:
 209                 on_chip_cache = 16 + 8;
 210                 break;
 211
 212         case EV6_CPU:
 213         case EV67_CPU:
 214         default:
 215                 on_chip_cache = 64 + 64;
 216                 break;
 217         }
 218
 219         freq = hwrpb->cycle_freq ? : est_cycle_freq;
 220
 221         cacheflush_time = (freq / 1000000) * (on_chip_cache << 10) / bandwidth;
 222         cache_decay_ticks = cacheflush_time / (freq / 1000) * HZ / 1000;
 223
 224         printk("per-CPU timeslice cutoff: %ld.%02ld usecs.\n",
 225                cacheflush_time/(freq/1000000),
 226                (cacheflush_time*100/(freq/1000000)) % 100);
 227         printk("task migration cache decay timeout: %ld msecs.\n",
 228                (cache_decay_ticks + 1) * 1000 / HZ);
 229 }
 230
 231 /* Wait until hwrpb->txrdy is clear for cpu.  Return -1 on timeout.  */
 232 static int __init
 233 wait_for_txrdy (unsigned long cpumask)
 234 {
 235         unsigned long timeout;
 236
 237         if (!(hwrpb->txrdy & cpumask))
 238                 return 0;
 239
 240         timeout = jiffies + 10*HZ;
 241         while (time_before(jiffies, timeout)) {
 242                 if (!(hwrpb->txrdy & cpumask))
 243                         return 0;
 244                 udelay(10);
 245                 barrier();
 246         }
 247
 248         return -1;
 249 }
 250
 251 /*
 252  * Send a message to a secondary's console.  "START" is one such
 253  * interesting message.  ;-)
 254  */
 255 static void __init
 256 send_secondary_console_msg(char *str, int cpuid)
 257 {
 258         struct percpu_struct *cpu;
 259         register char *cp1, *cp2;
 260         unsigned long cpumask;
 261         size_t len;
 262
 263         cpu = (struct percpu_struct *)
 264                 ((char*)hwrpb
 265                  + hwrpb->processor_offset
 266                  + cpuid * hwrpb->processor_size);
 267
 268         cpumask = (1UL << cpuid);
 269         if (wait_for_txrdy(cpumask))
 270                 goto timeout;
 271
 272         cp2 = str;
 273         len = strlen(cp2);
 274         *(unsigned int *)&cpu->ipc_buffer[0] = len;
 275         cp1 = (char *) &cpu->ipc_buffer[1];
 276         memcpy(cp1, cp2, len);
 277
 278         /* atomic test and set */
 279         wmb();
 280         set_bit(cpuid, &hwrpb->rxrdy);
 281
 282         if (wait_for_txrdy(cpumask))
 283                 goto timeout;
 284         return;
 285
 286  timeout:
 287         printk("Processor %x not ready\n", cpuid);
 288 }
 289
 290 /*
 291  * A secondary console wants to send a message.  Receive it.
 292  */
 293 static void
 294 recv_secondary_console_msg(void)
 295 {
 296         int mycpu, i, cnt;
 297         unsigned long txrdy = hwrpb->txrdy;
 298         char *cp1, *cp2, buf[80];
 299         struct percpu_struct *cpu;
 300
 301         DBGS(("recv_secondary_console_msg: TXRDY 0x%lx.\n", txrdy));
 302
 303         mycpu = hard_smp_processor_id();
 304
 305         for (i = 0; i < NR_CPUS; i++) {
 306                 if (!(txrdy & (1UL << i)))
 307                         continue;
 308
 309                 DBGS(("recv_secondary_console_msg: "
 310                       "TXRDY contains CPU %d.\n", i));
 311
 312                 cpu = (struct percpu_struct *)
 313                   ((char*)hwrpb
 314                    + hwrpb->processor_offset
 315                    + i * hwrpb->processor_size);
 316
 317                 DBGS(("recv_secondary_console_msg: on %d from %d"
 318                       " HALT_REASON 0x%lx FLAGS 0x%lx\n",
 319                       mycpu, i, cpu->halt_reason, cpu->flags));
 320
 321                 cnt = cpu->ipc_buffer[0] >> 32;
 322                 if (cnt <= 0 || cnt >= 80)
 323                         strcpy(buf, "<<< BOGUS MSG >>>");
 324                 else {
 325                         cp1 = (char *) &cpu->ipc_buffer[11];
 326                         cp2 = buf;
 327                         strcpy(cp2, cp1);
 328
 329                         while ((cp2 = strchr(cp2, '\r')) != 0) {
 330                                 *cp2 = ' ';
 331                                 if (cp2[1] == '\n')
 332                                         cp2[1] = ' ';
 333                         }
 334                 }
 335
 336                 DBGS((KERN_INFO "recv_secondary_console_msg: on %d "
 337                       "message is '%s'\n", mycpu, buf));
 338         }
 339
 340         hwrpb->txrdy = 0;
 341 }
 342
 343 /*
 344  * Convince the console to have a secondary cpu begin execution.
 345  */
 346 static int __init
 347 secondary_cpu_start(int cpuid, struct task_struct *idle)
 348 {
 349         struct percpu_struct *cpu;
 350         struct pcb_struct *hwpcb, *ipcb;
 351         unsigned long timeout;
 352
 353         cpu = (struct percpu_struct *)
 354                 ((char*)hwrpb
 355                  + hwrpb->processor_offset
 356                  + cpuid * hwrpb->processor_size);
 357         hwpcb = (struct pcb_struct *) cpu->hwpcb;
 358         ipcb = &idle->thread_info->pcb;
 359
 360         /* Initialize the CPU's HWPCB to something just good enough for
 361            us to get started.  Immediately after starting, we'll swpctx
 362            to the target idle task's pcb.  Reuse the stack in the mean
 363            time.  Precalculate the target PCBB.  */
 364         hwpcb->ksp = (unsigned long)ipcb + sizeof(union thread_union) - 16;
 365         hwpcb->usp = 0;
 366         hwpcb->ptbr = ipcb->ptbr;
 367         hwpcb->pcc = 0;
 368         hwpcb->asn = 0;
 369         hwpcb->unique = virt_to_phys(ipcb);
 370         hwpcb->flags = ipcb->flags;
 371         hwpcb->res1 = hwpcb->res2 = 0;
 372
 373 #if 0
 374         DBGS(("KSP 0x%lx PTBR 0x%lx VPTBR 0x%lx UNIQUE 0x%lx\n",
 375               hwpcb->ksp, hwpcb->ptbr, hwrpb->vptb, hwpcb->unique));
 376 #endif
 377         DBGS(("Starting secondary cpu %d: state 0x%lx pal_flags 0x%lx\n",
 378               cpuid, idle->state, ipcb->flags));
 379
 380         /* Setup HWRPB fields that SRM uses to activate secondary CPU */
 381         hwrpb->CPU_restart = __smp_callin;
 382         hwrpb->CPU_restart_data = (unsigned long) __smp_callin;
 383
 384         /* Recalculate and update the HWRPB checksum */
 385         hwrpb_update_checksum(hwrpb);
 386
 387         /*
 388          * Send a "start" command to the specified processor.
 389          */
 390
 391         /* SRM III 3.4.1.3 */
 392         cpu->flags |= 0x22;     /* turn on Context Valid and Restart Capable */
 393         cpu->flags &= ~1;       /* turn off Bootstrap In Progress */
 394         wmb();
 395
 396         send_secondary_console_msg("START\r\n", cpuid);
 397
 398         /* Wait 10 seconds for an ACK from the console.  */
 399         timeout = jiffies + 10*HZ;
 400         while (time_before(jiffies, timeout)) {
 401                 if (cpu->flags & 1)
 402                         goto started;
 403                 udelay(10);
 404                 barrier();
 405         }
 406         printk(KERN_ERR "SMP: Processor %d failed to start.\n", cpuid);
 407         return -1;
 408
 409  started:
 410         DBGS(("secondary_cpu_start: SUCCESS for CPU %d!!!\n", cpuid));
 411         return 0;
 412 }
 413
 414 static struct task_struct * __init
 415 fork_by_hand(void)
 416 {
 417         /* Don't care about the contents of regs since we'll never
 418            reschedule the forked task. */
 419         struct pt_regs regs;
 420         return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
 421 }
 422
 423 /*
 424  * Bring one cpu online.
 425  */
 426 static int __init
 427 smp_boot_one_cpu(int cpuid)
 428 {
 429         struct task_struct *idle;
 430         unsigned long timeout;
 431
 432         /* Cook up an idler for this guy.  Note that the address we
 433            give to kernel_thread is irrelevant -- it's going to start
 434            where HWRPB.CPU_restart says to start.  But this gets all
 435            the other task-y sort of data structures set up like we
 436            wish.  We can't use kernel_thread since we must avoid
 437            rescheduling the child.  */
 438         idle = fork_by_hand();
 439         if (IS_ERR(idle))
 440                 panic("failed fork for CPU %d", cpuid);
 441
 442         wake_up_forked_process(idle);
 443
 444         init_idle(idle, cpuid);
 445         unhash_process(idle);
 446
 447         DBGS(("smp_boot_one_cpu: CPU %d state 0x%lx flags 0x%lx\n",
 448               cpuid, idle->state, idle->flags));
 449
 450         /* Signal the secondary to wait a moment.  */
 451         smp_secondary_alive = -1;
 452
 453         /* Whirrr, whirrr, whirrrrrrrrr... */
 454         if (secondary_cpu_start(cpuid, idle))
 455                 return -1;
 456
 457         /* Notify the secondary CPU it can run calibrate_delay.  */
 458         mb();
 459         smp_secondary_alive = 0;
 460
 461         /* We've been acked by the console; wait one second for
 462            the task to start up for real.  */
 463         timeout = jiffies + 1*HZ;
 464         while (time_before(jiffies, timeout)) {
 465                 if (smp_secondary_alive == 1)
 466                         goto alive;
 467                 udelay(10);
 468                 barrier();
 469         }
 470
 471         /* We failed to boot the CPU.  */
 472
 473         printk(KERN_ERR "SMP: Processor %d is stuck.\n", cpuid);
 474         return -1;
 475
 476  alive:
 477         /* Another "Red Snapper". */
 478         return 0;
 479 }
 480
 481 /*
 482  * Called from setup_arch.  Detect an SMP system and which processors
 483  * are present.
 484  */
 485 void __init
 486 setup_smp(void)
 487 {
 488         struct percpu_struct *cpubase, *cpu;
 489         unsigned long i;
 490
 491         if (boot_cpuid != 0) {
 492                 printk(KERN_WARNING "SMP: Booting off cpu %d instead of 0?\n",
 493                        boot_cpuid);
 494         }
 495
 496         if (hwrpb->nr_processors > 1) {
 497                 int boot_cpu_palrev;
 498
 499                 DBGS(("setup_smp: nr_processors %ld\n",
 500                       hwrpb->nr_processors));
 501
 502                 cpubase = (struct percpu_struct *)
 503                         ((char*)hwrpb + hwrpb->processor_offset);
 504                 boot_cpu_palrev = cpubase->pal_revision;
 505
 506                 for (i = 0; i < hwrpb->nr_processors; i++) {
 507                         cpu = (struct percpu_struct *)
 508                                 ((char *)cpubase + i*hwrpb->processor_size);
 509                         if ((cpu->flags & 0x1cc) == 0x1cc) {
 510                                 smp_num_probed++;
 511                                 /* Assume here that "whami" == index */
 512                                 hwrpb_cpu_present_mask |= (1UL << i);
 513                                 cpu->pal_revision = boot_cpu_palrev;
 514                         }
 515
 516                         DBGS(("setup_smp: CPU %d: flags 0x%lx type 0x%lx\n",
 517                               i, cpu->flags, cpu->type));
 518                         DBGS(("setup_smp: CPU %d: PAL rev 0x%lx\n",
 519                               i, cpu->pal_revision));
 520                 }
 521         } else {
 522                 smp_num_probed = 1;
 523                 hwrpb_cpu_present_mask = (1UL << boot_cpuid);
 524         }
 525         cpu_present_mask = 1UL << boot_cpuid;
 526
 527         printk(KERN_INFO "SMP: %d CPUs probed -- cpu_present_mask = %lx\n",
 528                smp_num_probed, hwrpb_cpu_present_mask);
 529 }
 530
 531 /*
 532  * Called by smp_init prepare the secondaries
 533  */
 534 void __init
 535 smp_prepare_cpus(unsigned int max_cpus)
 536 {
 537         int cpu_count, i;
 538
 539         /* Take care of some initial bookkeeping.  */
 540         memset(ipi_data, 0, sizeof(ipi_data));
 541
 542         current_thread_info()->cpu = boot_cpuid;
 543
 544         smp_store_cpu_info(boot_cpuid);
 545         smp_tune_scheduling(boot_cpuid);
 546         smp_setup_percpu_timer(boot_cpuid);
 547
 548         /* Nothing to do on a UP box, or when told not to.  */
 549         if (smp_num_probed == 1 || max_cpus == 0) {
 550                 cpu_present_mask = 1UL << boot_cpuid;
 551                 printk(KERN_INFO "SMP mode deactivated.\n");
 552                 return;
 553         }
 554
 555         printk(KERN_INFO "SMP starting up secondaries.\n");
 556
 557         cpu_count = 1;
 558         for (i = 0; (i < NR_CPUS) && (cpu_count < max_cpus); i++) {
 559                 if (i == boot_cpuid)
 560                         continue;
 561
 562                 if (((hwrpb_cpu_present_mask >> i) & 1) == 0)
 563                         continue;
 564
 565                 cpu_present_mask |= 1UL << i;
 566                 cpu_count++;
 567         }
 568
 569         smp_num_cpus = cpu_count;
 570 }
 571
 572 void __devinit
 573 smp_prepare_boot_cpu(void)
 574 {
 575         /*
 576          * Mark the boot cpu (current cpu) as both present and online
 577          */
 578         cpu_set(smp_processor_id(), cpu_present_mask);
 579         cpu_set(smp_processor_id(), cpu_online_map);
 580 }
 581
 582 int __devinit
 583 __cpu_up(unsigned int cpu)
 584 {
 585         smp_boot_one_cpu(cpu);
 586
 587         return cpu_online(cpu) ? 0 : -ENOSYS;
 588 }
 589
 590 void __init
 591 smp_cpus_done(unsigned int max_cpus)
 592 {
 593         int cpu;
 594         unsigned long bogosum = 0;
 595
 596         for(cpu = 0; cpu < NR_CPUS; cpu++)
 597                 if (cpu_online(cpu))
 598                         bogosum += cpu_data[cpu].loops_per_jiffy;
 599
 600         printk(KERN_INFO "SMP: Total of %ld processors activated "
 601                "(%lu.%02lu BogoMIPS).\n",
 602                num_online_cpus(),
 603                (bogosum + 2500) / (500000/HZ),
 604                ((bogosum + 2500) / (5000/HZ)) % 100);
 605 }
 606
 607 \f
 608 void
 609 smp_percpu_timer_interrupt(struct pt_regs *regs)
 610 {
 611         int cpu = smp_processor_id();
 612         unsigned long user = user_mode(regs);
 613         struct cpuinfo_alpha *data = &cpu_data[cpu];
 614
 615         /* Record kernel PC.  */
 616         if (!user)
 617                 alpha_do_profile(regs->pc);
 618
 619         if (!--data->prof_counter) {
 620                 /* We need to make like a normal interrupt -- otherwise
 621                    timer interrupts ignore the global interrupt lock,
 622                    which would be a Bad Thing.  */
 623                 irq_enter();
 624
 625                 update_process_times(user);
 626
 627                 data->prof_counter = data->prof_multiplier;
 628
 629                 irq_exit();
 630         }
 631 }
 632
 633 int __init
 634 setup_profiling_timer(unsigned int multiplier)
 635 {
 636         return -EINVAL;
 637 }
 638
 639 \f
 640 static void
 641 send_ipi_message(unsigned long to_whom, enum ipi_message_type operation)
 642 {
 643         unsigned long i, set, n;
 644
 645         mb();
 646         for (i = to_whom; i ; i &= ~set) {
 647                 set = i & -i;
 648                 n = __ffs(set);
 649                 set_bit(operation, &ipi_data[n].bits);
 650         }
 651
 652         mb();
 653         for (i = to_whom; i ; i &= ~set) {
 654                 set = i & -i;
 655                 n = __ffs(set);
 656                 wripir(n);
 657         }
 658 }
 659
 660 /* Structure and data for smp_call_function.  This is designed to
 661    minimize static memory requirements.  Plus it looks cleaner.  */
 662
 663 struct smp_call_struct {
 664         void (*func) (void *info);
 665         void *info;
 666         long wait;
 667         atomic_t unstarted_count;
 668         atomic_t unfinished_count;
 669 };
 670
 671 static struct smp_call_struct *smp_call_function_data;
 672
 673 /* Atomicly drop data into a shared pointer.  The pointer is free if
 674    it is initially locked.  If retry, spin until free.  */
 675
 676 static int
 677 pointer_lock (void *lock, void *data, int retry)
 678 {
 679         void *old, *tmp;
 680
 681         mb();
 682  again:
 683         /* Compare and swap with zero.  */
 684         asm volatile (
 685         "1:     ldq_l   %0,%1\n"
 686         "       mov     %3,%2\n"
 687         "       bne     %0,2f\n"
 688         "       stq_c   %2,%1\n"
 689         "       beq     %2,1b\n"
 690         "2:"
 691         : "=&r"(old), "=m"(*(void **)lock), "=&r"(tmp)
 692         : "r"(data)
 693         : "memory");
 694
 695         if (old == 0)
 696                 return 0;
 697         if (! retry)
 698                 return -EBUSY;
 699
 700         while (*(void **)lock)
 701                 barrier();
 702         goto again;
 703 }
 704
 705 void
 706 handle_ipi(struct pt_regs *regs)
 707 {
 708         int this_cpu = smp_processor_id();
 709         unsigned long *pending_ipis = &ipi_data[this_cpu].bits;
 710         unsigned long ops;
 711
 712 #if 0
 713         DBGS(("handle_ipi: on CPU %d ops 0x%lx PC 0x%lx\n",
 714               this_cpu, *pending_ipis, regs->pc));
 715 #endif
 716
 717         mb();   /* Order interrupt and bit testing. */
 718         while ((ops = xchg(pending_ipis, 0)) != 0) {
 719           mb(); /* Order bit clearing and data access. */
 720           do {
 721                 unsigned long which;
 722
 723                 which = ops & -ops;
 724                 ops &= ~which;
 725                 which = __ffs(which);
 726
 727                 switch (which) {
 728                 case IPI_RESCHEDULE:
 729                         /* Reschedule callback.  Everything to be done
 730                            is done by the interrupt return path.  */
 731                         break;
 732
 733                 case IPI_CALL_FUNC:
 734                     {
 735                         struct smp_call_struct *data;
 736                         void (*func)(void *info);
 737                         void *info;
 738                         int wait;
 739
 740                         data = smp_call_function_data;
 741                         func = data->func;
 742                         info = data->info;
 743                         wait = data->wait;
 744
 745                         /* Notify the sending CPU that the data has been
 746                            received, and execution is about to begin.  */
 747                         mb();
 748                         atomic_dec (&data->unstarted_count);
 749
 750                         /* At this point the structure may be gone unless
 751                            wait is true.  */
 752                         (*func)(info);
 753
 754                         /* Notify the sending CPU that the task is done.  */
 755                         mb();
 756                         if (wait) atomic_dec (&data->unfinished_count);
 757                         break;
 758                     }
 759
 760                 case IPI_CPU_STOP:
 761                         halt();
 762
 763                 default:
 764                         printk(KERN_CRIT "Unknown IPI on CPU %d: %lu\n",
 765                                this_cpu, which);
 766                         break;
 767                 }
 768           } while (ops);
 769
 770           mb(); /* Order data access and bit testing. */
 771         }
 772
 773         cpu_data[this_cpu].ipi_count++;
 774
 775         if (hwrpb->txrdy)
 776                 recv_secondary_console_msg();
 777 }
 778
 779 void
 780 smp_send_reschedule(int cpu)
 781 {
 782 #if DEBUG_IPI_MSG
 783         if (cpu == hard_smp_processor_id())
 784                 printk(KERN_WARNING
 785                        "smp_send_reschedule: Sending IPI to self.\n");
 786 #endif
 787         send_ipi_message(1UL << cpu, IPI_RESCHEDULE);
 788 }
 789
 790 void
 791 smp_send_stop(void)
 792 {
 793         unsigned long to_whom = cpu_present_mask & ~(1UL << smp_processor_id());
 794 #if DEBUG_IPI_MSG
 795         if (hard_smp_processor_id() != boot_cpu_id)
 796                 printk(KERN_WARNING "smp_send_stop: Not on boot cpu.\n");
 797 #endif
 798         send_ipi_message(to_whom, IPI_CPU_STOP);
 799 }
 800
 801 /*
 802  * Run a function on all other CPUs.
 803  *  <func>      The function to run. This must be fast and non-blocking.
 804  *  <info>      An arbitrary pointer to pass to the function.
 805  *  <retry>     If true, keep retrying until ready.
 806  *  <wait>      If true, wait until function has completed on other CPUs.
 807  *  [RETURNS]   0 on success, else a negative status code.
 808  *
 809  * Does not return until remote CPUs are nearly ready to execute <func>
 810  * or are or have executed.
 811  * You must not call this function with disabled interrupts or from a
 812  * hardware interrupt handler or from a bottom half handler.
 813  */
 814
 815 int
 816 smp_call_function_on_cpu (void (*func) (void *info), void *info, int retry,
 817                           int wait, unsigned long to_whom)
 818 {
 819         struct smp_call_struct data;
 820         unsigned long timeout;
 821         int num_cpus_to_call;
 822
 823         data.func = func;
 824         data.info = info;
 825         data.wait = wait;
 826
 827         to_whom &= ~(1L << smp_processor_id());
 828         num_cpus_to_call = hweight64(to_whom);
 829
 830         atomic_set(&data.unstarted_count, num_cpus_to_call);
 831         atomic_set(&data.unfinished_count, num_cpus_to_call);
 832
 833         /* Acquire the smp_call_function_data mutex.  */
 834         if (pointer_lock(&smp_call_function_data, &data, retry))
 835                 return -EBUSY;
 836
 837         /* Send a message to the requested CPUs.  */
 838         send_ipi_message(to_whom, IPI_CALL_FUNC);
 839
 840         /* Wait for a minimal response.  */
 841         timeout = jiffies + HZ;
 842         while (atomic_read (&data.unstarted_count) > 0
 843                && time_before (jiffies, timeout))
 844                 barrier();
 845
 846         /* If there's no response yet, log a message but allow a longer
 847          * timeout period -- if we get a response this time, log
 848          * a message saying when we got it..
 849          */
 850         if (atomic_read(&data.unstarted_count) > 0) {
 851                 long start_time = jiffies;
 852                 printk(KERN_ERR "%s: initial timeout -- trying long wait\n",
 853                        __FUNCTION__);
 854                 timeout = jiffies + 30 * HZ;
 855                 while (atomic_read(&data.unstarted_count) > 0
 856                        && time_before(jiffies, timeout))
 857                         barrier();
 858                 if (atomic_read(&data.unstarted_count) <= 0) {
 859                         long delta = jiffies - start_time;
 860                         printk(KERN_ERR
 861                                "%s: response %ld.%ld seconds into long wait\n",
 862                                __FUNCTION__, delta / HZ,
 863                                (100 * (delta - ((delta / HZ) * HZ))) / HZ);
 864                 }
 865         }
 866
 867         /* We either got one or timed out -- clear the lock. */
 868         mb();
 869         smp_call_function_data = 0;
 870
 871         /*
 872          * If after both the initial and long timeout periods we still don't
 873          * have a response, something is very wrong...
 874          */
 875         BUG_ON(atomic_read (&data.unstarted_count) > 0);
 876
 877         /* Wait for a complete response, if needed.  */
 878         if (wait) {
 879                 while (atomic_read (&data.unfinished_count) > 0)
 880                         barrier();
 881         }
 882
 883         return 0;
 884 }
 885
 886 int
 887 smp_call_function (void (*func) (void *info), void *info, int retry, int wait)
 888 {
 889         return smp_call_function_on_cpu (func, info, retry, wait,
 890                                          cpu_online_map);
 891 }
 892
 893 static void
 894 ipi_imb(void *ignored)
 895 {
 896         imb();
 897 }
 898
 899 void
 900 smp_imb(void)
 901 {
 902         /* Must wait other processors to flush their icache before continue. */
 903         if (on_each_cpu(ipi_imb, NULL, 1, 1))
 904                 printk(KERN_CRIT "smp_imb: timed out\n");
 905 }
 906
 907 static void
 908 ipi_flush_tlb_all(void *ignored)
 909 {
 910         tbia();
 911 }
 912
 913 void
 914 flush_tlb_all(void)
 915 {
 916         /* Although we don't have any data to pass, we do want to
 917            synchronize with the other processors.  */
 918         if (on_each_cpu(ipi_flush_tlb_all, NULL, 1, 1)) {
 919                 printk(KERN_CRIT "flush_tlb_all: timed out\n");
 920         }
 921 }
 922
 923 #define asn_locked() (cpu_data[smp_processor_id()].asn_lock)
 924
 925 static void
 926 ipi_flush_tlb_mm(void *x)
 927 {
 928         struct mm_struct *mm = (struct mm_struct *) x;
 929         if (mm == current->active_mm && !asn_locked())
 930                 flush_tlb_current(mm);
 931         else
 932                 flush_tlb_other(mm);
 933 }
 934
 935 void
 936 flush_tlb_mm(struct mm_struct *mm)
 937 {
 938         preempt_disable();
 939
 940         if (mm == current->active_mm) {
 941                 flush_tlb_current(mm);
 942                 if (atomic_read(&mm->mm_users) <= 1) {
 943                         int cpu, this_cpu = smp_processor_id();
 944                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
 945                                 if (!cpu_online(cpu) || cpu == this_cpu)
 946                                         continue;
 947                                 if (mm->context[cpu])
 948                                         mm->context[cpu] = 0;
 949                         }
 950                         preempt_enable();
 951                         return;
 952                 }
 953         }
 954
 955         if (smp_call_function(ipi_flush_tlb_mm, mm, 1, 1)) {
 956                 printk(KERN_CRIT "flush_tlb_mm: timed out\n");
 957         }
 958
 959         preempt_enable();
 960 }
 961
 962 struct flush_tlb_page_struct {
 963         struct vm_area_struct *vma;
 964         struct mm_struct *mm;
 965         unsigned long addr;
 966 };
 967
 968 static void
 969 ipi_flush_tlb_page(void *x)
 970 {
 971         struct flush_tlb_page_struct *data = (struct flush_tlb_page_struct *)x;
 972         struct mm_struct * mm = data->mm;
 973
 974         if (mm == current->active_mm && !asn_locked())
 975                 flush_tlb_current_page(mm, data->vma, data->addr);
 976         else
 977                 flush_tlb_other(mm);
 978 }
 979
 980 void
 981 flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
 982 {
 983         struct flush_tlb_page_struct data;
 984         struct mm_struct *mm = vma->vm_mm;
 985
 986         preempt_disable();
 987
 988         if (mm == current->active_mm) {
 989                 flush_tlb_current_page(mm, vma, addr);
 990                 if (atomic_read(&mm->mm_users) <= 1) {
 991                         int cpu, this_cpu = smp_processor_id();
 992                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
 993                                 if (!cpu_online(cpu) || cpu == this_cpu)
 994                                         continue;
 995                                 if (mm->context[cpu])
 996                                         mm->context[cpu] = 0;
 997                         }
 998                         preempt_enable();
 999                         return;
1000                 }
1001         }
1002
1003         data.vma = vma;
1004         data.mm = mm;
1005         data.addr = addr;
1006
1007         if (smp_call_function(ipi_flush_tlb_page, &data, 1, 1)) {
1008                 printk(KERN_CRIT "flush_tlb_page: timed out\n");
1009         }
1010
1011         preempt_enable();
1012 }
1013
1014 void
1015 flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
1016 {
1017         /* On the Alpha we always flush the whole user tlb.  */
1018         flush_tlb_mm(vma->vm_mm);
1019 }
1020
1021 static void
1022 ipi_flush_icache_page(void *x)
1023 {
1024         struct mm_struct *mm = (struct mm_struct *) x;
1025         if (mm == current->active_mm && !asn_locked())
1026                 __load_new_mm_context(mm);
1027         else
1028                 flush_tlb_other(mm);
1029 }
1030
1031 void
1032 flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
1033                         unsigned long addr, int len)
1034 {
1035         struct mm_struct *mm = vma->vm_mm;
1036
1037         if ((vma->vm_flags & VM_EXEC) == 0)
1038                 return;
1039
1040         preempt_disable();
1041
1042         if (mm == current->active_mm) {
1043                 __load_new_mm_context(mm);
1044                 if (atomic_read(&mm->mm_users) <= 1) {
1045                         int cpu, this_cpu = smp_processor_id();
1046                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
1047                                 if (!cpu_online(cpu) || cpu == this_cpu)
1048                                         continue;
1049                                 if (mm->context[cpu])
1050                                         mm->context[cpu] = 0;
1051                         }
1052                         preempt_enable();
1053                         return;
1054                 }
1055         }
1056
1057         if (smp_call_function(ipi_flush_icache_page, mm, 1, 1)) {
1058                 printk(KERN_CRIT "flush_icache_page: timed out\n");
1059         }
1060
1061         preempt_enable();
1062 }
1063 \f
1064 #ifdef CONFIG_DEBUG_SPINLOCK
1065 void
1066 _raw_spin_unlock(spinlock_t * lock)
1067 {
1068         mb();
1069         lock->lock = 0;
1070
1071         lock->on_cpu = -1;
1072         lock->previous = NULL;
1073         lock->task = NULL;
1074         lock->base_file = "none";
1075         lock->line_no = 0;
1076 }
1077
1078 void
1079 debug_spin_lock(spinlock_t * lock, const char *base_file, int line_no)
1080 {
1081         long tmp;
1082         long stuck;
1083         void *inline_pc = __builtin_return_address(0);
1084         unsigned long started = jiffies;
1085         int printed = 0;
1086         int cpu = smp_processor_id();
1087
1088         stuck = 1L << 30;
1089  try_again:
1090
1091         /* Use sub-sections to put the actual loop at the end
1092            of this object file's text section so as to perfect
1093            branch prediction.  */
1094         __asm__ __volatile__(
1095         "1:     ldl_l   %0,%1\n"
1096         "       subq    %2,1,%2\n"
1097         "       blbs    %0,2f\n"
1098         "       or      %0,1,%0\n"
1099         "       stl_c   %0,%1\n"
1100         "       beq     %0,3f\n"
1101         "4:     mb\n"
1102         ".subsection 2\n"
1103         "2:     ldl     %0,%1\n"
1104         "       subq    %2,1,%2\n"
1105         "3:     blt     %2,4b\n"
1106         "       blbs    %0,2b\n"
1107         "       br      1b\n"
1108         ".previous"
1109         : "=r" (tmp), "=m" (lock->lock), "=r" (stuck)
1110         : "1" (lock->lock), "2" (stuck) : "memory");
1111
1112         if (stuck < 0) {
1113                 printk(KERN_WARNING
1114                        "%s:%d spinlock stuck in %s at %p(%d)"
1115                        " owner %s at %p(%d) %s:%d\n",
1116                        base_file, line_no,
1117                        current->comm, inline_pc, cpu,
1118                        lock->task->comm, lock->previous,
1119                        lock->on_cpu, lock->base_file, lock->line_no);
1120                 stuck = 1L << 36;
1121                 printed = 1;
1122                 goto try_again;
1123         }
1124
1125         /* Exiting.  Got the lock.  */
1126         lock->on_cpu = cpu;
1127         lock->previous = inline_pc;
1128         lock->task = current;
1129         lock->base_file = base_file;
1130         lock->line_no = line_no;
1131
1132         if (printed) {
1133                 printk(KERN_WARNING
1134                        "%s:%d spinlock grabbed in %s at %p(%d) %ld ticks\n",
1135                        base_file, line_no, current->comm, inline_pc,
1136                        cpu, jiffies - started);
1137         }
1138 }
1139
1140 int
1141 debug_spin_trylock(spinlock_t * lock, const char *base_file, int line_no)
1142 {
1143         int ret;
1144         if ((ret = !test_and_set_bit(0, lock))) {
1145                 lock->on_cpu = smp_processor_id();
1146                 lock->previous = __builtin_return_address(0);
1147                 lock->task = current;
1148         } else {
1149                 lock->base_file = base_file;
1150                 lock->line_no = line_no;
1151         }
1152         return ret;
1153 }
1154 #endif /* CONFIG_DEBUG_SPINLOCK */
1155 \f
1156 #ifdef CONFIG_DEBUG_RWLOCK
1157 void _raw_write_lock(rwlock_t * lock)
1158 {
1159         long regx, regy;
1160         int stuck_lock, stuck_reader;
1161         void *inline_pc = __builtin_return_address(0);
1162
1163  try_again:
1164
1165         stuck_lock = 1<<30;
1166         stuck_reader = 1<<30;
1167
1168         __asm__ __volatile__(
1169         "1:     ldl_l   %1,%0\n"
1170         "       blbs    %1,6f\n"
1171         "       blt     %1,8f\n"
1172         "       mov     1,%1\n"
1173         "       stl_c   %1,%0\n"
1174         "       beq     %1,6f\n"
1175         "4:     mb\n"
1176         ".subsection 2\n"
1177         "6:     blt     %3,4b   # debug\n"
1178         "       subl    %3,1,%3 # debug\n"
1179         "       ldl     %1,%0\n"
1180         "       blbs    %1,6b\n"
1181         "8:     blt     %4,4b   # debug\n"
1182         "       subl    %4,1,%4 # debug\n"
1183         "       ldl     %1,%0\n"
1184         "       blt     %1,8b\n"
1185         "       br      1b\n"
1186         ".previous"
1187         : "=m" (*(volatile int *)lock), "=&r" (regx), "=&r" (regy),
1188           "=&r" (stuck_lock), "=&r" (stuck_reader)
1189         : "0" (*(volatile int *)lock), "3" (stuck_lock), "4" (stuck_reader) : "memory");
1190
1191         if (stuck_lock < 0) {
1192                 printk(KERN_WARNING "write_lock stuck at %p\n", inline_pc);
1193                 goto try_again;
1194         }
1195         if (stuck_reader < 0) {
1196                 printk(KERN_WARNING "write_lock stuck on readers at %p\n",
1197                        inline_pc);
1198                 goto try_again;
1199         }
1200 }
1201
1202 void _raw_read_lock(rwlock_t * lock)
1203 {
1204         long regx;
1205         int stuck_lock;
1206         void *inline_pc = __builtin_return_address(0);
1207
1208  try_again:
1209
1210         stuck_lock = 1<<30;
1211
1212         __asm__ __volatile__(
1213         "1:     ldl_l   %1,%0;"
1214         "       blbs    %1,6f;"
1215         "       subl    %1,2,%1;"
1216         "       stl_c   %1,%0;"
1217         "       beq     %1,6f;"
1218         "4:     mb\n"
1219         ".subsection 2\n"
1220         "6:     ldl     %1,%0;"
1221         "       blt     %2,4b   # debug\n"
1222         "       subl    %2,1,%2 # debug\n"
1223         "       blbs    %1,6b;"
1224         "       br      1b\n"
1225         ".previous"
1226         : "=m" (*(volatile int *)lock), "=&r" (regx), "=&r" (stuck_lock)
1227         : "0" (*(volatile int *)lock), "2" (stuck_lock) : "memory");
1228
1229         if (stuck_lock < 0) {
1230                 printk(KERN_WARNING "read_lock stuck at %p\n", inline_pc);
1231                 goto try_again;
1232         }
1233 }
1234 #endif /* CONFIG_DEBUG_RWLOCK */