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 cpumask_t 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 = cpumask_of_cpu(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 = cpumask_of_cpu(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_set(i, cpu_possible_map);
 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 %d 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(cpumask_t to_whom, enum ipi_message_type operation)
 642 {
 643         int i;
 644
 645         mb();
 646         for_each_cpu_mask(i, to_whom)
 647                 set_bit(operation, &ipi_data[i].bits);
 648
 649         mb();
 650         for_each_cpu_mask(i, to_whom)
 651                 wripir(i);
 652 }
 653
 654 /* Structure and data for smp_call_function.  This is designed to
 655    minimize static memory requirements.  Plus it looks cleaner.  */
 656
 657 struct smp_call_struct {
 658         void (*func) (void *info);
 659         void *info;
 660         long wait;
 661         atomic_t unstarted_count;
 662         atomic_t unfinished_count;
 663 };
 664
 665 static struct smp_call_struct *smp_call_function_data;
 666
 667 /* Atomicly drop data into a shared pointer.  The pointer is free if
 668    it is initially locked.  If retry, spin until free.  */
 669
 670 static int
 671 pointer_lock (void *lock, void *data, int retry)
 672 {
 673         void *old, *tmp;
 674
 675         mb();
 676  again:
 677         /* Compare and swap with zero.  */
 678         asm volatile (
 679         "1:     ldq_l   %0,%1\n"
 680         "       mov     %3,%2\n"
 681         "       bne     %0,2f\n"
 682         "       stq_c   %2,%1\n"
 683         "       beq     %2,1b\n"
 684         "2:"
 685         : "=&r"(old), "=m"(*(void **)lock), "=&r"(tmp)
 686         : "r"(data)
 687         : "memory");
 688
 689         if (old == 0)
 690                 return 0;
 691         if (! retry)
 692                 return -EBUSY;
 693
 694         while (*(void **)lock)
 695                 barrier();
 696         goto again;
 697 }
 698
 699 void
 700 handle_ipi(struct pt_regs *regs)
 701 {
 702         int this_cpu = smp_processor_id();
 703         unsigned long *pending_ipis = &ipi_data[this_cpu].bits;
 704         unsigned long ops;
 705
 706 #if 0
 707         DBGS(("handle_ipi: on CPU %d ops 0x%lx PC 0x%lx\n",
 708               this_cpu, *pending_ipis, regs->pc));
 709 #endif
 710
 711         mb();   /* Order interrupt and bit testing. */
 712         while ((ops = xchg(pending_ipis, 0)) != 0) {
 713           mb(); /* Order bit clearing and data access. */
 714           do {
 715                 unsigned long which;
 716
 717                 which = ops & -ops;
 718                 ops &= ~which;
 719                 which = __ffs(which);
 720
 721                 switch (which) {
 722                 case IPI_RESCHEDULE:
 723                         /* Reschedule callback.  Everything to be done
 724                            is done by the interrupt return path.  */
 725                         break;
 726
 727                 case IPI_CALL_FUNC:
 728                     {
 729                         struct smp_call_struct *data;
 730                         void (*func)(void *info);
 731                         void *info;
 732                         int wait;
 733
 734                         data = smp_call_function_data;
 735                         func = data->func;
 736                         info = data->info;
 737                         wait = data->wait;
 738
 739                         /* Notify the sending CPU that the data has been
 740                            received, and execution is about to begin.  */
 741                         mb();
 742                         atomic_dec (&data->unstarted_count);
 743
 744                         /* At this point the structure may be gone unless
 745                            wait is true.  */
 746                         (*func)(info);
 747
 748                         /* Notify the sending CPU that the task is done.  */
 749                         mb();
 750                         if (wait) atomic_dec (&data->unfinished_count);
 751                         break;
 752                     }
 753
 754                 case IPI_CPU_STOP:
 755                         halt();
 756
 757                 default:
 758                         printk(KERN_CRIT "Unknown IPI on CPU %d: %lu\n",
 759                                this_cpu, which);
 760                         break;
 761                 }
 762           } while (ops);
 763
 764           mb(); /* Order data access and bit testing. */
 765         }
 766
 767         cpu_data[this_cpu].ipi_count++;
 768
 769         if (hwrpb->txrdy)
 770                 recv_secondary_console_msg();
 771 }
 772
 773 void
 774 smp_send_reschedule(int cpu)
 775 {
 776 #ifdef DEBUG_IPI_MSG
 777         if (cpu == hard_smp_processor_id())
 778                 printk(KERN_WARNING
 779                        "smp_send_reschedule: Sending IPI to self.\n");
 780 #endif
 781         send_ipi_message(cpumask_of_cpu(cpu), IPI_RESCHEDULE);
 782 }
 783
 784 void
 785 smp_send_stop(void)
 786 {
 787         cpumask_t to_whom = cpu_possible_map;
 788         cpu_clear(smp_processor_id(), to_whom);
 789 #ifdef DEBUG_IPI_MSG
 790         if (hard_smp_processor_id() != boot_cpu_id)
 791                 printk(KERN_WARNING "smp_send_stop: Not on boot cpu.\n");
 792 #endif
 793         send_ipi_message(to_whom, IPI_CPU_STOP);
 794 }
 795
 796 /*
 797  * Run a function on all other CPUs.
 798  *  <func>      The function to run. This must be fast and non-blocking.
 799  *  <info>      An arbitrary pointer to pass to the function.
 800  *  <retry>     If true, keep retrying until ready.
 801  *  <wait>      If true, wait until function has completed on other CPUs.
 802  *  [RETURNS]   0 on success, else a negative status code.
 803  *
 804  * Does not return until remote CPUs are nearly ready to execute <func>
 805  * or are or have executed.
 806  * You must not call this function with disabled interrupts or from a
 807  * hardware interrupt handler or from a bottom half handler.
 808  */
 809
 810 int
 811 smp_call_function_on_cpu (void (*func) (void *info), void *info, int retry,
 812                           int wait, cpumask_t to_whom)
 813 {
 814         struct smp_call_struct data;
 815         unsigned long timeout;
 816         int num_cpus_to_call;
 817
 818         /* Can deadlock when called with interrupts disabled */
 819         WARN_ON(irqs_disabled());
 820
 821         data.func = func;
 822         data.info = info;
 823         data.wait = wait;
 824
 825         cpu_clear(smp_processor_id(), to_whom);
 826         num_cpus_to_call = cpus_weight(to_whom);
 827
 828         atomic_set(&data.unstarted_count, num_cpus_to_call);
 829         atomic_set(&data.unfinished_count, num_cpus_to_call);
 830
 831         /* Acquire the smp_call_function_data mutex.  */
 832         if (pointer_lock(&smp_call_function_data, &data, retry))
 833                 return -EBUSY;
 834
 835         /* Send a message to the requested CPUs.  */
 836         send_ipi_message(to_whom, IPI_CALL_FUNC);
 837
 838         /* Wait for a minimal response.  */
 839         timeout = jiffies + HZ;
 840         while (atomic_read (&data.unstarted_count) > 0
 841                && time_before (jiffies, timeout))
 842                 barrier();
 843
 844         /* If there's no response yet, log a message but allow a longer
 845          * timeout period -- if we get a response this time, log
 846          * a message saying when we got it..
 847          */
 848         if (atomic_read(&data.unstarted_count) > 0) {
 849                 long start_time = jiffies;
 850                 printk(KERN_ERR "%s: initial timeout -- trying long wait\n",
 851                        __FUNCTION__);
 852                 timeout = jiffies + 30 * HZ;
 853                 while (atomic_read(&data.unstarted_count) > 0
 854                        && time_before(jiffies, timeout))
 855                         barrier();
 856                 if (atomic_read(&data.unstarted_count) <= 0) {
 857                         long delta = jiffies - start_time;
 858                         printk(KERN_ERR
 859                                "%s: response %ld.%ld seconds into long wait\n",
 860                                __FUNCTION__, delta / HZ,
 861                                (100 * (delta - ((delta / HZ) * HZ))) / HZ);
 862                 }
 863         }
 864
 865         /* We either got one or timed out -- clear the lock. */
 866         mb();
 867         smp_call_function_data = NULL;
 868
 869         /*
 870          * If after both the initial and long timeout periods we still don't
 871          * have a response, something is very wrong...
 872          */
 873         BUG_ON(atomic_read (&data.unstarted_count) > 0);
 874
 875         /* Wait for a complete response, if needed.  */
 876         if (wait) {
 877                 while (atomic_read (&data.unfinished_count) > 0)
 878                         barrier();
 879         }
 880
 881         return 0;
 882 }
 883
 884 int
 885 smp_call_function (void (*func) (void *info), void *info, int retry, int wait)
 886 {
 887         return smp_call_function_on_cpu (func, info, retry, wait,
 888                                          cpu_online_map);
 889 }
 890
 891 static void
 892 ipi_imb(void *ignored)
 893 {
 894         imb();
 895 }
 896
 897 void
 898 smp_imb(void)
 899 {
 900         /* Must wait other processors to flush their icache before continue. */
 901         if (on_each_cpu(ipi_imb, NULL, 1, 1))
 902                 printk(KERN_CRIT "smp_imb: timed out\n");
 903 }
 904
 905 static void
 906 ipi_flush_tlb_all(void *ignored)
 907 {
 908         tbia();
 909 }
 910
 911 void
 912 flush_tlb_all(void)
 913 {
 914         /* Although we don't have any data to pass, we do want to
 915            synchronize with the other processors.  */
 916         if (on_each_cpu(ipi_flush_tlb_all, NULL, 1, 1)) {
 917                 printk(KERN_CRIT "flush_tlb_all: timed out\n");
 918         }
 919 }
 920
 921 #define asn_locked() (cpu_data[smp_processor_id()].asn_lock)
 922
 923 static void
 924 ipi_flush_tlb_mm(void *x)
 925 {
 926         struct mm_struct *mm = (struct mm_struct *) x;
 927         if (mm == current->active_mm && !asn_locked())
 928                 flush_tlb_current(mm);
 929         else
 930                 flush_tlb_other(mm);
 931 }
 932
 933 void
 934 flush_tlb_mm(struct mm_struct *mm)
 935 {
 936         preempt_disable();
 937
 938         if (mm == current->active_mm) {
 939                 flush_tlb_current(mm);
 940                 if (atomic_read(&mm->mm_users) <= 1) {
 941                         int cpu, this_cpu = smp_processor_id();
 942                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
 943                                 if (!cpu_online(cpu) || cpu == this_cpu)
 944                                         continue;
 945                                 if (mm->context[cpu])
 946                                         mm->context[cpu] = 0;
 947                         }
 948                         preempt_enable();
 949                         return;
 950                 }
 951         }
 952
 953         if (smp_call_function(ipi_flush_tlb_mm, mm, 1, 1)) {
 954                 printk(KERN_CRIT "flush_tlb_mm: timed out\n");
 955         }
 956
 957         preempt_enable();
 958 }
 959
 960 struct flush_tlb_page_struct {
 961         struct vm_area_struct *vma;
 962         struct mm_struct *mm;
 963         unsigned long addr;
 964 };
 965
 966 static void
 967 ipi_flush_tlb_page(void *x)
 968 {
 969         struct flush_tlb_page_struct *data = (struct flush_tlb_page_struct *)x;
 970         struct mm_struct * mm = data->mm;
 971
 972         if (mm == current->active_mm && !asn_locked())
 973                 flush_tlb_current_page(mm, data->vma, data->addr);
 974         else
 975                 flush_tlb_other(mm);
 976 }
 977
 978 void
 979 flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
 980 {
 981         struct flush_tlb_page_struct data;
 982         struct mm_struct *mm = vma->vm_mm;
 983
 984         preempt_disable();
 985
 986         if (mm == current->active_mm) {
 987                 flush_tlb_current_page(mm, vma, addr);
 988                 if (atomic_read(&mm->mm_users) <= 1) {
 989                         int cpu, this_cpu = smp_processor_id();
 990                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
 991                                 if (!cpu_online(cpu) || cpu == this_cpu)
 992                                         continue;
 993                                 if (mm->context[cpu])
 994                                         mm->context[cpu] = 0;
 995                         }
 996                         preempt_enable();
 997                         return;
 998                 }
 999         }
1000
1001         data.vma = vma;
1002         data.mm = mm;
1003         data.addr = addr;
1004
1005         if (smp_call_function(ipi_flush_tlb_page, &data, 1, 1)) {
1006                 printk(KERN_CRIT "flush_tlb_page: timed out\n");
1007         }
1008
1009         preempt_enable();
1010 }
1011
1012 void
1013 flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
1014 {
1015         /* On the Alpha we always flush the whole user tlb.  */
1016         flush_tlb_mm(vma->vm_mm);
1017 }
1018
1019 static void
1020 ipi_flush_icache_page(void *x)
1021 {
1022         struct mm_struct *mm = (struct mm_struct *) x;
1023         if (mm == current->active_mm && !asn_locked())
1024                 __load_new_mm_context(mm);
1025         else
1026                 flush_tlb_other(mm);
1027 }
1028
1029 void
1030 flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
1031                         unsigned long addr, int len)
1032 {
1033         struct mm_struct *mm = vma->vm_mm;
1034
1035         if ((vma->vm_flags & VM_EXEC) == 0)
1036                 return;
1037
1038         preempt_disable();
1039
1040         if (mm == current->active_mm) {
1041                 __load_new_mm_context(mm);
1042                 if (atomic_read(&mm->mm_users) <= 1) {
1043                         int cpu, this_cpu = smp_processor_id();
1044                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
1045                                 if (!cpu_online(cpu) || cpu == this_cpu)
1046                                         continue;
1047                                 if (mm->context[cpu])
1048                                         mm->context[cpu] = 0;
1049                         }
1050                         preempt_enable();
1051                         return;
1052                 }
1053         }
1054
1055         if (smp_call_function(ipi_flush_icache_page, mm, 1, 1)) {
1056                 printk(KERN_CRIT "flush_icache_page: timed out\n");
1057         }
1058
1059         preempt_enable();
1060 }
1061 \f
1062 #ifdef CONFIG_DEBUG_SPINLOCK
1063 void
1064 _raw_spin_unlock(spinlock_t * lock)
1065 {
1066         mb();
1067         lock->lock = 0;
1068
1069         lock->on_cpu = -1;
1070         lock->previous = NULL;
1071         lock->task = NULL;
1072         lock->base_file = "none";
1073         lock->line_no = 0;
1074 }
1075
1076 void
1077 debug_spin_lock(spinlock_t * lock, const char *base_file, int line_no)
1078 {
1079         long tmp;
1080         long stuck;
1081         void *inline_pc = __builtin_return_address(0);
1082         unsigned long started = jiffies;
1083         int printed = 0;
1084         int cpu = smp_processor_id();
1085
1086         stuck = 1L << 30;
1087  try_again:
1088
1089         /* Use sub-sections to put the actual loop at the end
1090            of this object file's text section so as to perfect
1091            branch prediction.  */
1092         __asm__ __volatile__(
1093         "1:     ldl_l   %0,%1\n"
1094         "       subq    %2,1,%2\n"
1095         "       blbs    %0,2f\n"
1096         "       or      %0,1,%0\n"
1097         "       stl_c   %0,%1\n"
1098         "       beq     %0,3f\n"
1099         "4:     mb\n"
1100         ".subsection 2\n"
1101         "2:     ldl     %0,%1\n"
1102         "       subq    %2,1,%2\n"
1103         "3:     blt     %2,4b\n"
1104         "       blbs    %0,2b\n"
1105         "       br      1b\n"
1106         ".previous"
1107         : "=r" (tmp), "=m" (lock->lock), "=r" (stuck)
1108         : "1" (lock->lock), "2" (stuck) : "memory");
1109
1110         if (stuck < 0) {
1111                 printk(KERN_WARNING
1112                        "%s:%d spinlock stuck in %s at %p(%d)"
1113                        " owner %s at %p(%d) %s:%d\n",
1114                        base_file, line_no,
1115                        current->comm, inline_pc, cpu,
1116                        lock->task->comm, lock->previous,
1117                        lock->on_cpu, lock->base_file, lock->line_no);
1118                 stuck = 1L << 36;
1119                 printed = 1;
1120                 goto try_again;
1121         }
1122
1123         /* Exiting.  Got the lock.  */
1124         lock->on_cpu = cpu;
1125         lock->previous = inline_pc;
1126         lock->task = current;
1127         lock->base_file = base_file;
1128         lock->line_no = line_no;
1129
1130         if (printed) {
1131                 printk(KERN_WARNING
1132                        "%s:%d spinlock grabbed in %s at %p(%d) %ld ticks\n",
1133                        base_file, line_no, current->comm, inline_pc,
1134                        cpu, jiffies - started);
1135         }
1136 }
1137
1138 int
1139 debug_spin_trylock(spinlock_t * lock, const char *base_file, int line_no)
1140 {
1141         int ret;
1142         if ((ret = !test_and_set_bit(0, lock))) {
1143                 lock->on_cpu = smp_processor_id();
1144                 lock->previous = __builtin_return_address(0);
1145                 lock->task = current;
1146         } else {
1147                 lock->base_file = base_file;
1148                 lock->line_no = line_no;
1149         }
1150         return ret;
1151 }
1152 #endif /* CONFIG_DEBUG_SPINLOCK */
1153 \f
1154 #ifdef CONFIG_DEBUG_RWLOCK
1155 void _raw_write_lock(rwlock_t * lock)
1156 {
1157         long regx, regy;
1158         int stuck_lock, stuck_reader;
1159         void *inline_pc = __builtin_return_address(0);
1160
1161  try_again:
1162
1163         stuck_lock = 1<<30;
1164         stuck_reader = 1<<30;
1165
1166         __asm__ __volatile__(
1167         "1:     ldl_l   %1,%0\n"
1168         "       blbs    %1,6f\n"
1169         "       blt     %1,8f\n"
1170         "       mov     1,%1\n"
1171         "       stl_c   %1,%0\n"
1172         "       beq     %1,6f\n"
1173         "4:     mb\n"
1174         ".subsection 2\n"
1175         "6:     blt     %3,4b   # debug\n"
1176         "       subl    %3,1,%3 # debug\n"
1177         "       ldl     %1,%0\n"
1178         "       blbs    %1,6b\n"
1179         "8:     blt     %4,4b   # debug\n"
1180         "       subl    %4,1,%4 # debug\n"
1181         "       ldl     %1,%0\n"
1182         "       blt     %1,8b\n"
1183         "       br      1b\n"
1184         ".previous"
1185         : "=m" (*(volatile int *)lock), "=&r" (regx), "=&r" (regy),
1186           "=&r" (stuck_lock), "=&r" (stuck_reader)
1187         : "0" (*(volatile int *)lock), "3" (stuck_lock), "4" (stuck_reader) : "memory");
1188
1189         if (stuck_lock < 0) {
1190                 printk(KERN_WARNING "write_lock stuck at %p\n", inline_pc);
1191                 goto try_again;
1192         }
1193         if (stuck_reader < 0) {
1194                 printk(KERN_WARNING "write_lock stuck on readers at %p\n",
1195                        inline_pc);
1196                 goto try_again;
1197         }
1198 }
1199
1200 void _raw_read_lock(rwlock_t * lock)
1201 {
1202         long regx;
1203         int stuck_lock;
1204         void *inline_pc = __builtin_return_address(0);
1205
1206  try_again:
1207
1208         stuck_lock = 1<<30;
1209
1210         __asm__ __volatile__(
1211         "1:     ldl_l   %1,%0;"
1212         "       blbs    %1,6f;"
1213         "       subl    %1,2,%1;"
1214         "       stl_c   %1,%0;"
1215         "       beq     %1,6f;"
1216         "4:     mb\n"
1217         ".subsection 2\n"
1218         "6:     ldl     %1,%0;"
1219         "       blt     %2,4b   # debug\n"
1220         "       subl    %2,1,%2 # debug\n"
1221         "       blbs    %1,6b;"
1222         "       br      1b\n"
1223         ".previous"
1224         : "=m" (*(volatile int *)lock), "=&r" (regx), "=&r" (stuck_lock)
1225         : "0" (*(volatile int *)lock), "2" (stuck_lock) : "memory");
1226
1227         if (stuck_lock < 0) {
1228                 printk(KERN_WARNING "read_lock stuck at %p\n", inline_pc);
1229                 goto try_again;
1230         }
1231 }
1232 #endif /* CONFIG_DEBUG_RWLOCK */