~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/alpha/kernel/smp.c

Version: ~ [ linux-5.4-rc1 ] ~ [ linux-5.3.2 ] ~ [ linux-5.2.18 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.76 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.146 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.194 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.194 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.74 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/err.h>
 20 #include <linux/threads.h>
 21 #include <linux/smp.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 #include <linux/profile.h>
 29 #include <linux/bitops.h>
 30 #include <linux/cpu.h>
 31 
 32 #include <asm/hwrpb.h>
 33 #include <asm/ptrace.h>
 34 #include <linux/atomic.h>
 35 
 36 #include <asm/io.h>
 37 #include <asm/irq.h>
 38 #include <asm/pgtable.h>
 39 #include <asm/pgalloc.h>
 40 #include <asm/mmu_context.h>
 41 #include <asm/tlbflush.h>
 42 
 43 #include "proto.h"
 44 #include "irq_impl.h"
 45 
 46 
 47 #define DEBUG_SMP 0
 48 #if DEBUG_SMP
 49 #define DBGS(args)      printk args
 50 #else
 51 #define DBGS(args)
 52 #endif
 53 
 54 /* A collection of per-processor data.  */
 55 struct cpuinfo_alpha cpu_data[NR_CPUS];
 56 EXPORT_SYMBOL(cpu_data);
 57 
 58 /* A collection of single bit ipi messages.  */
 59 static struct {
 60         unsigned long bits ____cacheline_aligned;
 61 } ipi_data[NR_CPUS] __cacheline_aligned;
 62 
 63 enum ipi_message_type {
 64         IPI_RESCHEDULE,
 65         IPI_CALL_FUNC,
 66         IPI_CPU_STOP,
 67 };
 68 
 69 /* Set to a secondary's cpuid when it comes online.  */
 70 static int smp_secondary_alive = 0;
 71 
 72 int smp_num_probed;             /* Internal processor count */
 73 int smp_num_cpus = 1;           /* Number that came online.  */
 74 EXPORT_SYMBOL(smp_num_cpus);
 75 
 76 /*
 77  * Called by both boot and secondaries to move global data into
 78  *  per-processor storage.
 79  */
 80 static inline void __init
 81 smp_store_cpu_info(int cpuid)
 82 {
 83         cpu_data[cpuid].loops_per_jiffy = loops_per_jiffy;
 84         cpu_data[cpuid].last_asn = ASN_FIRST_VERSION;
 85         cpu_data[cpuid].need_new_asn = 0;
 86         cpu_data[cpuid].asn_lock = 0;
 87 }
 88 
 89 /*
 90  * Ideally sets up per-cpu profiling hooks.  Doesn't do much now...
 91  */
 92 static inline void __init
 93 smp_setup_percpu_timer(int cpuid)
 94 {
 95         cpu_data[cpuid].prof_counter = 1;
 96         cpu_data[cpuid].prof_multiplier = 1;
 97 }
 98 
 99 static void __init
100 wait_boot_cpu_to_stop(int cpuid)
101 {
102         unsigned long stop = jiffies + 10*HZ;
103 
104         while (time_before(jiffies, stop)) {
105                 if (!smp_secondary_alive)
106                         return;
107                 barrier();
108         }
109 
110         printk("wait_boot_cpu_to_stop: FAILED on CPU %d, hanging now\n", cpuid);
111         for (;;)
112                 barrier();
113 }
114 
115 /*
116  * Where secondaries begin a life of C.
117  */
118 void
119 smp_callin(void)
120 {
121         int cpuid = hard_smp_processor_id();
122 
123         if (cpu_online(cpuid)) {
124                 printk("??, cpu 0x%x already present??\n", cpuid);
125                 BUG();
126         }
127         set_cpu_online(cpuid, true);
128 
129         /* Turn on machine checks.  */
130         wrmces(7);
131 
132         /* Set trap vectors.  */
133         trap_init();
134 
135         /* Set interrupt vector.  */
136         wrent(entInt, 0);
137 
138         /* Get our local ticker going. */
139         smp_setup_percpu_timer(cpuid);
140         init_clockevent();
141 
142         /* Call platform-specific callin, if specified */
143         if (alpha_mv.smp_callin)
144                 alpha_mv.smp_callin();
145 
146         /* All kernel threads share the same mm context.  */
147         atomic_inc(&init_mm.mm_count);
148         current->active_mm = &init_mm;
149 
150         /* inform the notifiers about the new cpu */
151         notify_cpu_starting(cpuid);
152 
153         /* Must have completely accurate bogos.  */
154         local_irq_enable();
155 
156         /* Wait boot CPU to stop with irq enabled before running
157            calibrate_delay. */
158         wait_boot_cpu_to_stop(cpuid);
159         mb();
160         calibrate_delay();
161 
162         smp_store_cpu_info(cpuid);
163         /* Allow master to continue only after we written loops_per_jiffy.  */
164         wmb();
165         smp_secondary_alive = 1;
166 
167         DBGS(("smp_callin: commencing CPU %d current %p active_mm %p\n",
168               cpuid, current, current->active_mm));
169 
170         preempt_disable();
171         cpu_startup_entry(CPUHP_ONLINE);
172 }
173 
174 /* Wait until hwrpb->txrdy is clear for cpu.  Return -1 on timeout.  */
175 static int
176 wait_for_txrdy (unsigned long cpumask)
177 {
178         unsigned long timeout;
179 
180         if (!(hwrpb->txrdy & cpumask))
181                 return 0;
182 
183         timeout = jiffies + 10*HZ;
184         while (time_before(jiffies, timeout)) {
185                 if (!(hwrpb->txrdy & cpumask))
186                         return 0;
187                 udelay(10);
188                 barrier();
189         }
190 
191         return -1;
192 }
193 
194 /*
195  * Send a message to a secondary's console.  "START" is one such
196  * interesting message.  ;-)
197  */
198 static void
199 send_secondary_console_msg(char *str, int cpuid)
200 {
201         struct percpu_struct *cpu;
202         register char *cp1, *cp2;
203         unsigned long cpumask;
204         size_t len;
205 
206         cpu = (struct percpu_struct *)
207                 ((char*)hwrpb
208                  + hwrpb->processor_offset
209                  + cpuid * hwrpb->processor_size);
210 
211         cpumask = (1UL << cpuid);
212         if (wait_for_txrdy(cpumask))
213                 goto timeout;
214 
215         cp2 = str;
216         len = strlen(cp2);
217         *(unsigned int *)&cpu->ipc_buffer[0] = len;
218         cp1 = (char *) &cpu->ipc_buffer[1];
219         memcpy(cp1, cp2, len);
220 
221         /* atomic test and set */
222         wmb();
223         set_bit(cpuid, &hwrpb->rxrdy);
224 
225         if (wait_for_txrdy(cpumask))
226                 goto timeout;
227         return;
228 
229  timeout:
230         printk("Processor %x not ready\n", cpuid);
231 }
232 
233 /*
234  * A secondary console wants to send a message.  Receive it.
235  */
236 static void
237 recv_secondary_console_msg(void)
238 {
239         int mycpu, i, cnt;
240         unsigned long txrdy = hwrpb->txrdy;
241         char *cp1, *cp2, buf[80];
242         struct percpu_struct *cpu;
243 
244         DBGS(("recv_secondary_console_msg: TXRDY 0x%lx.\n", txrdy));
245 
246         mycpu = hard_smp_processor_id();
247 
248         for (i = 0; i < NR_CPUS; i++) {
249                 if (!(txrdy & (1UL << i)))
250                         continue;
251 
252                 DBGS(("recv_secondary_console_msg: "
253                       "TXRDY contains CPU %d.\n", i));
254 
255                 cpu = (struct percpu_struct *)
256                   ((char*)hwrpb
257                    + hwrpb->processor_offset
258                    + i * hwrpb->processor_size);
259 
260                 DBGS(("recv_secondary_console_msg: on %d from %d"
261                       " HALT_REASON 0x%lx FLAGS 0x%lx\n",
262                       mycpu, i, cpu->halt_reason, cpu->flags));
263 
264                 cnt = cpu->ipc_buffer[0] >> 32;
265                 if (cnt <= 0 || cnt >= 80)
266                         strcpy(buf, "<<< BOGUS MSG >>>");
267                 else {
268                         cp1 = (char *) &cpu->ipc_buffer[1];
269                         cp2 = buf;
270                         memcpy(cp2, cp1, cnt);
271                         cp2[cnt] = '\0';
272                         
273                         while ((cp2 = strchr(cp2, '\r')) != 0) {
274                                 *cp2 = ' ';
275                                 if (cp2[1] == '\n')
276                                         cp2[1] = ' ';
277                         }
278                 }
279 
280                 DBGS((KERN_INFO "recv_secondary_console_msg: on %d "
281                       "message is '%s'\n", mycpu, buf));
282         }
283 
284         hwrpb->txrdy = 0;
285 }
286 
287 /*
288  * Convince the console to have a secondary cpu begin execution.
289  */
290 static int
291 secondary_cpu_start(int cpuid, struct task_struct *idle)
292 {
293         struct percpu_struct *cpu;
294         struct pcb_struct *hwpcb, *ipcb;
295         unsigned long timeout;
296           
297         cpu = (struct percpu_struct *)
298                 ((char*)hwrpb
299                  + hwrpb->processor_offset
300                  + cpuid * hwrpb->processor_size);
301         hwpcb = (struct pcb_struct *) cpu->hwpcb;
302         ipcb = &task_thread_info(idle)->pcb;
303 
304         /* Initialize the CPU's HWPCB to something just good enough for
305            us to get started.  Immediately after starting, we'll swpctx
306            to the target idle task's pcb.  Reuse the stack in the mean
307            time.  Precalculate the target PCBB.  */
308         hwpcb->ksp = (unsigned long)ipcb + sizeof(union thread_union) - 16;
309         hwpcb->usp = 0;
310         hwpcb->ptbr = ipcb->ptbr;
311         hwpcb->pcc = 0;
312         hwpcb->asn = 0;
313         hwpcb->unique = virt_to_phys(ipcb);
314         hwpcb->flags = ipcb->flags;
315         hwpcb->res1 = hwpcb->res2 = 0;
316 
317 #if 0
318         DBGS(("KSP 0x%lx PTBR 0x%lx VPTBR 0x%lx UNIQUE 0x%lx\n",
319               hwpcb->ksp, hwpcb->ptbr, hwrpb->vptb, hwpcb->unique));
320 #endif
321         DBGS(("Starting secondary cpu %d: state 0x%lx pal_flags 0x%lx\n",
322               cpuid, idle->state, ipcb->flags));
323 
324         /* Setup HWRPB fields that SRM uses to activate secondary CPU */
325         hwrpb->CPU_restart = __smp_callin;
326         hwrpb->CPU_restart_data = (unsigned long) __smp_callin;
327 
328         /* Recalculate and update the HWRPB checksum */
329         hwrpb_update_checksum(hwrpb);
330 
331         /*
332          * Send a "start" command to the specified processor.
333          */
334 
335         /* SRM III 3.4.1.3 */
336         cpu->flags |= 0x22;     /* turn on Context Valid and Restart Capable */
337         cpu->flags &= ~1;       /* turn off Bootstrap In Progress */
338         wmb();
339 
340         send_secondary_console_msg("START\r\n", cpuid);
341 
342         /* Wait 10 seconds for an ACK from the console.  */
343         timeout = jiffies + 10*HZ;
344         while (time_before(jiffies, timeout)) {
345                 if (cpu->flags & 1)
346                         goto started;
347                 udelay(10);
348                 barrier();
349         }
350         printk(KERN_ERR "SMP: Processor %d failed to start.\n", cpuid);
351         return -1;
352 
353  started:
354         DBGS(("secondary_cpu_start: SUCCESS for CPU %d!!!\n", cpuid));
355         return 0;
356 }
357 
358 /*
359  * Bring one cpu online.
360  */
361 static int
362 smp_boot_one_cpu(int cpuid, struct task_struct *idle)
363 {
364         unsigned long timeout;
365 
366         /* Signal the secondary to wait a moment.  */
367         smp_secondary_alive = -1;
368 
369         /* Whirrr, whirrr, whirrrrrrrrr... */
370         if (secondary_cpu_start(cpuid, idle))
371                 return -1;
372 
373         /* Notify the secondary CPU it can run calibrate_delay.  */
374         mb();
375         smp_secondary_alive = 0;
376 
377         /* We've been acked by the console; wait one second for
378            the task to start up for real.  */
379         timeout = jiffies + 1*HZ;
380         while (time_before(jiffies, timeout)) {
381                 if (smp_secondary_alive == 1)
382                         goto alive;
383                 udelay(10);
384                 barrier();
385         }
386 
387         /* We failed to boot the CPU.  */
388 
389         printk(KERN_ERR "SMP: Processor %d is stuck.\n", cpuid);
390         return -1;
391 
392  alive:
393         /* Another "Red Snapper". */
394         return 0;
395 }
396 
397 /*
398  * Called from setup_arch.  Detect an SMP system and which processors
399  * are present.
400  */
401 void __init
402 setup_smp(void)
403 {
404         struct percpu_struct *cpubase, *cpu;
405         unsigned long i;
406 
407         if (boot_cpuid != 0) {
408                 printk(KERN_WARNING "SMP: Booting off cpu %d instead of 0?\n",
409                        boot_cpuid);
410         }
411 
412         if (hwrpb->nr_processors > 1) {
413                 int boot_cpu_palrev;
414 
415                 DBGS(("setup_smp: nr_processors %ld\n",
416                       hwrpb->nr_processors));
417 
418                 cpubase = (struct percpu_struct *)
419                         ((char*)hwrpb + hwrpb->processor_offset);
420                 boot_cpu_palrev = cpubase->pal_revision;
421 
422                 for (i = 0; i < hwrpb->nr_processors; i++) {
423                         cpu = (struct percpu_struct *)
424                                 ((char *)cpubase + i*hwrpb->processor_size);
425                         if ((cpu->flags & 0x1cc) == 0x1cc) {
426                                 smp_num_probed++;
427                                 set_cpu_possible(i, true);
428                                 set_cpu_present(i, true);
429                                 cpu->pal_revision = boot_cpu_palrev;
430                         }
431 
432                         DBGS(("setup_smp: CPU %d: flags 0x%lx type 0x%lx\n",
433                               i, cpu->flags, cpu->type));
434                         DBGS(("setup_smp: CPU %d: PAL rev 0x%lx\n",
435                               i, cpu->pal_revision));
436                 }
437         } else {
438                 smp_num_probed = 1;
439         }
440 
441         printk(KERN_INFO "SMP: %d CPUs probed -- cpu_present_mask = %lx\n",
442                smp_num_probed, cpumask_bits(cpu_present_mask)[0]);
443 }
444 
445 /*
446  * Called by smp_init prepare the secondaries
447  */
448 void __init
449 smp_prepare_cpus(unsigned int max_cpus)
450 {
451         /* Take care of some initial bookkeeping.  */
452         memset(ipi_data, 0, sizeof(ipi_data));
453 
454         current_thread_info()->cpu = boot_cpuid;
455 
456         smp_store_cpu_info(boot_cpuid);
457         smp_setup_percpu_timer(boot_cpuid);
458 
459         /* Nothing to do on a UP box, or when told not to.  */
460         if (smp_num_probed == 1 || max_cpus == 0) {
461                 init_cpu_possible(cpumask_of(boot_cpuid));
462                 init_cpu_present(cpumask_of(boot_cpuid));
463                 printk(KERN_INFO "SMP mode deactivated.\n");
464                 return;
465         }
466 
467         printk(KERN_INFO "SMP starting up secondaries.\n");
468 
469         smp_num_cpus = smp_num_probed;
470 }
471 
472 void
473 smp_prepare_boot_cpu(void)
474 {
475 }
476 
477 int
478 __cpu_up(unsigned int cpu, struct task_struct *tidle)
479 {
480         smp_boot_one_cpu(cpu, tidle);
481 
482         return cpu_online(cpu) ? 0 : -ENOSYS;
483 }
484 
485 void __init
486 smp_cpus_done(unsigned int max_cpus)
487 {
488         int cpu;
489         unsigned long bogosum = 0;
490 
491         for(cpu = 0; cpu < NR_CPUS; cpu++) 
492                 if (cpu_online(cpu))
493                         bogosum += cpu_data[cpu].loops_per_jiffy;
494         
495         printk(KERN_INFO "SMP: Total of %d processors activated "
496                "(%lu.%02lu BogoMIPS).\n",
497                num_online_cpus(), 
498                (bogosum + 2500) / (500000/HZ),
499                ((bogosum + 2500) / (5000/HZ)) % 100);
500 }
501 
502 int
503 setup_profiling_timer(unsigned int multiplier)
504 {
505         return -EINVAL;
506 }
507 
508 static void
509 send_ipi_message(const struct cpumask *to_whom, enum ipi_message_type operation)
510 {
511         int i;
512 
513         mb();
514         for_each_cpu(i, to_whom)
515                 set_bit(operation, &ipi_data[i].bits);
516 
517         mb();
518         for_each_cpu(i, to_whom)
519                 wripir(i);
520 }
521 
522 void
523 handle_ipi(struct pt_regs *regs)
524 {
525         int this_cpu = smp_processor_id();
526         unsigned long *pending_ipis = &ipi_data[this_cpu].bits;
527         unsigned long ops;
528 
529 #if 0
530         DBGS(("handle_ipi: on CPU %d ops 0x%lx PC 0x%lx\n",
531               this_cpu, *pending_ipis, regs->pc));
532 #endif
533 
534         mb();   /* Order interrupt and bit testing. */
535         while ((ops = xchg(pending_ipis, 0)) != 0) {
536           mb(); /* Order bit clearing and data access. */
537           do {
538                 unsigned long which;
539 
540                 which = ops & -ops;
541                 ops &= ~which;
542                 which = __ffs(which);
543 
544                 switch (which) {
545                 case IPI_RESCHEDULE:
546                         scheduler_ipi();
547                         break;
548 
549                 case IPI_CALL_FUNC:
550                         generic_smp_call_function_interrupt();
551                         break;
552 
553                 case IPI_CPU_STOP:
554                         halt();
555 
556                 default:
557                         printk(KERN_CRIT "Unknown IPI on CPU %d: %lu\n",
558                                this_cpu, which);
559                         break;
560                 }
561           } while (ops);
562 
563           mb(); /* Order data access and bit testing. */
564         }
565 
566         cpu_data[this_cpu].ipi_count++;
567 
568         if (hwrpb->txrdy)
569                 recv_secondary_console_msg();
570 }
571 
572 void
573 smp_send_reschedule(int cpu)
574 {
575 #ifdef DEBUG_IPI_MSG
576         if (cpu == hard_smp_processor_id())
577                 printk(KERN_WARNING
578                        "smp_send_reschedule: Sending IPI to self.\n");
579 #endif
580         send_ipi_message(cpumask_of(cpu), IPI_RESCHEDULE);
581 }
582 
583 void
584 smp_send_stop(void)
585 {
586         cpumask_t to_whom;
587         cpumask_copy(&to_whom, cpu_possible_mask);
588         cpumask_clear_cpu(smp_processor_id(), &to_whom);
589 #ifdef DEBUG_IPI_MSG
590         if (hard_smp_processor_id() != boot_cpu_id)
591                 printk(KERN_WARNING "smp_send_stop: Not on boot cpu.\n");
592 #endif
593         send_ipi_message(&to_whom, IPI_CPU_STOP);
594 }
595 
596 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
597 {
598         send_ipi_message(mask, IPI_CALL_FUNC);
599 }
600 
601 void arch_send_call_function_single_ipi(int cpu)
602 {
603         send_ipi_message(cpumask_of(cpu), IPI_CALL_FUNC);
604 }
605 
606 static void
607 ipi_imb(void *ignored)
608 {
609         imb();
610 }
611 
612 void
613 smp_imb(void)
614 {
615         /* Must wait other processors to flush their icache before continue. */
616         if (on_each_cpu(ipi_imb, NULL, 1))
617                 printk(KERN_CRIT "smp_imb: timed out\n");
618 }
619 EXPORT_SYMBOL(smp_imb);
620 
621 static void
622 ipi_flush_tlb_all(void *ignored)
623 {
624         tbia();
625 }
626 
627 void
628 flush_tlb_all(void)
629 {
630         /* Although we don't have any data to pass, we do want to
631            synchronize with the other processors.  */
632         if (on_each_cpu(ipi_flush_tlb_all, NULL, 1)) {
633                 printk(KERN_CRIT "flush_tlb_all: timed out\n");
634         }
635 }
636 
637 #define asn_locked() (cpu_data[smp_processor_id()].asn_lock)
638 
639 static void
640 ipi_flush_tlb_mm(void *x)
641 {
642         struct mm_struct *mm = (struct mm_struct *) x;
643         if (mm == current->active_mm && !asn_locked())
644                 flush_tlb_current(mm);
645         else
646                 flush_tlb_other(mm);
647 }
648 
649 void
650 flush_tlb_mm(struct mm_struct *mm)
651 {
652         preempt_disable();
653 
654         if (mm == current->active_mm) {
655                 flush_tlb_current(mm);
656                 if (atomic_read(&mm->mm_users) <= 1) {
657                         int cpu, this_cpu = smp_processor_id();
658                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
659                                 if (!cpu_online(cpu) || cpu == this_cpu)
660                                         continue;
661                                 if (mm->context[cpu])
662                                         mm->context[cpu] = 0;
663                         }
664                         preempt_enable();
665                         return;
666                 }
667         }
668 
669         if (smp_call_function(ipi_flush_tlb_mm, mm, 1)) {
670                 printk(KERN_CRIT "flush_tlb_mm: timed out\n");
671         }
672 
673         preempt_enable();
674 }
675 EXPORT_SYMBOL(flush_tlb_mm);
676 
677 struct flush_tlb_page_struct {
678         struct vm_area_struct *vma;
679         struct mm_struct *mm;
680         unsigned long addr;
681 };
682 
683 static void
684 ipi_flush_tlb_page(void *x)
685 {
686         struct flush_tlb_page_struct *data = (struct flush_tlb_page_struct *)x;
687         struct mm_struct * mm = data->mm;
688 
689         if (mm == current->active_mm && !asn_locked())
690                 flush_tlb_current_page(mm, data->vma, data->addr);
691         else
692                 flush_tlb_other(mm);
693 }
694 
695 void
696 flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
697 {
698         struct flush_tlb_page_struct data;
699         struct mm_struct *mm = vma->vm_mm;
700 
701         preempt_disable();
702 
703         if (mm == current->active_mm) {
704                 flush_tlb_current_page(mm, vma, addr);
705                 if (atomic_read(&mm->mm_users) <= 1) {
706                         int cpu, this_cpu = smp_processor_id();
707                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
708                                 if (!cpu_online(cpu) || cpu == this_cpu)
709                                         continue;
710                                 if (mm->context[cpu])
711                                         mm->context[cpu] = 0;
712                         }
713                         preempt_enable();
714                         return;
715                 }
716         }
717 
718         data.vma = vma;
719         data.mm = mm;
720         data.addr = addr;
721 
722         if (smp_call_function(ipi_flush_tlb_page, &data, 1)) {
723                 printk(KERN_CRIT "flush_tlb_page: timed out\n");
724         }
725 
726         preempt_enable();
727 }
728 EXPORT_SYMBOL(flush_tlb_page);
729 
730 void
731 flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
732 {
733         /* On the Alpha we always flush the whole user tlb.  */
734         flush_tlb_mm(vma->vm_mm);
735 }
736 EXPORT_SYMBOL(flush_tlb_range);
737 
738 static void
739 ipi_flush_icache_page(void *x)
740 {
741         struct mm_struct *mm = (struct mm_struct *) x;
742         if (mm == current->active_mm && !asn_locked())
743                 __load_new_mm_context(mm);
744         else
745                 flush_tlb_other(mm);
746 }
747 
748 void
749 flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
750                         unsigned long addr, int len)
751 {
752         struct mm_struct *mm = vma->vm_mm;
753 
754         if ((vma->vm_flags & VM_EXEC) == 0)
755                 return;
756 
757         preempt_disable();
758 
759         if (mm == current->active_mm) {
760                 __load_new_mm_context(mm);
761                 if (atomic_read(&mm->mm_users) <= 1) {
762                         int cpu, this_cpu = smp_processor_id();
763                         for (cpu = 0; cpu < NR_CPUS; cpu++) {
764                                 if (!cpu_online(cpu) || cpu == this_cpu)
765                                         continue;
766                                 if (mm->context[cpu])
767                                         mm->context[cpu] = 0;
768                         }
769                         preempt_enable();
770                         return;
771                 }
772         }
773 
774         if (smp_call_function(ipi_flush_icache_page, mm, 1)) {
775                 printk(KERN_CRIT "flush_icache_page: timed out\n");
776         }
777 
778         preempt_enable();
779 }
780 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp