diff -uNrp linux-2.6.10/Documentation/adeos.txt linux-2.6.10-ppc-adeos/Documentation/adeos.txt --- linux-2.6.10/Documentation/adeos.txt 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/Documentation/adeos.txt 2004-11-24 12:33:17.000000000 +0100 @@ -0,0 +1,176 @@ + +The Adeos nanokernel is based on research and publications made in the +early '90s on the subject of nanokernels. Our basic method was to +reverse the approach described in most of the papers on the subject. +Instead of first building the nanokernel and then building the client +OSes, we started from a live and known-to-be-functional OS, Linux, and +inserted a nanokernel beneath it. Starting from Adeos, other client +OSes can now be put side-by-side with the Linux kernel. + +To this end, Adeos enables multiple domains to exist simultaneously on +the same hardware. None of these domains see each other, but all of +them see Adeos. A domain is most probably a complete OS, but there is +no assumption being made regarding the sophistication of what's in +a domain. + +To share the hardware among the different OSes, Adeos implements an +interrupt pipeline (ipipe). Every OS domain has an entry in the ipipe. +Each interrupt that comes in the ipipe is passed on to every domain +in the ipipe. Instead of disabling/enabling interrupts, each domain +in the pipeline only needs to stall/unstall his pipeline stage. If +an ipipe stage is stalled, then the interrupts do not progress in the +ipipe until that stage has been unstalled. Each stage of the ipipe +can, of course, decide to do a number of things with an interrupt. +Among other things, it can decide that it's the last recipient of the +interrupt. In that case, the ipipe does not propagate the interrupt +to the rest of the domains in the ipipe. + +Regardless of the operations being done in the ipipe, the Adeos code +does __not__ play with the interrupt masks. The only case where the +hardware masks are altered is during the addition/removal of a domain +from the ipipe. This also means that no OS is allowed to use the real +hardware cli/sti. But this is OK, since the stall/unstall calls +achieve the same functionality. + +Our approach is based on the following papers (links to these +papers are provided at the bottom of this message): +[1] D. Probert, J. Bruno, and M. Karzaorman. "Space: a new approach to +operating system abstraction." In: International Workshop on Object +Orientation in Operating Systems, pages 133-137, October 1991. +[2] D. Probert, J. Bruno. "Building fundamentally extensible application- +specific operating systems in Space", March 1995. +[3] D. Cheriton, K. Duda. "A caching model of operating system kernel +functionality". In: Proc. Symp. on Operating Systems Design and +Implementation, pages 179-194, Monterey CA (USA), 1994. +[4] D. Engler, M. Kaashoek, and J. O'Toole Jr. "Exokernel: an operating +system architecture for application-specific resource management", +December 1995. + +If you don't want to go fetch the complete papers, here's a summary. +The first 2 discuss the Space nanokernel, the 3rd discussed the cache +nanokernel, and the last discusses exokernel. + +The complete Adeos approach has been thoroughly documented in a whitepaper +published more than a year ago entitled "Adaptive Domain Environment +for Operating Systems" and available here: http://www.opersys.com/adeos +The current implementation is slightly different. Mainly, we do not +implement the functionality to move Linux out of ring 0. Although of +interest, this approach is not very portable. + +Instead, our patch taps right into Linux's main source of control +over the hardware, the interrupt dispatching code, and inserts an +interrupt pipeline which can then serve all the nanokernel's clients, +including Linux. + +This is not a novelty in itself. Other OSes have been modified in such +a way for a wide range of purposes. One of the most interesting +examples is described by Stodolsky, Chen, and Bershad in a paper +entitled "Fast Interrupt Priority Management in Operating System +Kernels" published in 1993 as part of the Usenix Microkernels and +Other Kernel Architectures Symposium. In that case, cli/sti were +replaced by virtual cli/sti which did not modify the real interrupt +mask in any way. Instead, interrupts were defered and delivered to +the OS upon a call to the virtualized sti. + +Mainly, this resulted in increased performance for the OS. Although +we haven't done any measurements on Linux's interrupt handling +performance with Adeos, our nanokernel includes by definition the +code implementing the technique described in the abovementioned +Stodolsky paper, which we use to redirect the hardware interrupt flow +to the pipeline. + +i386 and armnommu are currently supported. Most of the +architecture-dependent code is easily portable to other architectures. + +Aside of adding the Adeos module (driver/adeos), we also modified some +files to tap into Linux interrupt and system event dispatching (all +the modifications are encapsulated in #ifdef CONFIG_ADEOS_*/#endif). + +We modified the idle task so it gives control back to Adeos in order for +the ipipe to continue propagation. + +We modified init/main.c to initialize Adeos very early in the startup. + +Of course, we also added the appropriate makefile modifications and +config options so that you can choose to enable/disable Adeos as +part of the kernel build configuration. + +Adeos' public API is fully documented here: +http://www.freesoftware.fsf.org/adeos/doc/api/index.html. + +In Linux's case, adeos_register_domain() is called very early during +system startup. + +To add your domain to the ipipe, you need to: +1) Register your domain with Adeos using adeos_register_domain() +2) Call adeos_virtualize_irq() for all the IRQs you wish to be +notified about in the ipipe. + +That's it. Provided you gave Adeos appropriate handlers in step +#2, your interrupts will be delivered via the ipipe. + +During runtime, you may change your position in the ipipe using +adeos_renice_domain(). You may also stall/unstall the pipeline +and change the ipipe's handling of the interrupts according to your +needs. + +Adeos supports SMP, and APIC support on UP. + +Here are some of the possible uses for Adeos (this list is far +from complete): +1) Much like User-Mode Linux, it should now be possible to have 2 +Linux kernels living side-by-side on the same hardware. In contrast +to UML, this would not be 2 kernels one ontop of the other, but +really side-by-side. Since Linux can be told at boot time to use +only one portion of the available RAM, on a 128MB machine this +would mean that the first could be made to use the 0-64MB space and +the second would use the 64-128MB space. We realize that many +modifications are required. Among other things, one of the 2 kernels +will not need to conduct hardware initialization. Nevertheless, this +possibility should be studied closer. + +2) It follows from #1 that adding other kernels beside Linux should +be feasible. BSD is a prime candidate, but it would also be nice to +see what virtualizers such as VMWare and Plex86 could do with Adeos. +Proprietary operating systems could potentially also be accomodated. + +3) All the previous work that has been done on nanokernels should now +be easily ported to Linux. Mainly, we would be very interested to +hear about extensions to Adeos. Primarily, we have no mechanisms +currently enabling multiple domains to share information. The papers +mentioned earlier provide such mechanisms, but we'd like to see +actual practical examples. + +4) Kernel debuggers' main problem (tapping into the kernel's +interrupts) is solved and it should then be possible to provide +patchless kernel debuggers. They would then become loadable kernel +modules. + +5) Drivers who require absolute priority and dislike other kernel +portions who use cli/sti can now create a domain of their own +and place themselves before Linux in the ipipe. This provides a +mechanism for the implementation of systems that can provide guaranteed +realtime response. + +Philippe Gerum +Karim Yaghmour + +---------------------------------------------------------------------- +Links to papers: +1- +http://citeseer.nj.nec.com/probert91space.html +ftp://ftp.cs.ucsb.edu/pub/papers/space/iwooos91.ps.gz (not working) +http://www4.informatik.uni-erlangen.de/~tsthiel/Papers/Space-iwooos91.ps.gz + +2- +http://www.cs.ucsb.edu/research/trcs/abstracts/1995-06.shtml +http://www4.informatik.uni-erlangen.de/~tsthiel/Papers/Space-trcs95-06.ps.gz + +3- +http://citeseer.nj.nec.com/kenneth94caching.html +http://guir.cs.berkeley.edu/projects/osprelims/papers/cachmodel-OSkernel.ps.gz + +4- +http://citeseer.nj.nec.com/engler95exokernel.html +ftp://ftp.cag.lcs.mit.edu/multiscale/exokernel.ps.Z +---------------------------------------------------------------------- diff -uNrp linux-2.6.10/Makefile linux-2.6.10-ppc-adeos/Makefile --- linux-2.6.10/Makefile 2004-12-24 22:35:01.000000000 +0100 +++ linux-2.6.10-ppc-adeos/Makefile 2005-03-27 16:35:18.000000000 +0200 @@ -558,6 +558,8 @@ export MODLIB ifeq ($(KBUILD_EXTMOD),) core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ +core-$(CONFIG_ADEOS) += adeos/ + vmlinux-dirs := $(patsubst %/,%,$(filter %/, $(init-y) $(init-m) \ $(core-y) $(core-m) $(drivers-y) $(drivers-m) \ $(net-y) $(net-m) $(libs-y) $(libs-m))) diff -uNrp linux-2.6.10/adeos/Kconfig linux-2.6.10-ppc-adeos/adeos/Kconfig --- linux-2.6.10/adeos/Kconfig 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/adeos/Kconfig 2005-04-15 17:56:13.000000000 +0200 @@ -0,0 +1,40 @@ +menu "Adeos support" + +config ADEOS + tristate "Adeos support" + default y + ---help--- + Activate this option if you want the Adeos nanokernel to be + compiled in. + +config ADEOS_CORE + def_bool ADEOS + +config ADEOS_THREADS + bool "Threaded domains" + depends on ADEOS + default y + ---help--- + This option causes the domains to run as lightweight + threads, which is useful for having seperate stacks + for domains. Enabling this option is the safest setting for + now; disabling it causes an experimental mode to be used + where interrupts/events are directly processed on behalf of + the preempted context. Say Y if unsure. + +config ADEOS_NOTHREADS + def_bool !ADEOS_THREADS + +config ADEOS_PROFILING + bool "Pipeline profiling" + depends on ADEOS + default n + ---help--- + This option activates the profiling code which collects the + timestamps needed to measure the propagation time of + interrupts through the pipeline. Say N if unsure. + +config ADEOS_PREEMPT_RT + def_bool PREEMPT_NONE || PREEMPT_VOLUNTARY || PREEMPT_DESKTOP || PREEMPT_RT + +endmenu diff -uNrp linux-2.6.10/adeos/Makefile linux-2.6.10-ppc-adeos/adeos/Makefile --- linux-2.6.10/adeos/Makefile 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/adeos/Makefile 2005-05-27 19:17:37.000000000 +0200 @@ -0,0 +1,13 @@ +# +# Makefile for the Adeos layer. +# + +obj-$(CONFIG_ADEOS) += adeos.o + +adeos-objs := generic.o + +adeos-$(CONFIG_X86) += x86.o + +adeos-$(CONFIG_IA64) += ia64.o + +adeos-$(CONFIG_PPC) += ppc.o diff -uNrp linux-2.6.10/adeos/generic.c linux-2.6.10-ppc-adeos/adeos/generic.c --- linux-2.6.10/adeos/generic.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/adeos/generic.c 2005-06-28 16:54:06.000000000 +0200 @@ -0,0 +1,638 @@ +/* + * linux/adeos/generic.c + * + * Copyright (C) 2002 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Architecture-independent ADEOS services. + */ + +#include +#include +#include +#include +#include +#include + +MODULE_DESCRIPTION("Adeos nanokernel"); +MODULE_AUTHOR("Philippe Gerum"); +MODULE_LICENSE("GPL"); + +/* adeos_register_domain() -- Add a new domain to the system. All + client domains must call this routine to register themselves to + ADEOS before using its services. */ + +int adeos_register_domain (adomain_t *adp, adattr_t *attr) + +{ + struct list_head *pos; + unsigned long flags; + int n; + + if (adp_current != adp_root) + { + printk(KERN_WARNING "Adeos: Only the root domain may register a new domain.\n"); + return -EPERM; + } + + flags = adeos_critical_enter(NULL); + + list_for_each(pos,&__adeos_pipeline) { + adomain_t *_adp = list_entry(pos,adomain_t,p_link); + if (_adp->domid == attr->domid) + break; + } + + adeos_critical_exit(flags); + + if (pos != &__adeos_pipeline) + /* A domain with the given id already exists -- fail. */ + return -EBUSY; + + for (n = 0; n < ADEOS_NR_CPUS; n++) + { + /* Each domain starts in sleeping state on every CPU. */ + adp->cpudata[n].status = (1 << IPIPE_SLEEP_FLAG); +#ifdef CONFIG_ADEOS_THREADS + adp->estackbase[n] = 0; +#endif /* CONFIG_ADEOS_THREADS */ + } + + adp->name = attr->name; + adp->priority = attr->priority; + adp->domid = attr->domid; + adp->dswitch = attr->dswitch; + adp->flags = 0; + adp->ptd_setfun = attr->ptdset; + adp->ptd_getfun = attr->ptdget; + adp->ptd_keymap = 0; + adp->ptd_keycount = 0; + adp->ptd_keymax = attr->nptdkeys; + + for (n = 0; n < ADEOS_NR_EVENTS; n++) + /* Event handlers must be cleared before the i-pipe stage is + inserted since an exception may occur on behalf of the new + emerging domain. */ + adp->events[n].handler = NULL; + + if (attr->entry != NULL) + __adeos_init_domain(adp,attr); + + /* Insert the domain in the interrupt pipeline last, so it won't + be resumed for processing interrupts until it has a valid stack + context. */ + + __adeos_init_stage(adp); + + INIT_LIST_HEAD(&adp->p_link); + + flags = adeos_critical_enter(NULL); + + list_for_each(pos,&__adeos_pipeline) { + adomain_t *_adp = list_entry(pos,adomain_t,p_link); + if (adp->priority > _adp->priority) + break; + } + + list_add_tail(&adp->p_link,pos); + + adeos_critical_exit(flags); + + printk(KERN_WARNING "Adeos: Domain %s registered.\n",adp->name); + + /* Finally, allow the new domain to perform its initialization + chores. */ + + if (attr->entry != NULL) + { + adeos_declare_cpuid; + + adeos_lock_cpu(flags); + +#ifdef CONFIG_ADEOS_THREADS + __adeos_switch_to(adp_root,adp,cpuid); +#else /* !CONFIG_ADEOS_THREADS */ + adp_cpu_current[cpuid] = adp; + attr->entry(1); + adp_cpu_current[cpuid] = adp_root; +#endif /* CONFIG_ADEOS_THREADS */ + + adeos_load_cpuid(); /* Processor might have changed. */ + + if (adp_root->cpudata[cpuid].irq_pending_hi != 0 && + !test_bit(IPIPE_STALL_FLAG,&adp_root->cpudata[cpuid].status)) + __adeos_sync_stage(IPIPE_IRQMASK_ANY); + + adeos_unlock_cpu(flags); + } + + return 0; +} + +/* adeos_unregister_domain() -- Remove a domain from the system. All + client domains must call this routine to unregister themselves from + the ADEOS layer. */ + +int adeos_unregister_domain (adomain_t *adp) + +{ + unsigned long flags; + unsigned event; + + if (adp_current != adp_root) + { + printk(KERN_WARNING "Adeos: Only the root domain may unregister a domain.\n"); + return -EPERM; + } + + if (adp == adp_root) + { + printk(KERN_WARNING "Adeos: Cannot unregister the root domain.\n"); + return -EPERM; + } + + for (event = 0; event < ADEOS_NR_EVENTS; event++) + /* Need this to update the monitor count. */ + adeos_catch_event_from(adp,event,NULL); + +#ifdef CONFIG_SMP + { + int nr_cpus = num_online_cpus(), _cpuid; + unsigned irq; + + /* In the SMP case, wait for the logged events to drain on other + processors before eventually removing the domain from the + pipeline. */ + + adeos_unstall_pipeline_from(adp); + + flags = adeos_critical_enter(NULL); + + for (irq = 0; irq < IPIPE_NR_IRQS; irq++) + { + clear_bit(IPIPE_HANDLE_FLAG,&adp->irqs[irq].control); + clear_bit(IPIPE_STICKY_FLAG,&adp->irqs[irq].control); + set_bit(IPIPE_PASS_FLAG,&adp->irqs[irq].control); + } + + adeos_critical_exit(flags); + + for (_cpuid = 0; _cpuid < nr_cpus; _cpuid++) + { + for (irq = 0; irq < IPIPE_NR_IRQS; irq++) + while (adp->cpudata[_cpuid].irq_hits[irq] > 0) + cpu_relax(); + + while (test_bit(IPIPE_XPEND_FLAG,&adp->cpudata[_cpuid].status)) + cpu_relax(); + + while (!test_bit(IPIPE_SLEEP_FLAG,&adp->cpudata[_cpuid].status)) + cpu_relax(); + } + } +#endif /* CONFIG_SMP */ + + /* Simply remove the domain from the pipeline and we are almost + done. */ + + flags = adeos_critical_enter(NULL); + list_del_init(&adp->p_link); + adeos_critical_exit(flags); + + __adeos_cleanup_domain(adp); + + printk(KERN_WARNING "Adeos: Domain %s unregistered.\n",adp->name); + + return 0; +} + +/* adeos_propagate_irq() -- Force a given IRQ propagation on behalf of + a running interrupt handler to the next domain down the pipeline. + Returns non-zero if a domain has received the interrupt + notification, zero otherwise. + This call is useful for handling shared interrupts among domains. + e.g. pipeline = [domain-A]---[domain-B]... + Both domains share IRQ #X. + - domain-A handles IRQ #X but does not pass it down (i.e. Terminate + or Dynamic interrupt control mode) + - domain-B handles IRQ #X (i.e. Terminate or Accept interrupt + control modes). + When IRQ #X is raised, domain-A's handler determines whether it + should process the interrupt by identifying its source. If not, + adeos_propagate_irq() is called so that the next domain down the + pipeline which handles IRQ #X is given a chance to process it. This + process can be repeated until the end of the pipeline is + reached. */ + +/* adeos_schedule_irq() -- Almost the same as adeos_propagate_irq(), + but attempts to pend the interrupt for the current domain first. */ + +int fastcall __adeos_schedule_irq (unsigned irq, struct list_head *head) + +{ + struct list_head *ln; + unsigned long flags; + adeos_declare_cpuid; + + if (irq >= IPIPE_NR_IRQS || + (adeos_virtual_irq_p(irq) && !test_bit(irq - IPIPE_VIRQ_BASE,&__adeos_virtual_irq_map))) + return -EINVAL; + + adeos_lock_cpu(flags); + + ln = head; + + while (ln != &__adeos_pipeline) + { + adomain_t *adp = list_entry(ln,adomain_t,p_link); + + if (test_bit(IPIPE_HANDLE_FLAG,&adp->irqs[irq].control)) + { + adp->cpudata[cpuid].irq_hits[irq]++; + __adeos_set_irq_bit(adp,cpuid,irq); + adeos_unlock_cpu(flags); + return 1; + } + + ln = adp->p_link.next; + } + + adeos_unlock_cpu(flags); + + return 0; +} + +/* adeos_free_irq() -- Return a previously allocated virtual/soft + pipelined interrupt to the pool of allocatable interrupts. */ + +int adeos_free_irq (unsigned irq) + +{ + if (irq >= IPIPE_NR_IRQS) + return -EINVAL; + + clear_bit(irq - IPIPE_VIRQ_BASE,&__adeos_virtual_irq_map); + + return 0; +} + +cpumask_t adeos_set_irq_affinity (unsigned irq, cpumask_t cpumask) + +{ +#ifdef CONFIG_SMP + if (irq >= IPIPE_NR_XIRQS) + /* Allow changing affinity of external IRQs only. */ + return CPU_MASK_NONE; + + if (num_online_cpus() > 1) + /* Allow changing affinity of external IRQs only. */ + return __adeos_set_irq_affinity(irq,cpumask); +#endif /* CONFIG_SMP */ + + return CPU_MASK_NONE; +} + +/* adeos_catch_event_from() -- Interpose an event handler starting + from a given domain. */ + +int adeos_catch_event_from (adomain_t *adp, unsigned event, void (*handler)(adevinfo_t *)) + +{ + if (event >= ADEOS_NR_EVENTS) + return -EINVAL; + + if (!xchg(&adp->events[event].handler,handler)) + { + if (handler) + __adeos_event_monitors[event]++; + } + else if (!handler) + __adeos_event_monitors[event]--; + + return 0; +} + +void adeos_init_attr (adattr_t *attr) + +{ + attr->name = "Anonymous"; + attr->domid = 1; + attr->entry = NULL; + attr->estacksz = 0; /* Let ADEOS choose a reasonable stack size */ + attr->priority = ADEOS_ROOT_PRI; + attr->dswitch = NULL; + attr->nptdkeys = 0; + attr->ptdset = NULL; + attr->ptdget = NULL; +} + +int adeos_alloc_ptdkey (void) + +{ + unsigned long flags; + int key = -1; + + spin_lock_irqsave_hw(&__adeos_pipelock,flags); + + if (adp_current->ptd_keycount < adp_current->ptd_keymax) + { + key = ffz(adp_current->ptd_keymap); + set_bit(key,&adp_current->ptd_keymap); + adp_current->ptd_keycount++; + } + + spin_unlock_irqrestore_hw(&__adeos_pipelock,flags); + + return key; +} + +int adeos_free_ptdkey (int key) + +{ + unsigned long flags; + + if (key < 0 || key >= adp_current->ptd_keymax) + return -EINVAL; + + spin_lock_irqsave_hw(&__adeos_pipelock,flags); + + if (test_and_clear_bit(key,&adp_current->ptd_keymap)) + adp_current->ptd_keycount--; + + spin_unlock_irqrestore_hw(&__adeos_pipelock,flags); + + return 0; +} + +int adeos_set_ptd (int key, void *value) + +{ + if (key < 0 || key >= adp_current->ptd_keymax) + return -EINVAL; + + if (!adp_current->ptd_setfun) + { + printk(KERN_WARNING "Adeos: No ptdset hook for %s\n",adp_current->name); + return -EINVAL; + } + + adp_current->ptd_setfun(key,value); + + return 0; +} + +void *adeos_get_ptd (int key) + +{ + if (key < 0 || key >= adp_current->ptd_keymax) + return NULL; + + if (!adp_current->ptd_getfun) + { + printk(KERN_WARNING "Adeos: No ptdget hook for %s\n",adp_current->name); + return NULL; + } + + return adp_current->ptd_getfun(key); +} + +int adeos_init_mutex (admutex_t *mutex) + +{ + admutex_t initm = ADEOS_MUTEX_UNLOCKED; + *mutex = initm; + return 0; +} + +#ifdef CONFIG_ADEOS_THREADS + +int adeos_destroy_mutex (admutex_t *mutex) + +{ + if (!adeos_spin_trylock(&mutex->lock) && + adp_current != adp_root && + mutex->owner != adp_current) + return -EBUSY; + + return 0; +} + +static inline void __adeos_sleepon_mutex (admutex_t *mutex, adomain_t *sleeper, int cpuid) + +{ + adomain_t *owner = mutex->owner; + + /* Make the current domain (== sleeper) wait for the mutex to be + released. Adeos' pipelined scheme guarantees that the new + sleeper _is_ higher priority than any aslept domain since we + have stalled each sleeper's stage. Must be called with local hw + interrupts off. */ + + sleeper->m_link = mutex->sleepq; + mutex->sleepq = sleeper; + __adeos_switch_to(adp_cpu_current[cpuid],owner,cpuid); + mutex->owner = sleeper; + adeos_spin_unlock(&mutex->lock); +} + +unsigned long fastcall adeos_lock_mutex (admutex_t *mutex) + +{ + unsigned long flags, hwflags; + adeos_declare_cpuid; + adomain_t *adp; + + if (!adp_pipelined) + { + adeos_hw_local_irq_save(hwflags); + flags = !adeos_hw_test_iflag(hwflags); + adeos_spin_lock(&mutex->lock); + return flags; + } + + adeos_lock_cpu(hwflags); + + adp = adp_cpu_current[cpuid]; + + flags = __test_and_set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + /* Two cases to handle here on SMP systems, only one for UP: 1) in + case of a conflicting access from a higher priority domain + running on the same cpu, make this domain sleep on the mutex, + and resume the current owner so it can release the lock asap. + 2) in case of a conflicting access from any domain on a + different cpu than the current owner's, simply enter a spinning + loop. Note that testing mutex->owncpu is safe since it is only + changed by the current owner, and set to -1 when the mutex is + unlocked. */ + +#ifdef CONFIG_SMP + while (!adeos_spin_trylock(&mutex->lock)) + { + if (mutex->owncpu == cpuid) + { + __adeos_sleepon_mutex(mutex,adp,cpuid); + adeos_load_cpuid(); + } + } + + mutex->owncpu = cpuid; +#else /* !CONFIG_SMP */ + while (mutex->owner != NULL && mutex->owner != adp) + __adeos_sleepon_mutex(mutex,adp,cpuid); +#endif /* CONFIG_SMP */ + + mutex->owner = adp; + + adeos_unlock_cpu(hwflags); + + return flags; +} + +void fastcall adeos_unlock_mutex (admutex_t *mutex, unsigned long flags) + +{ + unsigned long hwflags; + adeos_declare_cpuid; + adomain_t *adp; + + if (!adp_pipelined) + { + adeos_spin_unlock(&mutex->lock); + + if (flags) + adeos_hw_cli(); + else + adeos_hw_sti(); + + return; + } + +#ifdef CONFIG_SMP + mutex->owncpu = -1; +#endif /* CONFIG_SMP */ + + if (!flags) + adeos_hw_sti(); /* Absolutely needed. */ + + adeos_lock_cpu(hwflags); + + if (mutex->sleepq != NULL) + { + adomain_t *sleeper = mutex->sleepq; + /* Wake up the highest priority sleeper. */ + mutex->sleepq = sleeper->m_link; + __adeos_switch_to(adp_cpu_current[cpuid],sleeper,cpuid); + adeos_load_cpuid(); + } + else + { + mutex->owner = NULL; + adeos_spin_unlock(&mutex->lock); + } + + adp = adp_cpu_current[cpuid]; + + if (flags) + __set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + else + { + __clear_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + if (adp->cpudata[cpuid].irq_pending_hi != 0) + __adeos_sync_stage(IPIPE_IRQMASK_ANY); + } + + adeos_unlock_cpu(hwflags); +} + +#else /* !CONFIG_ADEOS_THREADS */ + +int adeos_destroy_mutex (admutex_t *mutex) + +{ + if (!adeos_spin_trylock(&mutex->lock) && + adp_current != adp_root) + return -EBUSY; + + return 0; +} + +unsigned long fastcall adeos_lock_mutex (admutex_t *mutex) + +{ + unsigned long flags; /* FIXME: won't work on SPARC */ + spin_lock_irqsave_hw(&mutex->lock,flags); + return flags; +} + +void fastcall adeos_unlock_mutex (admutex_t *mutex, unsigned long flags) + +{ + spin_unlock_irqrestore_hw(&mutex->lock,flags); +} + +#endif /* CONFIG_ADEOS_THREADS */ + +void __adeos_takeover (void) + +{ + __adeos_enable_pipeline(); + printk(KERN_WARNING "Adeos: Pipelining started.\n"); +} + +#ifdef MODULE + +static int __init adeos_init_module (void) + +{ + __adeos_takeover(); + return 0; +} + +static void __exit adeos_exit_module (void) + +{ + __adeos_disable_pipeline(); + printk(KERN_WARNING "Adeos: Pipelining stopped.\n"); +} + +module_init(adeos_init_module); +module_exit(adeos_exit_module); + +#endif /* MODULE */ + +EXPORT_SYMBOL(adeos_register_domain); +EXPORT_SYMBOL(adeos_unregister_domain); +EXPORT_SYMBOL(adeos_virtualize_irq_from); +EXPORT_SYMBOL(adeos_control_irq); +EXPORT_SYMBOL(__adeos_schedule_irq); +EXPORT_SYMBOL(adeos_free_irq); +EXPORT_SYMBOL(adeos_send_ipi); +EXPORT_SYMBOL(adeos_catch_event_from); +EXPORT_SYMBOL(adeos_init_attr); +EXPORT_SYMBOL(adeos_get_sysinfo); +EXPORT_SYMBOL(adeos_tune_timer); +EXPORT_SYMBOL(adeos_alloc_ptdkey); +EXPORT_SYMBOL(adeos_free_ptdkey); +EXPORT_SYMBOL(adeos_set_ptd); +EXPORT_SYMBOL(adeos_get_ptd); +EXPORT_SYMBOL(adeos_set_irq_affinity); +EXPORT_SYMBOL(adeos_init_mutex); +EXPORT_SYMBOL(adeos_destroy_mutex); +EXPORT_SYMBOL(adeos_lock_mutex); +EXPORT_SYMBOL(adeos_unlock_mutex); diff -uNrp linux-2.6.10/adeos/ppc.c linux-2.6.10-ppc-adeos/adeos/ppc.c --- linux-2.6.10/adeos/ppc.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/adeos/ppc.c 2005-03-13 09:33:35.000000000 +0100 @@ -0,0 +1,514 @@ +/* + * linux/adeos/ppc.c + * + * Copyright (C) 2004 Philippe Gerum. + * + * Adeos/PPC port over 2.6 based on the previous 2.4 implementation by: + * + * Copyright (C) 2004 Wolfgang Grandegger. + * + * It follows closely the ARM and x86 ports of ADEOS. + * + * Copyright (C) 2003 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Architecture-dependent ADEOS support for PowerPC. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern spinlock_t __adeos_pipelock; + +extern unsigned long __adeos_virtual_irq_map; + +extern struct list_head __adeos_pipeline; + +extern irq_desc_t irq_desc[]; + +static struct hw_interrupt_type __adeos_std_irq_dtype[NR_IRQS]; + +static void __adeos_override_irq_enable (unsigned irq) + +{ + unsigned long adflags, hwflags; + adeos_declare_cpuid; + + adeos_hw_local_irq_save(hwflags); + adflags = adeos_test_and_stall_pipeline(); + preempt_disable(); + __adeos_unlock_irq(adp_cpu_current[cpuid],irq); + __adeos_std_irq_dtype[irq].enable(irq); + preempt_enable_no_resched(); + adeos_restore_pipeline_nosync(adp_cpu_current[cpuid],adflags,cpuid); + adeos_hw_local_irq_restore(hwflags); +} + +static void __adeos_override_irq_disable (unsigned irq) + +{ + unsigned long adflags, hwflags; + adeos_declare_cpuid; + + adeos_hw_local_irq_save(hwflags); + adflags = adeos_test_and_stall_pipeline(); + preempt_disable(); + __adeos_std_irq_dtype[irq].disable(irq); + __adeos_lock_irq(adp_cpu_current[cpuid],cpuid,irq); + preempt_enable_no_resched(); + adeos_restore_pipeline_nosync(adp_cpu_current[cpuid],adflags,cpuid); + adeos_hw_local_irq_restore(hwflags); +} + +static void __adeos_override_irq_end (unsigned irq) + +{ + unsigned long adflags, hwflags; + adeos_declare_cpuid; + + adeos_hw_local_irq_save(hwflags); + adflags = adeos_test_and_stall_pipeline(); + preempt_disable(); + + if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) + __adeos_unlock_irq(adp_cpu_current[cpuid],irq); + + __adeos_std_irq_dtype[irq].end(irq); + + preempt_enable_no_resched(); + adeos_restore_pipeline_nosync(adp_cpu_current[cpuid],adflags,cpuid); + adeos_hw_local_irq_restore(hwflags); +} + +static void __adeos_override_irq_affinity (unsigned irq, cpumask_t mask) + +{ + unsigned long adflags, hwflags; + adeos_declare_cpuid; + + adeos_hw_local_irq_save(hwflags); + adflags = adeos_test_and_stall_pipeline(); + preempt_disable(); + __adeos_std_irq_dtype[irq].set_affinity(irq,mask); + preempt_enable_no_resched(); + adeos_restore_pipeline_nosync(adp_cpu_current[cpuid],adflags,cpuid); + adeos_hw_local_irq_restore(hwflags); +} + +static void __adeos_enable_sync (void) + +{ + __adeos_decr_next[adeos_processor_id()] = __adeos_read_timebase() + get_dec(); +} + +/* __adeos_enable_pipeline() -- Take over the interrupt control from + the root domain (i.e. Linux). After this routine has returned, all + interrupts go through the pipeline. */ + +void __adeos_enable_pipeline (void) + +{ + unsigned long flags; + unsigned irq; + + flags = adeos_critical_enter(&__adeos_enable_sync); + + /* First, virtualize all interrupts from the root domain. */ + + for (irq = 0; irq < NR_IRQS; irq++) + adeos_virtualize_irq(irq, + (void (*)(unsigned))&__adeos_do_IRQ, + &__adeos_ack_irq, + IPIPE_HANDLE_MASK|IPIPE_PASS_MASK); + + /* We use a virtual IRQ to handle the timer irq (decrementer trap) + which has been allocated early in __adeos_init_platform(). */ + + adeos_virtualize_irq(ADEOS_TIMER_VIRQ, + (void (*)(unsigned))&__adeos_do_timer, + NULL, + IPIPE_HANDLE_MASK|IPIPE_PASS_MASK); + + + /* Interpose on the IRQ control routines so we can make them + atomic using hw masking and prevent the interrupt log from + being untimely flushed. */ + + for (irq = 0; irq < NR_IRQS; irq++) + { + if (irq_desc[irq].handler != NULL) + __adeos_std_irq_dtype[irq] = *irq_desc[irq].handler; + } + + /* The original controller structs are often shared, so we first + save them all before changing any of them. Notice that we don't + override the ack() handler since we will enforce the necessary + setup in __adeos_ack_irq(). */ + + for (irq = 0; irq < NR_IRQS; irq++) + { + struct hw_interrupt_type *handler = irq_desc[irq].handler; + + if (handler == NULL) + continue; + + if (handler->enable != NULL) + handler->enable = &__adeos_override_irq_enable; + + if (handler->disable != NULL) + handler->disable = &__adeos_override_irq_disable; + + if (handler->end != NULL) + handler->end = &__adeos_override_irq_end; + + if (handler->set_affinity != NULL) + handler->set_affinity = &__adeos_override_irq_affinity; + } + + __adeos_decr_next[adeos_processor_id()] = __adeos_read_timebase() + get_dec(); + + adp_pipelined = 1; + + adeos_critical_exit(flags); +} + +/* __adeos_disable_pipeline() -- Disengage the pipeline. */ + +void __adeos_disable_pipeline (void) + +{ + unsigned long flags; + unsigned irq; + + flags = adeos_critical_enter(NULL); + + /* Restore interrupt controllers. */ + + for (irq = 0; irq < NR_IRQS; irq++) + { + if (irq_desc[irq].handler != NULL) + *irq_desc[irq].handler = __adeos_std_irq_dtype[irq]; + } + + adp_pipelined = 0; + + adeos_critical_exit(flags); +} + +/* adeos_virtualize_irq_from() -- Attach a handler (and optionally a + hw acknowledge routine) to an interrupt for the given domain. */ + +int adeos_virtualize_irq_from (adomain_t *adp, + unsigned irq, + void (*handler)(unsigned irq), + int (*acknowledge)(unsigned irq), + unsigned modemask) +{ + unsigned long flags; + int err; + + if (irq >= IPIPE_NR_IRQS) + return -EINVAL; + + if (adp->irqs[irq].control & IPIPE_SYSTEM_MASK) + return -EPERM; + + adeos_spin_lock_irqsave(&__adeos_pipelock,flags); + + if (handler != NULL) + { + /* A bit of hack here: if we are re-virtualizing an IRQ just + to change the acknowledge routine by passing the special + ADEOS_SAME_HANDLER value, then allow to recycle the current + handler for the IRQ. This allows Linux device drivers + managing shared IRQ lines to call adeos_virtualize_irq() in + addition to request_irq() just for the purpose of + interposing their own shared acknowledge routine. */ + + if (handler == ADEOS_SAME_HANDLER) + { + handler = adp->irqs[irq].handler; + + if (handler == NULL) + { + err = -EINVAL; + goto unlock_and_exit; + } + } + else if ((modemask & IPIPE_EXCLUSIVE_MASK) != 0 && + adp->irqs[irq].handler != NULL) + { + err = -EBUSY; + goto unlock_and_exit; + } + + if ((modemask & (IPIPE_SHARED_MASK|IPIPE_PASS_MASK)) == IPIPE_SHARED_MASK) + { + err = -EINVAL; + goto unlock_and_exit; + } + + if ((modemask & IPIPE_STICKY_MASK) != 0) + modemask |= IPIPE_HANDLE_MASK; + } + else + modemask &= ~(IPIPE_HANDLE_MASK|IPIPE_STICKY_MASK|IPIPE_SHARED_MASK); + + if (acknowledge == NULL) + { + if ((modemask & IPIPE_SHARED_MASK) == 0) + /* Acknowledge handler unspecified -- this is ok in + non-shared management mode, but we will force the use + of the Linux-defined handler instead. */ + acknowledge = adp_root->irqs[irq].acknowledge; + else + { + /* A valid acknowledge handler to be called in shared mode + is required when declaring a shared IRQ. */ + err = -EINVAL; + goto unlock_and_exit; + } + } + + adp->irqs[irq].handler = handler; + adp->irqs[irq].acknowledge = acknowledge; + adp->irqs[irq].control = modemask; + + if (irq < NR_IRQS && + handler != NULL && + !adeos_virtual_irq_p(irq) && + (modemask & IPIPE_ENABLE_MASK) != 0) + { + if (adp != adp_current) + { + /* IRQ enable/disable state is domain-sensitive, so we may + not change it for another domain. What is allowed + however is forcing some domain to handle an interrupt + source, by passing the proper 'adp' descriptor which + thus may be different from adp_current. */ + err = -EPERM; + goto unlock_and_exit; + } + + enable_irq(irq); + } + + err = 0; + +unlock_and_exit: + + adeos_spin_unlock_irqrestore(&__adeos_pipelock,flags); + + return err; +} + +/* adeos_control_irq() -- Change an interrupt mode. This affects the + way a given interrupt is handled by ADEOS for the current + domain. setmask is a bitmask telling whether: + - the interrupt should be passed to the domain (IPIPE_HANDLE_MASK), + and/or + - the interrupt should be passed down to the lower priority domain(s) + in the pipeline (IPIPE_PASS_MASK). + This leads to four possibilities: + - PASS only => Ignore the interrupt + - HANDLE only => Terminate the interrupt (process but don't pass down) + - PASS + HANDLE => Accept the interrupt (process and pass down) + - => Discard the interrupt + - DYNAMIC is currently an alias of HANDLE since it marks an interrupt + which is processed by the current domain but not implicitely passed + down to the pipeline, letting the domain's handler choose on a case- + by-case basis whether the interrupt propagation should be forced + using adeos_propagate_irq(). + clrmask clears the corresponding bits from the control field before + setmask is applied. +*/ + +int adeos_control_irq (unsigned irq, + unsigned clrmask, + unsigned setmask) +{ + irq_desc_t *desc; + unsigned long flags; + + if (irq >= IPIPE_NR_IRQS) + return -EINVAL; + + if (adp_current->irqs[irq].control & IPIPE_SYSTEM_MASK) + return -EPERM; + + if (((setmask|clrmask) & IPIPE_SHARED_MASK) != 0) + return -EINVAL; + + desc = irq_desc + irq; + + if (adp_current->irqs[irq].handler == NULL) + setmask &= ~(IPIPE_HANDLE_MASK|IPIPE_STICKY_MASK); + + if ((setmask & IPIPE_STICKY_MASK) != 0) + setmask |= IPIPE_HANDLE_MASK; + + if ((clrmask & (IPIPE_HANDLE_MASK|IPIPE_STICKY_MASK)) != 0) /* If one goes, both go. */ + clrmask |= (IPIPE_HANDLE_MASK|IPIPE_STICKY_MASK); + + adeos_spin_lock_irqsave(&__adeos_pipelock,flags); + + adp_current->irqs[irq].control &= ~clrmask; + adp_current->irqs[irq].control |= setmask; + + if ((setmask & IPIPE_ENABLE_MASK) != 0) + enable_irq(irq); + else if ((clrmask & IPIPE_ENABLE_MASK) != 0) + disable_irq(irq); + + adeos_spin_unlock_irqrestore(&__adeos_pipelock,flags); + + return 0; +} + +#ifdef CONFIG_ADEOS_THREADS + +void __adeos_init_domain (adomain_t *adp, adattr_t *attr) + +{ + int estacksz = attr->estacksz > 0 ? attr->estacksz : 8192, _cpuid; + unsigned long flags, *ksp; + adeos_declare_cpuid; + + adeos_hw_local_irq_flags(flags); + + for (_cpuid = 0; _cpuid < num_online_cpus(); _cpuid++) + { + adp->estackbase[_cpuid] = (unsigned long)kmalloc(estacksz,GFP_KERNEL); + + if (adp->estackbase[_cpuid] == 0) + panic("Adeos: No memory for domain stack on CPU #%d",_cpuid); + + adp->esp[_cpuid] = adp->estackbase[_cpuid]; + *((unsigned long *)adp->esp[_cpuid]) = 0; + ksp = (unsigned long *)(((adp->esp[_cpuid] + estacksz - 16) & ~0xf) - 108); + adp->esp[_cpuid] = (unsigned long)ksp - STACK_FRAME_OVERHEAD; + ksp[19] = (_cpuid == cpuid); /* r3 */ + ksp[25] = (unsigned long)attr->entry; /* lr */ + ksp[26] = flags & ~MSR_EE; /* msr */ + } +} + +#else /* !CONFIG_ADEOS_THREADS */ + +void __adeos_init_domain (adomain_t *adp, adattr_t *attr) + +{} + +#endif /* CONFIG_ADEOS_THREADS */ + +void __adeos_cleanup_domain (adomain_t *adp) + +{ + int nr_cpus = num_online_cpus(); + int _cpuid; + + adeos_unstall_pipeline_from(adp); + + for (_cpuid = 0; _cpuid < nr_cpus; _cpuid++) + { +#ifdef CONFIG_SMP + while (adp->cpudata[_cpuid].irq_pending_hi != 0) + cpu_relax(); + + while (test_bit(IPIPE_XPEND_FLAG,&adp->cpudata[_cpuid].status)) + cpu_relax(); +#endif /* CONFIG_SMP */ + +#ifdef CONFIG_ADEOS_THREADS + if (adp->estackbase[_cpuid] != 0) + kfree((void *)adp->estackbase[_cpuid]); +#endif /* CONFIG_ADEOS_THREADS */ + } +} + +int adeos_get_sysinfo (adsysinfo_t *info) + +{ + info->ncpus = num_online_cpus(); + info->cpufreq = adeos_cpu_freq(); + info->archdep.tmirq = ADEOS_TIMER_VIRQ; + info->archdep.tmfreq = info->cpufreq; + + return 0; +} + +static void __adeos_set_decr (void) + +{ + adeos_declare_cpuid; + + adeos_load_cpuid(); + + disarm_decr[cpuid] = (__adeos_decr_ticks != tb_ticks_per_jiffy); +#ifdef CONFIG_40x + /* Enable and set auto-reload. */ + mtspr(SPRN_TCR,mfspr(SPRN_TCR) | TCR_ARE); + mtspr(SPRN_PIT,__adeos_decr_ticks); +#else /* !CONFIG_40x */ + __adeos_decr_next[cpuid] = __adeos_read_timebase() + __adeos_decr_ticks; + set_dec(__adeos_decr_ticks); +#endif /* CONFIG_40x */ +} + +int adeos_tune_timer (unsigned long ns, int flags) + +{ + unsigned long x, ticks; + + if (flags & ADEOS_RESET_TIMER) + ticks = tb_ticks_per_jiffy; + else + { + ticks = ns * tb_ticks_per_jiffy / (1000000000 / HZ); + + if (ticks > tb_ticks_per_jiffy) + return -EINVAL; + } + + x = adeos_critical_enter(&__adeos_set_decr); /* Sync with all CPUs */ + __adeos_decr_ticks = ticks; + __adeos_set_decr(); + adeos_critical_exit(x); + + return 0; +} + +/* adeos_send_ipi() -- Send a specified service IPI to a set of + processors. */ + +int adeos_send_ipi (unsigned ipi, cpumask_t cpumask) + +{ + printk(KERN_WARNING "Adeos: Call to unimplemented adeos_send_ipi() from %s\n",adp_current->name); + return 0; +} diff -uNrp linux-2.6.10/arch/ppc/Kconfig linux-2.6.10-ppc-adeos/arch/ppc/Kconfig --- linux-2.6.10/arch/ppc/Kconfig 2004-12-24 22:35:40.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/Kconfig 2005-03-27 16:35:18.000000000 +0200 @@ -1207,6 +1207,8 @@ endmenu source "lib/Kconfig" +source "adeos/Kconfig" + source "arch/ppc/oprofile/Kconfig" source "arch/ppc/Kconfig.debug" diff -uNrp linux-2.6.10/arch/ppc/kernel/Makefile linux-2.6.10-ppc-adeos/arch/ppc/kernel/Makefile --- linux-2.6.10/arch/ppc/kernel/Makefile 2004-12-24 22:35:28.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/Makefile 2005-03-27 16:35:18.000000000 +0200 @@ -29,3 +29,4 @@ ifndef CONFIG_MATH_EMULATION obj-$(CONFIG_8xx) += softemu8xx.o endif +obj-$(CONFIG_ADEOS_CORE) += adeos.o diff -uNrp linux-2.6.10/arch/ppc/kernel/adeos.c linux-2.6.10-ppc-adeos/arch/ppc/kernel/adeos.c --- linux-2.6.10/arch/ppc/kernel/adeos.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/adeos.c 2005-07-16 10:55:26.000000000 +0200 @@ -0,0 +1,716 @@ +/* + * linux/arch/ppc/kernel/adeos.c + * + * Copyright (C) 2004 Philippe Gerum. + * + * Adeos/PPC port over 2.6 based on the previous 2.4 implementation by: + * + * Copyright (C) 2004 Wolfgang Grandegger. + * + * It follows closely the ARM and x86 ports of ADEOS. + * + * Copyright (C) 2003 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Architecture-dependent ADEOS core support for PowerPC + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef CONFIG_SMP + +static cpumask_t __adeos_cpu_sync_map; + +static cpumask_t __adeos_cpu_lock_map; + +static spinlock_t __adeos_cpu_barrier = SPIN_LOCK_UNLOCKED; + +static atomic_t __adeos_critical_count = ATOMIC_INIT(0); + +static void (*__adeos_cpu_sync)(void); + +#endif /* CONFIG_SMP */ + +int do_IRQ(struct pt_regs *regs); + +extern struct list_head __adeos_pipeline; + +struct pt_regs __adeos_irq_regs; + +#ifdef CONFIG_POWER4 +extern struct irqaction k2u3_cascade_action; +extern int openpic2_get_irq(struct pt_regs *regs); +#endif + +/* Current reload value for the decrementer. */ +unsigned long __adeos_decr_ticks; + +/* Next tick date (timebase value). */ +unsigned long long __adeos_decr_next[ADEOS_NR_CPUS]; + +static inline unsigned long ffnz (unsigned long ul) { + + __asm__ __volatile__ ("cntlzw %0, %1" : "=r" (ul) : "r" (ul & (-ul))); + return 31 - ul; +} + +#ifdef CONFIG_SMP + +/* Always called with hw interrupts off. */ + +static void __adeos_do_critical_sync (unsigned irq) + +{ + adeos_declare_cpuid; + + adeos_load_cpuid(); + + cpu_set(cpuid,__adeos_cpu_sync_map); + + /* Now we are in sync with the lock requestor running on another + CPU. Enter a spinning wait until he releases the global + lock. */ + adeos_spin_lock(&__adeos_cpu_barrier); + + /* Got it. Now get out. */ + + if (__adeos_cpu_sync) + /* Call the sync routine if any. */ + __adeos_cpu_sync(); + + adeos_spin_unlock(&__adeos_cpu_barrier); + + cpu_clear(cpuid,__adeos_cpu_sync_map); +} + +#endif /* CONFIG_SMP */ + +/* adeos_critical_enter() -- Grab the superlock for entering a global + critical section. On this uniprocessor-only arch, this is identical + to hw cli(). */ + +unsigned long adeos_critical_enter (void (*syncfn)(void)) + +{ + unsigned long flags; + + adeos_hw_local_irq_save(flags); + +#ifdef CONFIG_SMP + if (num_online_cpus() > 1) /* We might be running a SMP-kernel on a UP box... */ + { + adeos_declare_cpuid; + cpumask_t lock_map; + + adeos_load_cpuid(); + + if (!cpu_test_and_set(cpuid,__adeos_cpu_lock_map)) + { + while (cpu_test_and_set(BITS_PER_LONG - 1,__adeos_cpu_lock_map)) + { + /* Refer to the explanations found in + linux/arch/asm-i386/irq.c about + SUSPECTED_CPU_OR_CHIPSET_BUG_WORKAROUND for more about + this strange loop. */ + int n = 0; + do { cpu_relax(); } while (++n < cpuid); + } + + adeos_spin_lock(&__adeos_cpu_barrier); + + __adeos_cpu_sync = syncfn; + + /* Send the sync IPI to all processors but the current one. */ + __adeos_send_IPI_allbutself(ADEOS_CRITICAL_VECTOR); + + cpus_andnot(lock_map,cpu_online_map,__adeos_cpu_lock_map); + + while (!cpus_equal(__adeos_cpu_sync_map,lock_map)) + cpu_relax(); + } + + atomic_inc(&__adeos_critical_count); + } +#endif /* CONFIG_SMP */ + + return flags; +} + +/* adeos_critical_exit() -- Release the superlock. */ + +void adeos_critical_exit (unsigned long flags) + +{ +#ifdef CONFIG_SMP + if (num_online_cpus() > 1) /* We might be running a SMP-kernel on a UP box... */ + { + adeos_declare_cpuid; + + adeos_load_cpuid(); + + if (atomic_dec_and_test(&__adeos_critical_count)) + { + adeos_spin_unlock(&__adeos_cpu_barrier); + + while (!cpus_empty(__adeos_cpu_sync_map)) + cpu_relax(); + + cpu_clear(cpuid,__adeos_cpu_lock_map); + cpu_clear(BITS_PER_LONG - 1,__adeos_cpu_lock_map); + } + } +#endif /* CONFIG_SMP */ + + adeos_hw_local_irq_restore(flags); +} + +void __adeos_init_platform (void) + +{ + unsigned timer_virq; + + /* Allocate a virtual IRQ for the decrementer trap early to get it + mapped to IPIPE_VIRQ_BASE */ + + timer_virq = adeos_alloc_irq(); + + if (timer_virq != ADEOS_TIMER_VIRQ) + panic("Adeos: cannot reserve timer virq #%d (got #%d)", + ADEOS_TIMER_VIRQ, + timer_virq); + + __adeos_decr_ticks = tb_ticks_per_jiffy; +} + +void __adeos_init_stage (adomain_t *adp) + +{ + int cpuid, n; + + for (cpuid = 0; cpuid < ADEOS_NR_CPUS; cpuid++) + { + adp->cpudata[cpuid].irq_pending_hi = 0; + + for (n = 0; n < IPIPE_IRQ_IWORDS; n++) + adp->cpudata[cpuid].irq_pending_lo[n] = 0; + + for (n = 0; n < IPIPE_NR_IRQS; n++) + adp->cpudata[cpuid].irq_hits[n] = 0; + } + + for (n = 0; n < IPIPE_NR_IRQS; n++) + { + adp->irqs[n].acknowledge = NULL; + adp->irqs[n].handler = NULL; + adp->irqs[n].control = IPIPE_PASS_MASK; /* Pass but don't handle */ + } + +#ifdef CONFIG_SMP + adp->irqs[ADEOS_CRITICAL_IPI].acknowledge = &__adeos_ack_irq; + adp->irqs[ADEOS_CRITICAL_IPI].handler = &__adeos_do_critical_sync; + /* Immediately handle in the current domain but *never* pass */ + adp->irqs[ADEOS_CRITICAL_IPI].control = IPIPE_HANDLE_MASK|IPIPE_STICKY_MASK|IPIPE_SYSTEM_MASK; +#endif /* CONFIG_SMP */ +} + +/* __adeos_sync_stage() -- Flush the pending IRQs for the current + domain (and processor). This routine flushes the interrupt log + (see "Optimistic interrupt protection" from D. Stodolsky et al. for + more on the deferred interrupt scheme). Every interrupt that + occurred while the pipeline was stalled gets played. WARNING: + callers on SMP boxen should always check for CPU migration on + return of this routine. One can control the kind of interrupts + which are going to be sync'ed using the syncmask + parameter. IPIPE_IRQMASK_ANY plays them all, IPIPE_IRQMASK_VIRT + plays virtual interrupts only. This routine must be called with hw + interrupts off. */ + +void __adeos_sync_stage (unsigned long syncmask) + +{ + unsigned long mask, submask; + struct adcpudata *cpudata; + int level, rank, sync; + adeos_declare_cpuid; + adomain_t *adp; + unsigned irq; + + adeos_load_cpuid(); + adp = adp_cpu_current[cpuid]; + cpudata = &adp->cpudata[cpuid]; + + sync = __test_and_set_bit(IPIPE_SYNC_FLAG,&cpudata->status); + + /* The policy here is to keep the dispatching code interrupt-free + by stalling the current stage. If the upper domain handler + (which we call) wants to re-enable interrupts while in a safe + portion of the code (e.g. SA_INTERRUPT flag unset for Linux's + sigaction()), it will have to unstall (then stall again before + returning to us!) the stage when it sees fit. */ + + while ((mask = (cpudata->irq_pending_hi & syncmask)) != 0) + { + /* Give a slight priority advantage to high-numbered IRQs + like the virtual ones. */ + level = ffnz(mask); + __clear_bit(level,&cpudata->irq_pending_hi); + + while ((submask = cpudata->irq_pending_lo[level]) != 0) + { + rank = ffnz(submask); + irq = (level << IPIPE_IRQ_ISHIFT) + rank; + + if (test_bit(IPIPE_LOCK_FLAG,&adp->irqs[irq].control)) + { + __clear_bit(rank,&cpudata->irq_pending_lo[level]); + continue; + } + + if (--cpudata->irq_hits[irq] == 0) + __clear_bit(rank,&cpudata->irq_pending_lo[level]); + + __set_bit(IPIPE_STALL_FLAG,&cpudata->status); + +#ifdef CONFIG_ADEOS_PROFILING + __adeos_profile_data[cpuid].irqs[irq].n_synced++; + adeos_hw_tsc(__adeos_profile_data[cpuid].irqs[irq].t_synced); +#endif /* CONFIG_ADEOS_PROFILING */ + + if (adp == adp_root) + { + adeos_hw_sti(); + irq_enter(); + ((void (*)(unsigned, struct pt_regs *))adp->irqs[irq].handler)(irq,&__adeos_irq_regs); + irq_exit(); + } + else + adp->irqs[irq].handler(irq); + + adeos_hw_cli(); + +#ifdef CONFIG_SMP + { + int _cpuid = adeos_processor_id(); + + if (_cpuid != cpuid) /* Handle CPU migration. */ + { + /* We expect any domain to clear the SYNC bit each + time it switches in a new task, so that preemptions + and/or CPU migrations (in the SMP case) over the + ISR do not lock out the log syncer for some + indefinite amount of time. In the Linux case, + schedule() handles this (see kernel/sched.c). For + this reason, we don't bother clearing it here for + the source CPU in the migration handling case, + since it must have scheduled another task in by + now. */ + cpuid = _cpuid; + cpudata = &adp->cpudata[cpuid]; + __set_bit(IPIPE_SYNC_FLAG,&cpudata->status); + } + } +#endif /* CONFIG_SMP */ + + __clear_bit(IPIPE_STALL_FLAG,&cpudata->status); + } + } + + if (!sync) + __clear_bit(IPIPE_SYNC_FLAG,&cpudata->status); +} + +int __adeos_ack_irq (unsigned irq) + +{ + irq_desc_t *desc = irq_desc + irq; + unsigned long adflags; + adeos_declare_cpuid; + + if (desc->handler->ack == NULL) + return 1; + + /* No need to mask IRQs at hw level: we are always called from + __adeos_handle_irq(), so interrupts are already off. We stall + the pipeline so that spin_lock_irq*() ops won't unintentionally + flush it, since this could cause infinite recursion. */ + + adeos_load_cpuid(); + adflags = adeos_test_and_stall_pipeline(); + preempt_disable(); + spin_lock(&desc->lock); + desc->handler->ack(irq); +#ifdef CONFIG_POWER4 + /* if it is a k2u3 cascaded irq, acknowledge it, also */ + if (desc->action == &k2u3_cascade_action) { + struct pt_regs regs; + int irq2 = openpic2_get_irq(®s); + if (irq2 != -1) { + irq_desc_t *desc2 = irq_desc + irq2; + if (desc2->handler->ack) + desc2->handler->ack(irq2); + } + } +#endif + spin_unlock(&desc->lock); + preempt_enable_no_resched(); + adeos_restore_pipeline_nosync(adp_cpu_current[cpuid],adflags,cpuid); + + return 1; +} + +static inline void __adeos_walk_pipeline (struct list_head *pos, int cpuid) + +{ + adomain_t *this_domain = adp_cpu_current[cpuid]; + + while (pos != &__adeos_pipeline) + { + adomain_t *next_domain = list_entry(pos,adomain_t,p_link); + + if (test_bit(IPIPE_STALL_FLAG,&next_domain->cpudata[cpuid].status)) + break; /* Stalled stage -- do not go further. */ + + if (next_domain->cpudata[cpuid].irq_pending_hi != 0) + { + /* Since the critical IPI might be dispatched by the + following actions, the current domain might not be + linked to the pipeline anymore after its handler + returns on SMP boxes, even if the domain remains valid + (see adeos_unregister_domain()), so don't make any + dangerous assumptions here. */ + + if (next_domain == this_domain) + __adeos_sync_stage(IPIPE_IRQMASK_ANY); + else + { + __adeos_switch_to(this_domain,next_domain,cpuid); + + adeos_load_cpuid(); /* Processor might have changed. */ + + if (this_domain->cpudata[cpuid].irq_pending_hi != 0 && + !test_bit(IPIPE_SYNC_FLAG,&this_domain->cpudata[cpuid].status) && + !test_bit(IPIPE_STALL_FLAG,&this_domain->cpudata[cpuid].status)) + __adeos_sync_stage(IPIPE_IRQMASK_ANY); + } + + break; + } + else if (next_domain == this_domain) + break; + + pos = next_domain->p_link.next; + } +} + +/* __adeos_handle_irq() -- ADEOS's generic IRQ handler. An optimistic + interrupt protection log is maintained here for each + domain. Interrupts are off on entry. */ + +void __adeos_handle_irq (int irq, struct pt_regs *regs) + +{ + struct list_head *head, *pos; + adeos_declare_cpuid; + int m_ack, s_ack; + + m_ack = irq & ADEOS_IRQ_ACKED; + irq &= ADEOS_IRQ_ACKED_MASK; + + if (irq >= IPIPE_NR_IRQS) + { + printk(KERN_ERR "Adeos: spurious interrupt %d\n",irq); + return; + } + + adeos_load_cpuid(); + +#ifdef CONFIG_ADEOS_PROFILING + __adeos_profile_data[cpuid].irqs[irq].n_handled++; + adeos_hw_tsc(__adeos_profile_data[cpuid].irqs[irq].t_handled); +#endif /* CONFIG_ADEOS_PROFILING */ + + s_ack = m_ack; + + if (test_bit(IPIPE_STICKY_FLAG,&adp_cpu_current[cpuid]->irqs[irq].control)) + head = &adp_cpu_current[cpuid]->p_link; + else + head = __adeos_pipeline.next; + + /* Ack the interrupt. */ + + pos = head; + + while (pos != &__adeos_pipeline) + { + adomain_t *_adp = list_entry(pos,adomain_t,p_link); + + /* For each domain handling the incoming IRQ, mark it as + pending in its log. */ + + if (test_bit(IPIPE_HANDLE_FLAG,&_adp->irqs[irq].control)) + { + /* Domains that handle this IRQ are polled for + acknowledging it by decreasing priority order. The + interrupt must be made pending _first_ in the domain's + status flags before the PIC is unlocked. */ + + _adp->cpudata[cpuid].irq_hits[irq]++; + __adeos_set_irq_bit(_adp,cpuid,irq); + + /* Always get the first master acknowledge available. Once + we've got it, allow slave acknowledge handlers to run + (until one of them stops us). */ + + if (_adp->irqs[irq].acknowledge != NULL) + { + if (!m_ack) + m_ack = _adp->irqs[irq].acknowledge(irq); + else if (test_bit(IPIPE_SHARED_FLAG,&_adp->irqs[irq].control) && !s_ack) + s_ack = _adp->irqs[irq].acknowledge(irq); + } + } + + /* If the domain does not want the IRQ to be passed down the + interrupt pipe, exit the loop now. */ + + if (!test_bit(IPIPE_PASS_FLAG,&_adp->irqs[irq].control)) + break; + + pos = _adp->p_link.next; + } + + /* Now walk the pipeline, yielding control to the highest priority + domain that has pending interrupt(s) or immediately to the + current domain if the interrupt has been marked as + 'sticky'. This search does not go beyond the current domain in + the pipeline. To understand this code properly, one must keep + in mind that domains having a higher priority than the current + one are sleeping on the adeos_suspend_domain() service. In + addition, domains having a lower priority have been preempted + by an interrupt dispatched to a higher priority domain. Once + the first and highest priority stage has been selected here, + the subsequent stages will be activated in turn when each + visited domain calls adeos_suspend_domain() to wake up its + neighbour down the pipeline. */ + + __adeos_walk_pipeline(head,cpuid); +} + +/* ADEOS's version of the interrupt trap handler. */ + +asmlinkage int __adeos_grab_irq (struct pt_regs *regs) + +{ + extern int ppc_spurious_interrupts; + adeos_declare_cpuid; + int irq, first = 1; + + if (!adp_pipelined) + { + do_IRQ(regs); + return 1; + } + + if ((irq = ppc_md.get_irq(regs)) >= 0) + { + __adeos_handle_irq(irq,regs); + first = 0; + } + else if (irq != -2 && first) + ppc_spurious_interrupts++; + + adeos_load_cpuid(); + + return (adp_cpu_current[cpuid] == adp_root && + !test_bit(IPIPE_STALL_FLAG,&adp_root->cpudata[cpuid].status)); +} + +/* ADEOS's version of irq.c:do_IRQ(). */ + +void __adeos_do_IRQ (int irq, struct pt_regs *regs) + +{ + /* irq_enter/exit are notified from our caller, + i.e. __adeos_sync_stage(). */ + __do_IRQ(irq,regs); +} + +/* ADEOS's version of the decrementer trap handler. */ + +asmlinkage int __adeos_grab_timer (struct pt_regs *regs) + +{ + adeos_declare_cpuid; + + if (!adp_pipelined) + { + timer_interrupt(regs); + return 1; + } + +#ifdef CONFIG_POWER4 + /* On 970 CPUs DEC cannot be disabled, and without setting DEC + * here, DEC interrupt would be triggered as soon as interrupts are + * enabled in __adeos_sync_stage + */ + set_dec(0x7fffffff); +#endif + + __adeos_irq_regs.msr = regs->msr; /* for do_timer() */ + + __adeos_handle_irq(ADEOS_TIMER_VIRQ,regs); + + adeos_load_cpuid(); + +#ifndef CONFIG_40x + if (__adeos_decr_ticks != tb_ticks_per_jiffy) + { + unsigned long long next_date, now; + + next_date = __adeos_decr_next[cpuid]; + + while ((now = __adeos_read_timebase()) >= next_date) + next_date += __adeos_decr_ticks; + + set_dec(next_date - now); + + __adeos_decr_next[cpuid] = next_date; + } +#endif /* !CONFIG_40x */ + + return (adp_cpu_current[cpuid] == adp_root && + !test_bit(IPIPE_STALL_FLAG,&adp_root->cpudata[cpuid].status)); +} + +void __adeos_do_timer (int irq, struct pt_regs *regs) + +{ + timer_interrupt(regs); +} + +asmlinkage int __adeos_check_root (struct pt_regs *regs) + +{ + adeos_declare_cpuid; + /* This routine is called with hw interrupts off, so no migration + can occur while checking the identity of the current domain. */ + adeos_load_cpuid(); + return (adp_cpu_current[cpuid] == adp_root && + !test_bit(IPIPE_STALL_FLAG,&adp_root->cpudata[cpuid].status)); +} + +/* adeos_trigger_irq() -- Push the interrupt to the pipeline entry + just like if it has been actually received from a hw source. This + both works for real and virtual interrupts. This also means that + the current domain might be immediately preempted by a higher + priority domain who happens to handle this interrupt. */ + +int adeos_trigger_irq (unsigned irq) + +{ + struct pt_regs regs; + unsigned long flags; + + if (irq >= IPIPE_NR_IRQS || + (adeos_virtual_irq_p(irq) && !test_bit(irq - IPIPE_VIRQ_BASE,&__adeos_virtual_irq_map))) + return -EINVAL; + + adeos_hw_local_irq_save(flags); + + regs.msr = flags; + + __adeos_handle_irq(irq | ADEOS_IRQ_ACKED, ®s); + + adeos_hw_local_irq_restore(flags); + + return 1; +} + +int __adeos_enter_syscall (struct pt_regs *regs) + +{ + adeos_declare_cpuid; + unsigned long flags; + + /* This routine either returns: + 0 -- if the syscall is to be passed to Linux; + 1 -- if the syscall should not be passed to Linux, and no + tail work should be performed; + -1 -- if the syscall should not be passed to Linux but the + tail work has to be performed. */ + + if (__adeos_event_monitors[ADEOS_SYSCALL_PROLOGUE] > 0 && + __adeos_handle_event(ADEOS_SYSCALL_PROLOGUE,regs) > 0) + { + if (adp_current == adp_root && !in_atomic()) + { + /* Sync pending VIRQs before _TIF_NEED_RESCHED is + * tested. */ + + adeos_lock_cpu(flags); + + if ((adp_root->cpudata[cpuid].irq_pending_hi & IPIPE_IRQMASK_VIRT) != 0) + __adeos_sync_stage(IPIPE_IRQMASK_VIRT); + + adeos_unlock_cpu(flags); + + return -1; + } + + return 1; + } + + return 0; +} + +int __adeos_exit_syscall (void) + +{ + if (__adeos_event_monitors[ADEOS_SYSCALL_EPILOGUE] > 0) + return __adeos_handle_event(ADEOS_SYSCALL_EPILOGUE,NULL); + + return 0; +} + +EXPORT_SYMBOL(__adeos_init_stage); +EXPORT_SYMBOL(__adeos_sync_stage); +EXPORT_SYMBOL(__adeos_irq_regs); +#ifdef CONFIG_ADEOS_THREADS +EXPORT_SYMBOL(__adeos_switch_domain); +#endif /* CONFIG_ADEOS_THREADS */ +EXPORT_SYMBOL(__adeos_do_IRQ); +EXPORT_SYMBOL(__adeos_do_timer); +EXPORT_SYMBOL(__adeos_decr_ticks); +EXPORT_SYMBOL(__adeos_decr_next); +EXPORT_SYMBOL(__adeos_current_threadinfo); +EXPORT_SYMBOL(adeos_critical_enter); +EXPORT_SYMBOL(adeos_critical_exit); +EXPORT_SYMBOL(adeos_trigger_irq); diff -uNrp linux-2.6.10/arch/ppc/kernel/entry.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/entry.S --- linux-2.6.10/arch/ppc/kernel/entry.S 2004-12-24 22:35:27.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/entry.S 2005-03-27 16:35:19.000000000 +0200 @@ -143,8 +143,23 @@ END_FTR_SECTION_IFSET(CPU_FTR_CAN_NAP) .globl transfer_to_handler_cont transfer_to_handler_cont: lwz r11,THREAD_INFO-THREAD(r12) +#ifdef CONFIG_ADEOS_CORE + /* Allow for kernel-based local stacks: those must not cause + the stack overflow detection to trigger when some activity has + been preempted over them (e.g. Adeos domain stacks). We just + check if the kernel stack is not treading on the memory area + ranging from ¤t->thread_info to ¤t->thread, which + is coarser than the vanilla implementation, but likely + sensitive enough to catch overflows soon enough though.*/ + addi r9,r11,THREAD + cmplw 0,r1,r11 + cmplw 1,r1,r9 + crand 1,1,4 + bgt- stack_ovf /* if r11 < r1 < r11+THREAD */ +#else /* CONFIG_ADEOS_CORE */ cmplw r1,r11 /* if r1 <= current->thread_info */ ble- stack_ovf /* then the kernel stack overflowed */ +#endif /* CONFIG_ADEOS_CORE */ 3: mflr r9 lwz r11,0(r9) /* virtual address of handler */ @@ -195,6 +210,21 @@ _GLOBAL(DoSyscall) lwz r11,_CCR(r1) /* Clear SO bit in CR */ rlwinm r11,r11,0,4,2 stw r11,_CCR(r1) +#ifdef CONFIG_ADEOS_CORE + addi r3,r1,GPR0 + bl __adeos_enter_syscall + cmpwi r3,0 + lwz r3,GPR3(r1) + lwz r0,GPR0(r1) + lwz r4,GPR4(r1) + lwz r5,GPR5(r1) + lwz r6,GPR6(r1) + lwz r7,GPR7(r1) + lwz r8,GPR8(r1) + lwz r9,GPR9(r1) + bgt .adeos_end_syscall + blt ret_from_syscall +#endif /* CONFIG_ADEOS_CORE */ #ifdef SHOW_SYSCALLS bl do_show_syscall #endif /* SHOW_SYSCALLS */ @@ -215,6 +245,13 @@ syscall_dotrace_cont: mtlr r10 addi r9,r1,STACK_FRAME_OVERHEAD blrl /* Call handler */ +#ifdef CONFIG_ADEOS_CORE + stw r3,RESULT(r1) /* Save result */ + bl __adeos_exit_syscall + cmpwi r3,0 + lwz r3,RESULT(r1) + bne- syscall_exit_cont +#endif /* CONFIG_ADEOS_CORE */ .globl ret_from_syscall ret_from_syscall: #ifdef SHOW_SYSCALLS @@ -262,6 +299,14 @@ syscall_exit_cont: SYNC RFI +#ifdef CONFIG_ADEOS_CORE +.adeos_end_syscall: + LOAD_MSR_KERNEL(r10,MSR_KERNEL) /* doesn't include MSR_EE */ + SYNC + MTMSRD(r10) + b syscall_exit_cont +#endif /* CONFIG_ADEOS_CORE */ + 66: li r3,-ENOSYS b ret_from_syscall @@ -586,6 +631,12 @@ ret_from_except: SYNC /* Some chip revs have problems here... */ MTMSRD(r10) /* disable interrupts */ +#ifdef CONFIG_ADEOS_CORE + bl __adeos_check_root + cmpwi r3, 0 + beq- restore +#endif /* CONFIG_ADEOS_CORE */ + lwz r3,_MSR(r1) /* Returning to user mode? */ andi. r0,r3,MSR_PR beq resume_kernel @@ -1024,3 +1075,119 @@ machine_check_in_rtas: /* XXX load up BATs and panic */ #endif /* CONFIG_PPC_OF */ + +#ifdef CONFIG_ADEOS_CORE + +_GLOBAL(__adeos_ret_from_except) + cmpwi r3, 0 + bne+ ret_from_except + b restore + +#ifdef CONFIG_ADEOS_THREADS + +/* + * r3 = adp_next, r4 = adp_cpu_current[adeos_processor_id()]. + * NOTE: This code is _not_ SMP-compliant. Always called with hw + * interrupts off. + */ +_GLOBAL(__adeos_switch_domain) + + stwu r1,-108-STACK_FRAME_OVERHEAD(r1) + + /* Save general purpose registers. */ + stw r31,STACK_FRAME_OVERHEAD+0*4(r1) + stw r30,STACK_FRAME_OVERHEAD+1*4(r1) + stw r29,STACK_FRAME_OVERHEAD+2*4(r1) + stw r28,STACK_FRAME_OVERHEAD+3*4(r1) + stw r27,STACK_FRAME_OVERHEAD+4*4(r1) + stw r26,STACK_FRAME_OVERHEAD+5*4(r1) + stw r25,STACK_FRAME_OVERHEAD+6*4(r1) + stw r24,STACK_FRAME_OVERHEAD+7*4(r1) + stw r23,STACK_FRAME_OVERHEAD+8*4(r1) + stw r22,STACK_FRAME_OVERHEAD+9*4(r1) + stw r21,STACK_FRAME_OVERHEAD+10*4(r1) + stw r20,STACK_FRAME_OVERHEAD+11*4(r1) + stw r19,STACK_FRAME_OVERHEAD+12*4(r1) + stw r18,STACK_FRAME_OVERHEAD+13*4(r1) + stw r17,STACK_FRAME_OVERHEAD+14*4(r1) + stw r16,STACK_FRAME_OVERHEAD+15*4(r1) + stw r15,STACK_FRAME_OVERHEAD+16*4(r1) + stw r14,STACK_FRAME_OVERHEAD+17*4(r1) + stw r13,STACK_FRAME_OVERHEAD+18*4(r1) + stw r3,STACK_FRAME_OVERHEAD+19*4(r1) + stw r2,STACK_FRAME_OVERHEAD+20*4(r1) + stw r0,STACK_FRAME_OVERHEAD+21*4(r1) + + /* Save special registers. */ + mfctr r2 + stw r2,STACK_FRAME_OVERHEAD+22*4(r1) + mfcr r2 + stw r2,STACK_FRAME_OVERHEAD+23*4(r1) + mfxer r2 + stw r2,STACK_FRAME_OVERHEAD+24*4(r1) + mflr r2 + stw r2,STACK_FRAME_OVERHEAD+25*4(r1) + mfmsr r2 + stw r2,STACK_FRAME_OVERHEAD+26*4(r1) + + /* Actual switch block. */ + lwz r2,0(r4) /* r2 = old_adp = adp_cpu_current[cpuid] */ + stw r1,0(r2) /* old_adp->esp[0] = sp */ + stw r3,0(r4) /* adp_cpu_current[cpuid] = new_adp */ + /* CONFIG_SMP should sync here; but first, accesses to esp[] + would require cpuid-indexing. */ + lwz r1,0(r3) /* sp = new_adp->esp[0] */ + + /* Restore special registers. */ + lwz r2,STACK_FRAME_OVERHEAD+26*4(r1) + mtmsr r2 + lwz r2,STACK_FRAME_OVERHEAD+25*4(r1) + mtlr r2 + lwz r2,STACK_FRAME_OVERHEAD+24*4(r1) + mtxer r2 + lwz r2,STACK_FRAME_OVERHEAD+23*4(r1) + mtcr r2 + lwz r2,STACK_FRAME_OVERHEAD+22*4(r1) + mtctr r2 + + /* Restore general purpose registers. */ + lwz r0,STACK_FRAME_OVERHEAD+21*4(r1) + lwz r2,STACK_FRAME_OVERHEAD+20*4(r1) + lwz r3,STACK_FRAME_OVERHEAD+19*4(r1) + lwz r13,STACK_FRAME_OVERHEAD+18*4(r1) + lwz r14,STACK_FRAME_OVERHEAD+17*4(r1) + lwz r15,STACK_FRAME_OVERHEAD+16*4(r1) + lwz r16,STACK_FRAME_OVERHEAD+15*4(r1) + lwz r17,STACK_FRAME_OVERHEAD+14*4(r1) + lwz r18,STACK_FRAME_OVERHEAD+13*4(r1) + lwz r19,STACK_FRAME_OVERHEAD+12*4(r1) + lwz r20,STACK_FRAME_OVERHEAD+11*4(r1) + lwz r21,STACK_FRAME_OVERHEAD+10*4(r1) + lwz r22,STACK_FRAME_OVERHEAD+9*4(r1) + lwz r23,STACK_FRAME_OVERHEAD+8*4(r1) + lwz r24,STACK_FRAME_OVERHEAD+7*4(r1) + lwz r25,STACK_FRAME_OVERHEAD+6*4(r1) + lwz r26,STACK_FRAME_OVERHEAD+5*4(r1) + lwz r27,STACK_FRAME_OVERHEAD+4*4(r1) + lwz r28,STACK_FRAME_OVERHEAD+3*4(r1) + lwz r29,STACK_FRAME_OVERHEAD+2*4(r1) + lwz r30,STACK_FRAME_OVERHEAD+1*4(r1) + lwz r31,STACK_FRAME_OVERHEAD+0*4(r1) + + addi r1,r1,108+STACK_FRAME_OVERHEAD + + blr + +#endif /* CONFIG_ADEOS_THREADS */ + +/* Returns the current threadinfo pointer in a way which is + insensitive to the underlying stack, by directly reading the + special purpose register #3. */ + +_GLOBAL(__adeos_current_threadinfo) + mfspr r3,SPRG3 + addi r3,r3,-THREAD + tovirt(r3,r3) + blr + +#endif /* CONFIG_ADEOS_CORE */ diff -uNrp linux-2.6.10/arch/ppc/kernel/head.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/head.S --- linux-2.6.10/arch/ppc/kernel/head.S 2004-12-24 22:34:58.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head.S 2005-03-27 16:35:19.000000000 +0200 @@ -339,6 +339,12 @@ i##n: \ EXC_XFER_TEMPLATE(n, hdlr, n+1, NOCOPY, transfer_to_handler, \ ret_from_except) +#ifdef CONFIG_ADEOS_CORE +#define EXC_XFER_ADEOS_LITE(n, hdlr) \ + EXC_XFER_TEMPLATE(n, hdlr, n+1, NOCOPY, transfer_to_handler, \ + __adeos_ret_from_except) +#endif /* CONFIG_ADEOS_CORE */ + #define EXC_XFER_EE(n, hdlr) \ EXC_XFER_TEMPLATE(n, hdlr, n, COPY_EE, transfer_to_handler_full, \ ret_from_except_full) @@ -445,7 +451,11 @@ InstructionAccess: #endif /* CONFIG_PPC64BRIDGE */ /* External interrupt */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x500, HardwareInterrupt, __adeos_grab_irq, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x500, HardwareInterrupt, do_IRQ, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ /* Alignment exception */ . = 0x600 @@ -470,7 +480,11 @@ FPUnavailable: EXC_XFER_EE_LITE(0x800, KernelFP) /* Decrementer */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x900, Decrementer, __adeos_grab_timer, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x900, Decrementer, timer_interrupt, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ EXCEPTION(0xa00, Trap_0a, UnknownException, EXC_XFER_EE) EXCEPTION(0xb00, Trap_0b, UnknownException, EXC_XFER_EE) diff -uNrp linux-2.6.10/arch/ppc/kernel/head_44x.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_44x.S --- linux-2.6.10/arch/ppc/kernel/head_44x.S 2004-12-24 22:34:29.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_44x.S 2005-03-27 16:35:19.000000000 +0200 @@ -421,7 +421,11 @@ interrupt_base: EXC_XFER_EE_LITE(0x0400, handle_page_fault) /* External Input Interrupt */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x0500, ExternalInput, __adeos_grab_irq, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x0500, ExternalInput, do_IRQ, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ /* Alignment Interrupt */ START_EXCEPTION(Alignment) @@ -456,7 +460,11 @@ interrupt_base: lis r0,TSR_DIS@h /* Setup the DEC interrupt mask */ mtspr SPRN_TSR,r0 /* Clear the DEC interrupt */ addi r3,r1,STACK_FRAME_OVERHEAD +#ifdef CONFIG_ADEOS_CORE + EXC_XFER_ADEOS_LITE(0x1000, __adeos_grab_timer) +#else /* !CONFIG_ADEOS_CORE */ EXC_XFER_LITE(0x1000, timer_interrupt) +#endif /* CONFIG_ADEOS_CORE */ /* Fixed Internal Timer Interrupt */ /* TODO: Add FIT support */ diff -uNrp linux-2.6.10/arch/ppc/kernel/head_4xx.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_4xx.S --- linux-2.6.10/arch/ppc/kernel/head_4xx.S 2004-12-24 22:35:39.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_4xx.S 2005-03-27 16:35:19.000000000 +0200 @@ -272,7 +272,13 @@ label: EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, NOCOPY, transfer_to_handler, \ ret_from_except) -#define EXC_XFER_EE(n, hdlr) \ +#ifdef CONFIG_ADEOS_CORE +#define EXC_XFER_ADEOS_LITE(n, hdlr) \ + EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, NOCOPY, transfer_to_handler, \ + __adeos_ret_from_except) +#endif /* CONFIG_ADEOS_CORE */ + + #define EXC_XFER_EE(n, hdlr) \ EXC_XFER_TEMPLATE(hdlr, n, MSR_KERNEL, COPY_EE, transfer_to_handler_full, \ ret_from_except_full) @@ -280,7 +286,6 @@ label: EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, COPY_EE, transfer_to_handler, \ ret_from_except) - /* * 0x0100 - Critical Interrupt Exception */ @@ -435,7 +440,11 @@ label: EXC_XFER_EE_LITE(0x400, handle_page_fault) /* 0x0500 - External Interrupt Exception */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x0500, HardwareInterrupt, __adeos_grab_irq, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x0500, HardwareInterrupt, do_IRQ, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ /* 0x0600 - Alignment Exception */ START_EXCEPTION(0x0600, Alignment) @@ -473,7 +482,11 @@ label: lis r0,TSR_PIS@h mtspr SPRN_TSR,r0 /* Clear the PIT exception */ addi r3,r1,STACK_FRAME_OVERHEAD +#ifdef CONFIG_ADEOS_CORE + EXC_XFER_ADEOS_LITE(0x1000, __adeos_grab_timer) +#else /* !CONFIG_ADEOS_CORE */ EXC_XFER_LITE(0x1000, timer_interrupt) +#endif /* CONFIG_ADEOS_CORE */ #if 0 /* NOTE: diff -uNrp linux-2.6.10/arch/ppc/kernel/head_8xx.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_8xx.S --- linux-2.6.10/arch/ppc/kernel/head_8xx.S 2004-12-24 22:34:44.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_8xx.S 2005-03-27 16:35:19.000000000 +0200 @@ -194,7 +194,13 @@ i##n: \ EXC_XFER_TEMPLATE(n, hdlr, n+1, NOCOPY, transfer_to_handler, \ ret_from_except) -#define EXC_XFER_EE(n, hdlr) \ +#ifdef CONFIG_ADEOS_CORE +#define EXC_XFER_ADEOS_LITE(n, hdlr) \ + EXC_XFER_TEMPLATE(n, hdlr, n+1, NOCOPY, transfer_to_handler, \ + __adeos_ret_from_except) +#endif /* CONFIG_ADEOS_CORE */ + + #define EXC_XFER_EE(n, hdlr) \ EXC_XFER_TEMPLATE(n, hdlr, n, COPY_EE, transfer_to_handler_full, \ ret_from_except_full) @@ -241,7 +247,11 @@ InstructionAccess: EXC_XFER_EE_LITE(0x400, handle_page_fault) /* External interrupt */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x500, HardwareInterrupt, __adeos_grab_irq, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x500, HardwareInterrupt, do_IRQ, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ /* Alignment exception */ . = 0x600 @@ -262,7 +272,11 @@ Alignment: EXCEPTION(0x800, FPUnavailable, UnknownException, EXC_XFER_STD) /* Decrementer */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x900, Decrementer, __adeos_grab_timer, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x900, Decrementer, timer_interrupt, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ EXCEPTION(0xa00, Trap_0a, UnknownException, EXC_XFER_EE) EXCEPTION(0xb00, Trap_0b, UnknownException, EXC_XFER_EE) diff -uNrp linux-2.6.10/arch/ppc/kernel/head_booke.h linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_booke.h --- linux-2.6.10/arch/ppc/kernel/head_booke.h 2004-12-24 22:33:51.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_booke.h 2005-03-27 16:35:19.000000000 +0200 @@ -228,6 +228,12 @@ label: EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, NOCOPY, transfer_to_handler, \ ret_from_except) +#ifdef CONFIG_ADEOS_CORE +#define EXC_XFER_ADEOS_LITE(n, hdlr) \ + EXC_XFER_TEMPLATE(hdlr, n+1, MSR_KERNEL, NOCOPY, transfer_to_handler, \ + __adeos_ret_from_except) +#endif /* CONFIG_ADEOS_CORE */ + #define EXC_XFER_EE(n, hdlr) \ EXC_XFER_TEMPLATE(hdlr, n, MSR_KERNEL, COPY_EE, transfer_to_handler_full, \ ret_from_except_full) diff -uNrp linux-2.6.10/arch/ppc/kernel/head_e500.S linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_e500.S --- linux-2.6.10/arch/ppc/kernel/head_e500.S 2004-12-24 22:35:23.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/head_e500.S 2005-03-27 16:35:19.000000000 +0200 @@ -473,7 +473,11 @@ interrupt_base: EXC_XFER_EE_LITE(0x0400, handle_page_fault) /* External Input Interrupt */ +#ifdef CONFIG_ADEOS_CORE + EXCEPTION(0x0500, ExternalInput, __adeos_grab_irq, EXC_XFER_ADEOS_LITE) +#else /* !CONFIG_ADEOS_CORE */ EXCEPTION(0x0500, ExternalInput, do_IRQ, EXC_XFER_LITE) +#endif /* CONFIG_ADEOS_CORE */ /* Alignment Interrupt */ START_EXCEPTION(Alignment) @@ -508,7 +512,11 @@ interrupt_base: lis r0,TSR_DIS@h /* Setup the DEC interrupt mask */ mtspr SPRN_TSR,r0 /* Clear the DEC interrupt */ addi r3,r1,STACK_FRAME_OVERHEAD +#ifdef CONFIG_ADEOS_CORE + EXC_XFER_ADEOS_LITE(0x0900, __adeos_grab_timer) +#else /* !CONFIG_ADEOS_CORE */ EXC_XFER_LITE(0x0900, timer_interrupt) +#endif /* CONFIG_ADEOS_CORE */ /* Fixed Internal Timer Interrupt */ /* TODO: Add FIT support */ diff -uNrp linux-2.6.10/arch/ppc/kernel/idle.c linux-2.6.10-ppc-adeos/arch/ppc/kernel/idle.c --- linux-2.6.10/arch/ppc/kernel/idle.c 2004-12-24 22:33:49.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/idle.c 2005-07-01 19:19:23.000000000 +0200 @@ -59,11 +59,16 @@ void default_idle(void) */ int cpu_idle(void) { - for (;;) + for (;;) { +#ifdef CONFIG_ADEOS_CORE + adeos_suspend_domain(); +#endif /* CONFIG_ADEOS_CORE */ + if (ppc_md.idle != NULL) ppc_md.idle(); else default_idle(); + } return 0; } diff -uNrp linux-2.6.10/arch/ppc/kernel/ppc_ksyms.c linux-2.6.10-ppc-adeos/arch/ppc/kernel/ppc_ksyms.c --- linux-2.6.10/arch/ppc/kernel/ppc_ksyms.c 2004-12-24 22:35:28.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/ppc_ksyms.c 2005-03-27 16:35:19.000000000 +0200 @@ -346,3 +346,28 @@ EXPORT_SYMBOL(agp_special_page); EXPORT_SYMBOL(__mtdcr); EXPORT_SYMBOL(__mfdcr); #endif + +#ifdef CONFIG_ADEOS_CORE +/* The following are per-platform convenience exports which are needed + by some Adeos domains loaded as kernel modules. */ +EXPORT_SYMBOL(__switch_to); +void show_stack(struct task_struct *task, + unsigned long *esp); +EXPORT_SYMBOL(show_stack); +void atomic_set_mask(unsigned long mask, + unsigned long *ptr); +EXPORT_SYMBOL(atomic_set_mask); +void atomic_clear_mask(unsigned long mask, + unsigned long *ptr); +EXPORT_SYMBOL(atomic_clear_mask); +extern unsigned long context_map[]; +EXPORT_SYMBOL(context_map); +EXPORT_SYMBOL(_switch); +#ifdef FEW_CONTEXTS +EXPORT_SYMBOL(nr_free_contexts); +EXPORT_SYMBOL(context_mm); +EXPORT_SYMBOL(steal_context); +#endif +extern struct task_struct *last_task_used_math; +EXPORT_SYMBOL(last_task_used_math); +#endif /* CONFIG_ADEOS_CORE */ diff -uNrp linux-2.6.10/arch/ppc/kernel/traps.c linux-2.6.10-ppc-adeos/arch/ppc/kernel/traps.c --- linux-2.6.10/arch/ppc/kernel/traps.c 2004-12-24 22:34:26.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/kernel/traps.c 2005-05-15 11:10:33.000000000 +0200 @@ -78,6 +78,12 @@ void die(const char * str, struct pt_reg { static int die_counter; int nl = 0; + +#ifdef CONFIG_ADEOS_CORE + /* lets us see Oopses from other domains, too */ + if (adp_current != adp_root) + adeos_set_printk_sync(adp_current); +#endif /* CONFIG_ADEOS_CORE */ console_verbose(); spin_lock_irq(&die_lock); #ifdef CONFIG_PMAC_BACKLIGHT @@ -199,10 +205,22 @@ static inline int check_io_access(struct #define clear_single_step(regs) ((regs)->msr &= ~MSR_SE) #endif +#ifdef CONFIG_ADEOS_CORE +static inline int __adeos_pipeline_trap(int trap, struct pt_regs *regs) +{ + return __adeos_event_monitors[trap] > 0 ? __adeos_handle_event(trap,regs) : 0; +} +#endif /* CONFIG_ADEOS_CORE */ + void MachineCheckException(struct pt_regs *regs) { unsigned long reason = get_mc_reason(regs); +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_MCE_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + if (user_mode(regs)) { regs->msr |= MSR_RI; _exception(SIGBUS, regs, BUS_ADRERR, regs->nip); @@ -338,6 +356,10 @@ void SMIException(struct pt_regs *regs) void UnknownException(struct pt_regs *regs) { +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_UNKNOWN_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ printk("Bad trap at PC: %lx, MSR: %lx, vector=%lx %s\n", regs->nip, regs->msr, regs->trap, print_tainted()); _exception(SIGTRAP, regs, 0, 0); @@ -345,6 +367,10 @@ void UnknownException(struct pt_regs *re void InstructionBreakpoint(struct pt_regs *regs) { +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_IABR_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ if (debugger_iabr_match(regs)) return; _exception(SIGTRAP, regs, TRAP_BRKPT, 0); @@ -352,6 +378,10 @@ void InstructionBreakpoint(struct pt_reg void RunModeException(struct pt_regs *regs) { +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_RM_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ _exception(SIGTRAP, regs, 0, 0); } @@ -421,6 +451,10 @@ static void emulate_single_step(struct p { if (single_stepping(regs)) { clear_single_step(regs); +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_SSTEP_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ _exception(SIGTRAP, regs, TRAP_TRACE, 0); } } @@ -490,6 +524,11 @@ void ProgramCheckException(struct pt_reg unsigned int reason = get_reason(regs); extern int do_mathemu(struct pt_regs *regs); +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_PCE_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + #ifdef CONFIG_MATH_EMULATION /* (reason & REASON_ILLEGAL) would be the obvious thing here, * but there seems to be a hardware bug on the 405GP (RevD) @@ -567,6 +606,10 @@ void ProgramCheckException(struct pt_reg void SingleStepException(struct pt_regs *regs) { regs->msr &= ~MSR_SE; /* Turn off 'trace' bit */ +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_SSTEP_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ if (debugger_sstep(regs)) return; _exception(SIGTRAP, regs, TRAP_TRACE, 0); @@ -581,6 +624,12 @@ void AlignmentException(struct pt_regs * regs->nip += 4; /* skip over emulated instruction */ return; } +#ifdef CONFIG_ADEOS_CORE + /* Assume that fixing alignment can always be done regardless + of the current domain. */ + if (__adeos_pipeline_trap(ADEOS_ALIGNMENT_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ if (fixed == -EFAULT) { /* fixed == -EFAULT means the operand address was bad */ if (user_mode(regs)) @@ -603,6 +652,10 @@ void StackOverflow(struct pt_regs *regs) void nonrecoverable_exception(struct pt_regs *regs) { +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_NREC_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ printk(KERN_ERR "Non-recoverable exception at PC=%lx MSR=%lx\n", regs->nip, regs->msr); debugger(regs); @@ -623,6 +676,11 @@ void SoftwareEmulation(struct pt_regs *r extern int Soft_emulate_8xx(struct pt_regs *); int errcode; +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_SOFTEMU_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + CHECK_FULL_REGS(regs); if (!user_mode(regs)) { @@ -651,6 +709,10 @@ void SoftwareEmulation(struct pt_regs *r void DebugException(struct pt_regs *regs, unsigned long debug_status) { +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_DEBUG_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ if (debug_status & DBSR_IC) { /* instruction completion */ regs->msr &= ~MSR_DE; if (user_mode(regs)) { @@ -680,6 +742,11 @@ void AltivecUnavailException(struct pt_r { static int kernel_altivec_count; +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_ALTUNAVAIL_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + #ifndef CONFIG_ALTIVEC if (user_mode(regs)) { /* A user program has executed an altivec instruction, @@ -701,6 +768,11 @@ void AltivecAssistException(struct pt_re { int err; +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_ALTASSIST_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + preempt_disable(); if (regs->msr & MSR_VEC) giveup_altivec(current); @@ -747,6 +819,11 @@ void SPEFloatingPointException(struct pt int fpexc_mode; int code = 0; +#ifdef CONFIG_ADEOS_CORE + if (__adeos_pipeline_trap(ADEOS_SPE_TRAP,regs)) + return; +#endif /* CONFIG_ADEOS_CORE */ + spefscr = current->thread.spefscr; fpexc_mode = current->thread.fpexc_mode; diff -uNrp linux-2.6.10/arch/ppc/mm/fault.c linux-2.6.10-ppc-adeos/arch/ppc/mm/fault.c --- linux-2.6.10/arch/ppc/mm/fault.c 2004-12-24 22:34:29.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/mm/fault.c 2005-03-27 16:35:19.000000000 +0200 @@ -116,6 +116,12 @@ int do_page_fault(struct pt_regs *regs, is_write = error_code & 0x02000000; #endif /* CONFIG_4xx || CONFIG_BOOKE */ +#ifdef CONFIG_ADEOS_CORE + if (__adeos_event_monitors[ADEOS_ACCESS_TRAP] > 0 && + __adeos_handle_event(ADEOS_ACCESS_TRAP,regs) != 0) + return 0; +#endif /* CONFIG_ADEOS_CORE */ + #if defined(CONFIG_XMON) || defined(CONFIG_KGDB) if (debugger_fault_handler && TRAP(regs) == 0x300) { debugger_fault_handler(regs); diff -uNrp linux-2.6.10/arch/ppc/platforms/pmac_pic.c linux-2.6.10-ppc-adeos/arch/ppc/platforms/pmac_pic.c --- linux-2.6.10/arch/ppc/platforms/pmac_pic.c 2004-12-24 22:35:28.000000000 +0100 +++ linux-2.6.10-ppc-adeos/arch/ppc/platforms/pmac_pic.c 2005-05-25 23:42:45.000000000 +0200 @@ -387,7 +387,12 @@ static irqreturn_t k2u3_action(int cpl, return IRQ_HANDLED; } +#ifdef CONFIG_ADEOS_CORE +/* this is used in kernel/adeos.c adeos_acknowledge_irq */ +struct irqaction k2u3_cascade_action = { +#else /* !CONFIG_ADEOS_CORE */ static struct irqaction k2u3_cascade_action = { +#endif /* CONFIG_ADEOS_CORE */ .handler = k2u3_action, .flags = 0, .mask = CPU_MASK_NONE, diff -uNrp linux-2.6.10/include/asm-ppc/adeos.h linux-2.6.10-ppc-adeos/include/asm-ppc/adeos.h --- linux-2.6.10/include/asm-ppc/adeos.h 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/asm-ppc/adeos.h 2005-07-15 18:29:59.000000000 +0200 @@ -0,0 +1,451 @@ +/* + * include/asm-ppc/adeos.h + * + * Copyright (C) 2004 Philippe Gerum. + * + * Adeos/PPC port over 2.6 based on the previous 2.4 implementation by: + * + * Copyright (C) 2004 Wolfgang Grandegger. + * + * It follows closely the ARM and x86 ports of ADEOS. + * + * Copyright (C) 2002 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PPC_ADEOS_H +#define __PPC_ADEOS_H + +#include +#include +#include +#include +#include +#include + +#define ADEOS_ARCH_STRING "r8c1/ppc" +#define ADEOS_MAJOR_NUMBER 8 +#define ADEOS_MINOR_NUMBER 1 + +#define ADEOS_IRQ_ACKED 0x1000 +#define ADEOS_IRQ_ACKED_MASK (ADEOS_IRQ_ACKED - 1) + +#ifdef CONFIG_SMP + +#error "Adeos/ppc: SMP not yet implemented" + +#define ADEOS_NR_CPUS NR_CPUS +#define ADEOS_CRITICAL_IPI 0 + +#define adeos_processor_id() (__adeos_current_threadinfo()->cpu) + +#define adeos_declare_cpuid int cpuid +#define adeos_load_cpuid() do { \ + (cpuid) = adeos_processor_id(); \ + } while(0) +#define adeos_lock_cpu(flags) do { \ + adeos_hw_local_irq_save(flags); \ + (cpuid) = adeos_processor_id(); \ + } while(0) +#define adeos_unlock_cpu(flags) adeos_hw_local_irq_restore(flags) +#define adeos_get_cpu(flags) adeos_lock_cpu(flags) +#define adeos_put_cpu(flags) adeos_unlock_cpu(flags) +#define adp_current (adp_cpu_current[adeos_processor_id()]) + +#else /* !CONFIG_SMP */ + +#define ADEOS_NR_CPUS 1 +#define adeos_processor_id() 0 +/* Array references using this index should be optimized out. */ +#define adeos_declare_cpuid const int cpuid = 0 +#define adeos_load_cpuid() /* nop */ +#define adeos_lock_cpu(flags) adeos_hw_local_irq_save(flags) +#define adeos_unlock_cpu(flags) adeos_hw_local_irq_restore(flags) +#define adeos_get_cpu(flags) do { flags = flags; } while(0) +#define adeos_put_cpu(flags) /* nop */ +#define adp_current (adp_cpu_current[0]) + +#endif /* CONFIG_SMP */ + + /* PPC traps */ +#define ADEOS_ACCESS_TRAP 0 /* Data or instruction access exception */ +#define ADEOS_ALIGNMENT_TRAP 1 /* Alignment exception */ +#define ADEOS_ALTUNAVAIL_TRAP 2 /* Altivec unavailable */ +#define ADEOS_PCE_TRAP 3 /* Program check exception */ +#define ADEOS_MCE_TRAP 4 /* Machine check exception */ +#define ADEOS_UNKNOWN_TRAP 5 /* Unknown exception */ +#define ADEOS_IABR_TRAP 6 /* Instruction breakpoint */ +#define ADEOS_RM_TRAP 7 /* Run mode exception */ +#define ADEOS_SSTEP_TRAP 8 /* Single-step exception */ +#define ADEOS_NREC_TRAP 9 /* Non-recoverable exception */ +#define ADEOS_SOFTEMU_TRAP 10 /* Software emulation */ +#define ADEOS_DEBUG_TRAP 11 /* Debug exception */ +#define ADEOS_SPE_TRAP 12 /* SPE exception */ +#define ADEOS_ALTASSIST_TRAP 13 /* Altivec assist exception */ +#define ADEOS_NR_FAULTS 14 +/* Pseudo-vectors used for kernel events */ +#define ADEOS_FIRST_KEVENT ADEOS_NR_FAULTS +#define ADEOS_SYSCALL_PROLOGUE (ADEOS_FIRST_KEVENT) +#define ADEOS_SYSCALL_EPILOGUE (ADEOS_FIRST_KEVENT + 1) +#define ADEOS_SCHEDULE_HEAD (ADEOS_FIRST_KEVENT + 2) +#define ADEOS_SCHEDULE_TAIL (ADEOS_FIRST_KEVENT + 3) +#define ADEOS_ENTER_PROCESS (ADEOS_FIRST_KEVENT + 4) +#define ADEOS_EXIT_PROCESS (ADEOS_FIRST_KEVENT + 5) +#define ADEOS_SIGNAL_PROCESS (ADEOS_FIRST_KEVENT + 6) +#define ADEOS_KICK_PROCESS (ADEOS_FIRST_KEVENT + 7) +#define ADEOS_RENICE_PROCESS (ADEOS_FIRST_KEVENT + 8) +#define ADEOS_USER_EVENT (ADEOS_FIRST_KEVENT + 9) +#define ADEOS_LAST_KEVENT (ADEOS_USER_EVENT) + +#define ADEOS_NR_EVENTS (ADEOS_LAST_KEVENT + 1) + +typedef struct adevinfo { + + unsigned domid; + unsigned event; + void *evdata; + + volatile int propagate; /* Private */ + +} adevinfo_t; + +typedef struct adsysinfo { + + int ncpus; /* Number of CPUs on board */ + + u64 cpufreq; /* CPU frequency (in Hz) */ + + /* Arch-dependent block */ + + struct { + unsigned tmirq; /* Decrementer virtual IRQ */ + u64 tmfreq; /* Timebase frequency */ + } archdep; + +} adsysinfo_t; + +#define IPIPE_NR_XIRQS NR_IRQS +/* Number of virtual IRQs */ +#define IPIPE_NR_VIRQS BITS_PER_LONG +/* First virtual IRQ # */ +#define IPIPE_VIRQ_BASE (((IPIPE_NR_XIRQS + BITS_PER_LONG - 1) / BITS_PER_LONG) * BITS_PER_LONG) +/* Total number of IRQ slots */ +#define IPIPE_NR_IRQS (IPIPE_VIRQ_BASE + IPIPE_NR_VIRQS) +/* Number of indirect words needed to map the whole IRQ space. */ +#define IPIPE_IRQ_IWORDS ((IPIPE_NR_IRQS + BITS_PER_LONG - 1) / BITS_PER_LONG) +#define IPIPE_IRQ_IMASK (BITS_PER_LONG - 1) +#define IPIPE_IRQ_ISHIFT 5 /* 2^5 for 32bits arch. */ + +#define IPIPE_IRQMASK_ANY (~0L) +#define IPIPE_IRQMASK_VIRT (IPIPE_IRQMASK_ANY << (IPIPE_VIRQ_BASE / BITS_PER_LONG)) + +/* The first virtual interrupt is reserved for the timer (see + __adeos_init_platform). */ +#define ADEOS_TIMER_VIRQ IPIPE_VIRQ_BASE + +typedef struct adomain { + + /* -- Section: offset-based references are made on these fields + from inline assembly code. Please don't move or reorder. */ +#ifdef CONFIG_ADEOS_THREADS + unsigned long esp[ADEOS_NR_CPUS]; /* Domain stack pointers */ +#endif /* CONFIG_ADEOS_THREADS */ + void (*dswitch)(void); /* Domain switch hook */ + /* -- End of section. */ + + struct list_head p_link; /* Link in pipeline */ + + struct adcpudata { + unsigned long status; + unsigned long irq_pending_hi; + unsigned long irq_pending_lo[IPIPE_IRQ_IWORDS]; + unsigned irq_hits[IPIPE_NR_IRQS]; +#ifdef CONFIG_ADEOS_THREADS + adevinfo_t event_info; +#endif /* CONFIG_ADEOS_THREADS */ + } cpudata[ADEOS_NR_CPUS]; + + struct { + int (*acknowledge)(unsigned irq); + void (*handler)(unsigned irq); + unsigned long control; + } irqs[IPIPE_NR_IRQS]; + + struct { + void (*handler)(adevinfo_t *evinfo); + } events[ADEOS_NR_EVENTS]; + + struct adomain *m_link; /* Link in mutex sleep queue */ + + unsigned long flags; + + unsigned domid; + + const char *name; + + int priority; + + int ptd_keymax; + int ptd_keycount; + unsigned long ptd_keymap; + void (*ptd_setfun)(int, void *); + void *(*ptd_getfun)(int); + +#ifdef CONFIG_ADEOS_THREADS + unsigned long estackbase[ADEOS_NR_CPUS]; +#endif /* CONFIG_ADEOS_THREADS */ + +} adomain_t; + +/* The following macros must be used hw interrupts off. */ + +#define __adeos_set_irq_bit(adp,cpuid,irq) \ +do { \ + if (!test_bit(IPIPE_LOCK_FLAG,&(adp)->irqs[irq].control)) { \ + __set_bit(irq & IPIPE_IRQ_IMASK,&(adp)->cpudata[cpuid].irq_pending_lo[irq >> IPIPE_IRQ_ISHIFT]); \ + __set_bit(irq >> IPIPE_IRQ_ISHIFT,&(adp)->cpudata[cpuid].irq_pending_hi); \ + } \ +} while(0) + +#define __adeos_clear_pend(adp,cpuid,irq) \ +do { \ + __clear_bit(irq & IPIPE_IRQ_IMASK,&(adp)->cpudata[cpuid].irq_pending_lo[irq >> IPIPE_IRQ_ISHIFT]); \ + if ((adp)->cpudata[cpuid].irq_pending_lo[irq >> IPIPE_IRQ_ISHIFT] == 0) \ + __clear_bit(irq >> IPIPE_IRQ_ISHIFT,&(adp)->cpudata[cpuid].irq_pending_hi); \ +} while(0) + +#define __adeos_lock_irq(adp,cpuid,irq) \ +do { \ + if (!test_and_set_bit(IPIPE_LOCK_FLAG,&(adp)->irqs[irq].control)) \ + __adeos_clear_pend(adp,cpuid,irq); \ +} while(0) + +#define __adeos_unlock_irq(adp,irq) \ +do { \ + if (test_and_clear_bit(IPIPE_LOCK_FLAG,&(adp)->irqs[irq].control)) { \ + int __cpuid, __nr_cpus = num_online_cpus(); \ + for (__cpuid = 0; __cpuid < __nr_cpus; __cpuid++) \ + if ((adp)->cpudata[__cpuid].irq_hits[irq] > 0) { /* We need atomic ops next. */ \ + set_bit(irq & IPIPE_IRQ_IMASK,&(adp)->cpudata[__cpuid].irq_pending_lo[irq >> IPIPE_IRQ_ISHIFT]); \ + set_bit(irq >> IPIPE_IRQ_ISHIFT,&(adp)->cpudata[__cpuid].irq_pending_hi); \ + } \ + } \ +} while(0) + +#define __adeos_clear_irq(adp,irq) \ +do { \ + int __cpuid, __nr_cpus = num_online_cpus(); \ + clear_bit(IPIPE_LOCK_FLAG,&(adp)->irqs[irq].control); \ + for (__cpuid = 0; __cpuid < __nr_cpus; __cpuid++) { \ + (adp)->cpudata[__cpuid].irq_hits[irq] = 0; \ + __adeos_clear_pend(adp,__cpuid,irq); \ + } \ +} while(0) + +#define adeos_virtual_irq_p(irq) ((irq) >= IPIPE_VIRQ_BASE && \ + (irq) < IPIPE_NR_IRQS) + +static inline void adeos_hw_local_irq_save_ptr(unsigned long *flags) +{ + unsigned long msr; + msr = mfmsr(); + *flags = msr; + mtmsr(msr & ~MSR_EE); + __asm__ __volatile__("": : :"memory"); +} + +#define adeos_hw_local_irq_save_flags(flags) adeos_hw_local_irq_save_ptr(&(flags)) +#define adeos_hw_local_irq_restore(flags) mtmsr(flags) + +static inline void adeos_hw_local_irq_disable(void) +{ + unsigned long msr; + msr = mfmsr(); + mtmsr(msr & ~MSR_EE); + __asm__ __volatile__("": : :"memory"); +} + +static inline void adeos_hw_local_irq_enable(void) +{ + unsigned long msr; + __asm__ __volatile__("": : :"memory"); + msr = mfmsr(); + mtmsr(msr | MSR_EE); +} + +#define adeos_hw_local_irq_save(flags) ({adeos_hw_local_irq_save_flags(flags);adeos_hw_local_irq_disable();}) +#define adeos_hw_save_flags_and_sti(flags) ({adeos_hw_local_irq_save_flags(flags);adeos_hw_local_irq_enable();}) + +#define adeos_hw_cli() adeos_hw_local_irq_disable() +#define adeos_hw_sti() adeos_hw_local_irq_enable() + +#define adeos_hw_local_irq_flags(flags) asm volatile("mfmsr %0" : "=r" (flags)) +#define adeos_hw_test_iflag(x) ((x) & MSR_EE) +#define adeos_hw_irqs_disabled() \ +({ \ + unsigned long flags; \ + adeos_hw_local_irq_flags(flags);\ + !adeos_hw_test_iflag(flags); \ +}) + +/* Get the machine TSC by copying the time base registers contents to + the destination variable. Assuming big-endianess here. */ + +#define adeos_hw_tsc(t) \ +({ unsigned long __tbu; \ + __asm__ __volatile__ ("1: mftbu %0\n" \ + "mftb %1\n" \ + "mftbu %2\n" \ + "cmpw %2,%0\n" \ + "bne- 1b\n" \ + :"=r" (((unsigned long *)&t)[0]), \ + "=r" (((unsigned long *)&t)[1]), \ + "=r" (__tbu)); \ + t; }) + +extern unsigned tb_ticks_per_jiffy; + +#define adeos_cpu_freq() (HZ * tb_ticks_per_jiffy) + +#define adeos_spin_lock(x) _spin_lock(x) +#define adeos_spin_unlock(x) _spin_unlock(x) +#define adeos_spin_trylock(x) _spin_trylock(x) +#define adeos_write_lock(x) _write_lock(x) +#define adeos_write_unlock(x) _write_unlock(x) +#define adeos_write_trylock(x) _write_trylock(x) +#define adeos_read_lock(x) _read_lock(x) +#define adeos_read_unlock(x) _read_unlock(x) +#define raw_spinlock_t spinlock_t +#define RAW_SPIN_LOCK_UNLOCKED SPIN_LOCK_UNLOCKED +#define raw_rwlock_t rwlock_t +#define RAW_RW_LOCK_UNLOCKED RW_LOCK_UNLOCKED + +#define spin_lock_irqsave_hw(lock,flags) adeos_spin_lock_irqsave(lock, flags) +#define spin_unlock_irqrestore_hw(lock,flags) adeos_spin_unlock_irqrestore(lock, flags) + +#define adeos_spin_lock_irqsave(x,flags) \ +do { \ + adeos_hw_local_irq_save(flags); \ + adeos_spin_lock(x); \ +} while (0) + +#define adeos_spin_unlock_irqrestore(x,flags) \ +do { \ + adeos_spin_unlock(x); \ + adeos_hw_local_irq_restore(flags); \ +} while (0) + +#define adeos_spin_lock_disable(x) \ +do { \ + adeos_hw_cli(); \ + adeos_spin_lock(x); \ +} while (0) + +#define adeos_spin_unlock_enable(x) \ +do { \ + adeos_spin_unlock(x); \ + adeos_hw_sti(); \ +} while (0) + +#define adeos_read_lock_irqsave(lock, flags) \ +do { \ + adeos_hw_local_irq_save(flags); \ + adeos_read_lock(lock); \ +} while (0) + +#define adeos_read_unlock_irqrestore(lock, flags) \ +do { \ + adeos_read_unlock(lock); \ + adeos_hw_local_irq_restore(flags); \ +} while (0) + +#define adeos_write_lock_irqsave(lock, flags) \ +do { \ + adeos_hw_local_irq_save(flags); \ + adeos_write_lock(lock); \ +} while (0) + +#define adeos_write_unlock_irqrestore(lock, flags) \ +do { \ + adeos_write_unlock(lock); \ + adeos_hw_local_irq_restore(flags); \ +} while (0) + +/* Private interface -- Internal use only */ + +struct adattr; + +void __adeos_init(void); + +void __adeos_init_domain(adomain_t *adp, + struct adattr *attr); + +void __adeos_cleanup_domain(adomain_t *adp); + +#define __adeos_check_platform() do { } while(0) + +#define __adeos_read_timebase() ({ unsigned long long t; adeos_hw_tsc(t); t; }) + +void __adeos_init_platform(void); + +void __adeos_enable_pipeline(void); + +void __adeos_disable_pipeline(void); + +void __adeos_init_stage(adomain_t *adp); + +void __adeos_sync_stage(unsigned long syncmask); + +int __adeos_ack_irq(unsigned irq); + +void __adeos_do_IRQ(int irq, + struct pt_regs *regs); + +void __adeos_do_timer(int irq, + struct pt_regs *regs); + +struct thread_info *__adeos_current_threadinfo(void); + +#ifdef CONFIG_ADEOS_THREADS + +int __adeos_switch_domain(adomain_t *adp, + adomain_t **currentp); + +/* Called with hw interrupts off. */ +static inline void __adeos_switch_to (adomain_t *out, + adomain_t *in, + int cpuid) +{ + extern adomain_t *adp_cpu_current[]; + + __adeos_switch_domain(in,&adp_cpu_current[cpuid]); + + if (out->dswitch != NULL) + out->dswitch(); +} + +#endif /* CONFIG_ADEOS_THREADS */ + +extern struct pt_regs __adeos_irq_regs; + +extern unsigned long __adeos_virtual_irq_map; + +extern unsigned long __adeos_decr_ticks; + +extern unsigned long long __adeos_decr_next[]; + +#endif /* !__PPC_ADEOS_H */ diff -uNrp linux-2.6.10/include/asm-ppc/hw_irq.h linux-2.6.10-ppc-adeos/include/asm-ppc/hw_irq.h --- linux-2.6.10/include/asm-ppc/hw_irq.h 2004-12-24 22:35:15.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/asm-ppc/hw_irq.h 2005-03-27 16:35:19.000000000 +0200 @@ -12,6 +12,37 @@ extern void timer_interrupt(struct pt_re #define INLINE_IRQS +#ifdef CONFIG_ADEOS_CORE + +void __adeos_stall_root(void); +void __adeos_unstall_root(void); +unsigned long __adeos_test_root(void); +unsigned long __adeos_test_and_stall_root(void); +void __adeos_restore_root(unsigned long flags); + +#define irqs_disabled() __adeos_test_root() + +static inline void local_irq_disable(void) { + __adeos_stall_root(); +} + +static inline void local_irq_enable(void) { + __adeos_unstall_root(); +} + +static inline void local_irq_save_ptr(unsigned long *flags) { + *flags = __adeos_test_and_stall_root(); +} + +static inline void local_irq_restore(unsigned long flags) { + __adeos_restore_root(flags); +} + +#define local_save_flags(flags) ((flags) = __adeos_test_root()) +#define local_irq_save(flags) local_irq_save_ptr(&flags) + +#else /* !CONFIG_ADEOS_CORE */ + #define irqs_disabled() ((mfmsr() & MSR_EE) == 0) #ifdef INLINE_IRQS @@ -57,6 +88,8 @@ extern void local_save_flags_ptr(unsigne #endif +#endif /* CONFIG_ADEOS_CORE */ + extern void do_lost_interrupts(unsigned long); #define mask_irq(irq) ({if (irq_desc[irq].handler && irq_desc[irq].handler->disable) irq_desc[irq].handler->disable(irq);}) diff -uNrp linux-2.6.10/include/asm-ppc/smp.h linux-2.6.10-ppc-adeos/include/asm-ppc/smp.h --- linux-2.6.10/include/asm-ppc/smp.h 2004-12-24 22:34:23.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/asm-ppc/smp.h 2005-03-27 16:35:19.000000000 +0200 @@ -45,7 +45,12 @@ extern void smp_local_timer_interrupt(st #define NO_PROC_ID 0xFF /* No processor magic marker */ #define PROC_CHANGE_PENALTY 20 -#define smp_processor_id() (current_thread_info()->cpu) +#ifdef CONFIG_ADEOS_CORE +#include +#define smp_processor_id() adeos_processor_id() +#else /* !CONFIG_ADEOS_CORE */ +#define smp_processor_id() (current_thread_info()->cpu) +#endif /* CONFIG_ADEOS_CORE */ extern int __cpu_up(unsigned int cpu); diff -uNrp linux-2.6.10/include/linux/adeos.h linux-2.6.10-ppc-adeos/include/linux/adeos.h --- linux-2.6.10/include/linux/adeos.h 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/linux/adeos.h 2005-07-02 13:30:57.000000000 +0200 @@ -0,0 +1,551 @@ +/* + * include/linux/adeos.h + * + * Copyright (C) 2002,2003,2004 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __LINUX_ADEOS_H +#define __LINUX_ADEOS_H + +#include + +#ifdef CONFIG_ADEOS_CORE + +#include +#include + +#define ADEOS_VERSION_PREFIX "2.6" +#define ADEOS_VERSION_STRING (ADEOS_VERSION_PREFIX ADEOS_ARCH_STRING) +#define ADEOS_RELEASE_NUMBER (0x02060000|((ADEOS_MAJOR_NUMBER&0xff)<<8)|(ADEOS_MINOR_NUMBER&0xff)) + +#define ADEOS_ROOT_PRI 100 +#define ADEOS_ROOT_ID 0 +#define ADEOS_ROOT_NPTDKEYS 4 /* Must be <= 32 */ + +#define ADEOS_RESET_TIMER 0x1 +#define ADEOS_SAME_HANDLER ((void (*)(unsigned))(-1)) + +/* Global domain flags */ +#define ADEOS_SPRINTK_FLAG 0 /* Synchronous printk() allowed */ +#define ADEOS_PPRINTK_FLAG 1 /* Asynchronous printk() request pending */ + +/* Per-cpu pipeline flags. + WARNING: some implementation might refer to those flags + non-symbolically in assembly portions (e.g. x86). */ +#define IPIPE_STALL_FLAG 0 /* Stalls a pipeline stage */ +#define IPIPE_XPEND_FLAG 1 /* Exception notification is pending */ +#define IPIPE_SLEEP_FLAG 2 /* Domain has self-suspended */ +#define IPIPE_SYNC_FLAG 3 /* The interrupt syncer is running for the domain */ + +#define IPIPE_HANDLE_FLAG 0 +#define IPIPE_PASS_FLAG 1 +#define IPIPE_ENABLE_FLAG 2 +#define IPIPE_DYNAMIC_FLAG IPIPE_HANDLE_FLAG +#define IPIPE_EXCLUSIVE_FLAG 3 +#define IPIPE_STICKY_FLAG 4 +#define IPIPE_SYSTEM_FLAG 5 +#define IPIPE_LOCK_FLAG 6 +#define IPIPE_SHARED_FLAG 7 +#define IPIPE_CALLASM_FLAG 8 /* Arch-dependent -- might be unused. */ + +#define IPIPE_HANDLE_MASK (1 << IPIPE_HANDLE_FLAG) +#define IPIPE_PASS_MASK (1 << IPIPE_PASS_FLAG) +#define IPIPE_ENABLE_MASK (1 << IPIPE_ENABLE_FLAG) +#define IPIPE_DYNAMIC_MASK IPIPE_HANDLE_MASK +#define IPIPE_EXCLUSIVE_MASK (1 << IPIPE_EXCLUSIVE_FLAG) +#define IPIPE_STICKY_MASK (1 << IPIPE_STICKY_FLAG) +#define IPIPE_SYSTEM_MASK (1 << IPIPE_SYSTEM_FLAG) +#define IPIPE_LOCK_MASK (1 << IPIPE_LOCK_FLAG) +#define IPIPE_SHARED_MASK (1 << IPIPE_SHARED_FLAG) +#define IPIPE_SYNC_MASK (1 << IPIPE_SYNC_FLAG) +#define IPIPE_CALLASM_MASK (1 << IPIPE_CALLASM_FLAG) + +#define IPIPE_DEFAULT_MASK (IPIPE_HANDLE_MASK|IPIPE_PASS_MASK) + +typedef struct adattr { + + unsigned domid; /* Domain identifier -- Magic value set by caller */ + const char *name; /* Domain name -- Warning: won't be dup'ed! */ + int priority; /* Priority in interrupt pipeline */ + void (*entry)(int); /* Domain entry point */ + int estacksz; /* Stack size for entry context -- 0 means unspec */ + void (*dswitch)(void); /* Handler called each time the domain is switched in */ + int nptdkeys; /* Max. number of per-thread data keys */ + void (*ptdset)(int,void *); /* Routine to set pt values */ + void *(*ptdget)(int); /* Routine to get pt values */ + +} adattr_t; + +typedef struct admutex { + + raw_spinlock_t lock; + +#ifdef CONFIG_ADEOS_THREADS + adomain_t *sleepq, /* Pending domain queue */ + *owner; /* Domain owning the mutex */ +#ifdef CONFIG_SMP + volatile int owncpu; +#define ADEOS_MUTEX_UNLOCKED { RAW_SPIN_LOCK_UNLOCKED, NULL, NULL, -1 } +#else /* !CONFIG_SMP */ +#define ADEOS_MUTEX_UNLOCKED { RAW_SPIN_LOCK_UNLOCKED, NULL, NULL } +#endif /* CONFIG_SMP */ +#else /* !CONFIG_ADEOS_THREADS */ +#define ADEOS_MUTEX_UNLOCKED { RAW_SPIN_LOCK_UNLOCKED } +#endif /* CONFIG_ADEOS_THREADS */ + +} admutex_t; + +extern int adp_pipelined; + +extern adomain_t *adp_cpu_current[], + *adp_root; + +extern int __adeos_event_monitors[]; + +extern unsigned __adeos_printk_virq; + +extern unsigned long __adeos_virtual_irq_map; + +extern struct list_head __adeos_pipeline; + +extern raw_spinlock_t __adeos_pipelock; + +#ifdef CONFIG_ADEOS_PROFILING + +typedef struct adprofdata { + + struct { + unsigned long long t_handled; + unsigned long long t_synced; + unsigned long n_handled; + unsigned long n_synced; + } irqs[IPIPE_NR_IRQS]; + +} adprofdata_t; + +extern adprofdata_t __adeos_profile_data[ADEOS_NR_CPUS]; + +#endif /* CONFIG_ADEOS_PROFILING */ + +/* Private interface */ + +#ifdef CONFIG_PROC_FS +void __adeos_init_proc(void); +#endif /* CONFIG_PROC_FS */ + +void __adeos_takeover(void); + +asmlinkage int __adeos_handle_event(unsigned event, + void *evdata); + +void __adeos_flush_printk(unsigned irq); + +void __adeos_dump_state(void); + +static inline void __adeos_schedule_head(void *evdata) { + + if (__adeos_event_monitors[ADEOS_SCHEDULE_HEAD] > 0) + __adeos_handle_event(ADEOS_SCHEDULE_HEAD,evdata); +} + +static inline int __adeos_schedule_tail(void *evdata) { + + if (__adeos_event_monitors[ADEOS_SCHEDULE_TAIL] > 0) + return __adeos_handle_event(ADEOS_SCHEDULE_TAIL,evdata); + + return 0; +} + +static inline void __adeos_enter_process(void) { + + if (__adeos_event_monitors[ADEOS_ENTER_PROCESS] > 0) + __adeos_handle_event(ADEOS_ENTER_PROCESS,NULL); +} + +static inline void __adeos_exit_process(void *evdata) { + + if (__adeos_event_monitors[ADEOS_EXIT_PROCESS] > 0) + __adeos_handle_event(ADEOS_EXIT_PROCESS,evdata); +} + +static inline int __adeos_signal_process(void *evdata) { + + if (__adeos_event_monitors[ADEOS_SIGNAL_PROCESS] > 0) + return __adeos_handle_event(ADEOS_SIGNAL_PROCESS,evdata); + + return 0; +} + +static inline void __adeos_kick_process(void *evdata) { + + if (__adeos_event_monitors[ADEOS_KICK_PROCESS] > 0) + __adeos_handle_event(ADEOS_KICK_PROCESS,evdata); +} + +static inline int __adeos_renice_process(void *evdata) { + + if (__adeos_event_monitors[ADEOS_RENICE_PROCESS] > 0) + return __adeos_handle_event(ADEOS_RENICE_PROCESS,evdata); + + return 0; +} + +void __adeos_stall_root(void); + +void __adeos_unstall_root(void); + +unsigned long __adeos_test_root(void); + +unsigned long __adeos_test_and_stall_root(void); + +void fastcall __adeos_restore_root(unsigned long flags); + +void __adeos_schedule_back_root(struct task_struct *prev); + +int __adeos_setscheduler_root(struct task_struct *p, + int policy, + int prio); + +void __adeos_reenter_root(struct task_struct *prev, + int policy, + int prio); + +int fastcall __adeos_schedule_irq(unsigned irq, + struct list_head *head); + +#define __adeos_pipeline_head_p(adp) (&(adp)->p_link == __adeos_pipeline.next) + +#ifdef CONFIG_ADEOS_THREADS + +static inline int __adeos_domain_work_p (adomain_t *adp, int cpuid) + +{ + return (!test_bit(IPIPE_SLEEP_FLAG,&adp->cpudata[cpuid].status) || + (!test_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status) && + adp->cpudata[cpuid].irq_pending_hi != 0) || + test_bit(IPIPE_XPEND_FLAG,&adp->cpudata[cpuid].status)); +} + +#else /* !CONFIG_ADEOS_THREADS */ + +static inline int __adeos_domain_work_p (adomain_t *adp, int cpuid) + +{ + return (!test_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status) && + adp->cpudata[cpuid].irq_pending_hi != 0); +} + +static inline void __adeos_switch_to (adomain_t *out, adomain_t *in, int cpuid) + +{ + void adeos_suspend_domain(void); + + /* "in" is guaranteed to be closer than "out" from the head of the + pipeline (and obviously different). */ + + adp_cpu_current[cpuid] = in; + + if (in->dswitch) + in->dswitch(); + + adeos_suspend_domain(); /* Sync stage and propagate interrupts. */ + adeos_load_cpuid(); /* Processor might have changed. */ + + if (adp_cpu_current[cpuid] == in) + /* Otherwise, something has changed the current domain under + our feet recycling the register set; do not override. */ + adp_cpu_current[cpuid] = out; +} + +#endif /* CONFIG_ADEOS_THREADS */ + +/* Public interface */ + +int adeos_register_domain(adomain_t *adp, + adattr_t *attr); + +int adeos_unregister_domain(adomain_t *adp); + +void adeos_suspend_domain(void); + +int adeos_virtualize_irq_from(adomain_t *adp, + unsigned irq, + void (*handler)(unsigned irq), + int (*acknowledge)(unsigned irq), + unsigned modemask); + +static inline int adeos_virtualize_irq(unsigned irq, + void (*handler)(unsigned irq), + int (*acknowledge)(unsigned irq), + unsigned modemask) { + + return adeos_virtualize_irq_from(adp_current, + irq, + handler, + acknowledge, + modemask); +} + +int adeos_control_irq(unsigned irq, + unsigned clrmask, + unsigned setmask); + +cpumask_t adeos_set_irq_affinity(unsigned irq, + cpumask_t cpumask); + +static inline int adeos_share_irq (unsigned irq, int (*acknowledge)(unsigned irq)) { + + return adeos_virtualize_irq(irq, + ADEOS_SAME_HANDLER, + acknowledge, + IPIPE_SHARED_MASK|IPIPE_HANDLE_MASK|IPIPE_PASS_MASK); +} + +unsigned adeos_alloc_irq(void); + +int adeos_free_irq(unsigned irq); + +int fastcall adeos_trigger_irq(unsigned irq); + +static inline int adeos_propagate_irq(unsigned irq) { + + return __adeos_schedule_irq(irq,adp_current->p_link.next); +} + +static inline int adeos_schedule_irq(unsigned irq) { + + return __adeos_schedule_irq(irq,&adp_current->p_link); +} + +int fastcall adeos_send_ipi(unsigned ipi, + cpumask_t cpumask); + +static inline void adeos_stall_pipeline_from (adomain_t *adp) + +{ + adeos_declare_cpuid; +#ifdef CONFIG_SMP + unsigned long flags; + + adeos_lock_cpu(flags); + + __set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + if (!__adeos_pipeline_head_p(adp)) + adeos_unlock_cpu(flags); +#else /* CONFIG_SMP */ + set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + if (__adeos_pipeline_head_p(adp)) + adeos_hw_cli(); +#endif /* CONFIG_SMP */ +} + +static inline unsigned long adeos_test_pipeline_from (adomain_t *adp) + +{ + unsigned long flags, s; + adeos_declare_cpuid; + + adeos_get_cpu(flags); + s = test_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + adeos_put_cpu(flags); + + return s; +} + +static inline unsigned long adeos_test_and_stall_pipeline_from (adomain_t *adp) + +{ + adeos_declare_cpuid; + unsigned long s; +#ifdef CONFIG_SMP + unsigned long flags; + + adeos_lock_cpu(flags); + + s = __test_and_set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + if (!__adeos_pipeline_head_p(adp)) + adeos_unlock_cpu(flags); +#else /* CONFIG_SMP */ + s = test_and_set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + + if (__adeos_pipeline_head_p(adp)) + adeos_hw_cli(); +#endif /* CONFIG_SMP */ + + return s; +} + +void fastcall adeos_unstall_pipeline_from(adomain_t *adp); + +static inline unsigned long adeos_test_and_unstall_pipeline_from(adomain_t *adp) + +{ + unsigned long flags, s; + adeos_declare_cpuid; + + adeos_get_cpu(flags); + s = test_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + adeos_unstall_pipeline_from(adp); + adeos_put_cpu(flags); + + return s; +} + +static inline void adeos_unstall_pipeline(void) + +{ + adeos_unstall_pipeline_from(adp_current); +} + +static inline unsigned long adeos_test_and_unstall_pipeline(void) + +{ + return adeos_test_and_unstall_pipeline_from(adp_current); +} + +static inline unsigned long adeos_test_pipeline (void) + +{ + return adeos_test_pipeline_from(adp_current); +} + +static inline unsigned long adeos_test_and_stall_pipeline (void) + +{ + return adeos_test_and_stall_pipeline_from(adp_current); +} + +static inline void adeos_restore_pipeline_from (adomain_t *adp, unsigned long flags) + +{ + if (flags) + adeos_stall_pipeline_from(adp); + else + adeos_unstall_pipeline_from(adp); +} + +static inline void adeos_stall_pipeline (void) + +{ + adeos_stall_pipeline_from(adp_current); +} + +static inline void adeos_restore_pipeline (unsigned long flags) + +{ + adeos_restore_pipeline_from(adp_current,flags); +} + +static inline void adeos_restore_pipeline_nosync (adomain_t *adp, unsigned long flags, int cpuid) + +{ + /* If cpuid is current, then it must be held on entry + (adeos_get_cpu/adeos_hw_local_irq_save/adeos_hw_cli). */ + + if (flags) + __set_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); + else + __clear_bit(IPIPE_STALL_FLAG,&adp->cpudata[cpuid].status); +} + +int adeos_catch_event_from(adomain_t *adp, + unsigned event, + void (*handler)(adevinfo_t *)); + +static inline int adeos_catch_event (unsigned event, void (*handler)(adevinfo_t *)) + +{ + return adeos_catch_event_from(adp_current,event,handler); +} + +static inline void adeos_propagate_event(adevinfo_t *evinfo) + +{ + evinfo->propagate = 1; +} + +void adeos_init_attr(adattr_t *attr); + +int adeos_get_sysinfo(adsysinfo_t *sysinfo); + +int adeos_tune_timer(unsigned long ns, + int flags); + +int adeos_alloc_ptdkey(void); + +int adeos_free_ptdkey(int key); + +int adeos_set_ptd(int key, + void *value); + +void *adeos_get_ptd(int key); + +unsigned long adeos_critical_enter(void (*syncfn)(void)); + +void adeos_critical_exit(unsigned long flags); + +int adeos_init_mutex(admutex_t *mutex); + +int adeos_destroy_mutex(admutex_t *mutex); + +unsigned long fastcall adeos_lock_mutex(admutex_t *mutex); + +void fastcall adeos_unlock_mutex(admutex_t *mutex, + unsigned long flags); + +static inline void adeos_set_printk_sync (adomain_t *adp) { + set_bit(ADEOS_SPRINTK_FLAG,&adp->flags); +} + +static inline void adeos_set_printk_async (adomain_t *adp) { + clear_bit(ADEOS_SPRINTK_FLAG,&adp->flags); +} + +#define spin_lock_irqsave_hw_cond(lock,flags) spin_lock_irqsave_hw(lock,flags) +#define spin_unlock_irqrestore_hw_cond(lock,flags) spin_unlock_irqrestore_hw(lock,flags) + +#define pic_irq_lock(irq) \ + do { \ + adeos_declare_cpuid; \ + adeos_load_cpuid(); \ + __adeos_lock_irq(adp_cpu_current[cpuid], cpuid, irq); \ + } while(0) + +#define pic_irq_unlock(irq) \ + do { \ + adeos_declare_cpuid; \ + adeos_load_cpuid(); \ + __adeos_unlock_irq(adp_cpu_current[cpuid], irq); \ + } while(0) + +#else /* !CONFIG_ADEOS_CORE */ + +#define spin_lock_irqsave_hw(lock,flags) spin_lock_irqsave(lock, flags) +#define spin_unlock_irqrestore_hw(lock,flags) spin_unlock_irqrestore(lock, flags) +#define spin_lock_irqsave_hw_cond(lock,flags) do { flags = 0; spin_lock(lock); } while(0) +#define spin_unlock_irqrestore_hw_cond(lock,flags) spin_unlock(lock) + +#define pic_irq_lock(irq) do { } while(0) +#define pic_irq_unlock(irq) do { } while(0) + +#endif /* CONFIG_ADEOS_CORE */ + +#endif /* !__LINUX_ADEOS_H */ diff -uNrp linux-2.6.10/include/linux/init_task.h linux-2.6.10-ppc-adeos/include/linux/init_task.h --- linux-2.6.10/include/linux/init_task.h 2004-12-24 22:33:52.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/linux/init_task.h 2005-03-27 16:35:19.000000000 +0200 @@ -65,6 +65,60 @@ extern struct group_info init_groups; * INIT_TASK is used to set up the first task table, touch at * your own risk!. Base=0, limit=0x1fffff (=2MB) */ +#ifdef CONFIG_ADEOS_CORE + +#define INIT_TASK(tsk) \ +{ \ + .state = 0, \ + .thread_info = &init_thread_info, \ + .usage = ATOMIC_INIT(2), \ + .flags = 0, \ + .lock_depth = -1, \ + .prio = MAX_PRIO-20, \ + .static_prio = MAX_PRIO-20, \ + .policy = SCHED_NORMAL, \ + .cpus_allowed = CPU_MASK_ALL, \ + .mm = NULL, \ + .active_mm = &init_mm, \ + .run_list = LIST_HEAD_INIT(tsk.run_list), \ + .time_slice = HZ, \ + .tasks = LIST_HEAD_INIT(tsk.tasks), \ + .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children), \ + .ptrace_list = LIST_HEAD_INIT(tsk.ptrace_list), \ + .real_parent = &tsk, \ + .parent = &tsk, \ + .children = LIST_HEAD_INIT(tsk.children), \ + .sibling = LIST_HEAD_INIT(tsk.sibling), \ + .group_leader = &tsk, \ + .wait_chldexit = __WAIT_QUEUE_HEAD_INITIALIZER(tsk.wait_chldexit),\ + .real_timer = { \ + .function = it_real_fn \ + }, \ + .group_info = &init_groups, \ + .cap_effective = CAP_INIT_EFF_SET, \ + .cap_inheritable = CAP_INIT_INH_SET, \ + .cap_permitted = CAP_FULL_SET, \ + .keep_capabilities = 0, \ + .user = INIT_USER, \ + .comm = "swapper", \ + .thread = INIT_THREAD, \ + .fs = &init_fs, \ + .files = &init_files, \ + .signal = &init_signals, \ + .sighand = &init_sighand, \ + .pending = { \ + .list = LIST_HEAD_INIT(tsk.pending.list), \ + .signal = {{0}}}, \ + .blocked = {{0}}, \ + .alloc_lock = SPIN_LOCK_UNLOCKED, \ + .proc_lock = SPIN_LOCK_UNLOCKED, \ + .switch_lock = SPIN_LOCK_UNLOCKED, \ + .journal_info = NULL, \ + .ptd = { [ 0 ... ADEOS_ROOT_NPTDKEYS - 1] = 0 } \ +} + +#else /* !CONFIG_ADEOS_CORE */ + #define INIT_TASK(tsk) \ { \ .state = 0, \ @@ -114,6 +168,7 @@ extern struct group_info init_groups; .journal_info = NULL, \ } +#endif /* CONFIG_ADEOS_CORE */ #endif diff -uNrp linux-2.6.10/include/linux/preempt.h linux-2.6.10-ppc-adeos/include/linux/preempt.h --- linux-2.6.10/include/linux/preempt.h 2004-12-24 22:34:26.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/linux/preempt.h 2005-03-27 16:35:19.000000000 +0200 @@ -25,6 +25,47 @@ do { \ asmlinkage void preempt_schedule(void); +#ifdef CONFIG_ADEOS_CORE + +#include + +extern adomain_t *adp_cpu_current[], + *adp_root; + +#define preempt_disable() \ +do { \ + if (adp_current == adp_root) { \ + inc_preempt_count(); \ + barrier(); \ + } \ +} while (0) + +#define preempt_enable_no_resched() \ +do { \ + if (adp_current == adp_root) { \ + barrier(); \ + dec_preempt_count(); \ + } \ +} while (0) + +#define preempt_check_resched() \ +do { \ + if (adp_current == adp_root) { \ + if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \ + preempt_schedule(); \ + } \ +} while (0) + +#define preempt_enable() \ +do { \ + if (adp_current == adp_root) { \ + preempt_enable_no_resched(); \ + preempt_check_resched(); \ + } \ +} while (0) + +#else /* !CONFIG_ADEOS_CORE */ + #define preempt_disable() \ do { \ inc_preempt_count(); \ @@ -49,6 +90,8 @@ do { \ preempt_check_resched(); \ } while (0) +#endif /* CONFIG_ADEOS_CORE */ + #else #define preempt_disable() do { } while (0) diff -uNrp linux-2.6.10/include/linux/sched.h linux-2.6.10-ppc-adeos/include/linux/sched.h --- linux-2.6.10/include/linux/sched.h 2004-12-24 22:33:59.000000000 +0100 +++ linux-2.6.10-ppc-adeos/include/linux/sched.h 2005-03-27 16:35:19.000000000 +0200 @@ -4,6 +4,9 @@ #include /* for HZ */ #include +#ifdef CONFIG_ADEOS_CORE +#include +#endif /* CONFIG_ADEOS_CORE */ #include #include #include @@ -664,6 +667,10 @@ struct task_struct { struct mempolicy *mempolicy; short il_next; /* could be shared with used_math */ #endif + +#ifdef CONFIG_ADEOS_CORE + void *ptd[ADEOS_ROOT_NPTDKEYS]; +#endif /* CONFIG_ADEOS_CORE */ }; static inline pid_t process_group(struct task_struct *tsk) diff -uNrp linux-2.6.10/init/main.c linux-2.6.10-ppc-adeos/init/main.c --- linux-2.6.10/init/main.c 2004-12-24 22:34:01.000000000 +0100 +++ linux-2.6.10-ppc-adeos/init/main.c 2005-03-27 16:35:19.000000000 +0200 @@ -526,6 +526,11 @@ asmlinkage void __init start_kernel(void init_timers(); softirq_init(); time_init(); +#ifdef CONFIG_ADEOS_CORE + /* On PPC, we need calibrated values for the decrementer to + initialize, so run time_init() first. */ + __adeos_init(); +#endif /* CONFIG_ADEOS_CORE */ /* * HACK ALERT! This is early. We're enabling the console before @@ -652,6 +657,11 @@ static void __init do_basic_setup(void) sock_init(); do_initcalls(); + +#ifdef CONFIG_ADEOS + /* i.e. Permanent pipelining from boot onwards. */ + __adeos_takeover(); +#endif /* CONFIG_ADEOS */ } static void do_pre_smp_initcalls(void) diff -uNrp linux-2.6.10/kernel/Makefile linux-2.6.10-ppc-adeos/kernel/Makefile --- linux-2.6.10/kernel/Makefile 2004-12-24 22:34:26.000000000 +0100 +++ linux-2.6.10-ppc-adeos/kernel/Makefile 2005-03-27 16:35:19.000000000 +0200 @@ -9,6 +9,7 @@ obj-y = sched.o fork.o exec_domain.o rcupdate.o intermodule.o extable.o params.o posix-timers.o \ kthread.o wait.o kfifo.o sys_ni.o +obj-$(CONFIG_ADEOS_CORE) += adeos.o obj-$(CONFIG_FUTEX) += futex.o obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o obj-$(CONFIG_SMP) += cpu.o spinlock.o diff -uNrp linux-2.6.10/kernel/adeos.c linux-2.6.10-ppc-adeos/kernel/adeos.c --- linux-2.6.10/kernel/adeos.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10-ppc-adeos/kernel/adeos.c 2005-06-28 16:52:47.000000000 +0200 @@ -0,0 +1,799 @@ +/* + * linux/kernel/adeos.c + * + * Copyright (C) 2002,2003,2004 Philippe Gerum. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, + * USA; either version 2 of the License, or (at your option) any later + * version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Architecture-independent ADEOS core support. + */ + +#include +#include +#ifdef CONFIG_PROC_FS +#include +#endif /* CONFIG_PROC_FS */ + +/* The pre-defined domain slot for the root domain. */ +static adomain_t adeos_root_domain; + +/* A constant pointer to the root domain. */ +adomain_t *adp_root = &adeos_root_domain; + +/* A pointer to the current domain. */ +adomain_t *adp_cpu_current[ADEOS_NR_CPUS] = { [ 0 ... ADEOS_NR_CPUS - 1] = &adeos_root_domain }; + +/* The spinlock protecting from races while modifying the pipeline. */ +raw_spinlock_t __adeos_pipelock = RAW_SPIN_LOCK_UNLOCKED; + +/* The pipeline data structure. Enqueues adomain_t objects by priority. */ +struct list_head __adeos_pipeline; + +/* A global flag telling whether Adeos pipelining is engaged. */ +int adp_pipelined; + +/* An array of global counters tracking domains monitoring events. */ +int __adeos_event_monitors[ADEOS_NR_EVENTS] = { [ 0 ... ADEOS_NR_EVENTS - 1] = 0 }; + +/* The allocated VIRQ map. */ +unsigned long __adeos_virtual_irq_map = 0; + +/* A VIRQ to kick printk() output out when the root domain is in control. */ +unsigned __adeos_printk_virq; + +#ifdef CONFIG_ADEOS_PROFILING +adprofdata_t __adeos_profile_data[ADEOS_NR_CPUS]; +#endif /* CONFIG_ADEOS_PROFILING */ + +static void __adeos_set_root_ptd (int key, void *value) { + + current->ptd[key] = value; +} + +static void *__adeos_get_root_ptd (int key) { + + return current->ptd[key]; +} + +/* adeos_init() -- Initialization routine of the ADEOS layer. Called + by the host kernel early during the boot procedure. */ + +void __adeos_init (void) + +{ + adomain_t *adp = &adeos_root_domain; + + __adeos_check_platform(); /* Do platform dependent checks first. */ + + /* + A lightweight registration code for the root domain. Current + assumptions are: + - We are running on the boot CPU, and secondary CPUs are still + lost in space. + - adeos_root_domain has been zero'ed. + */ + + INIT_LIST_HEAD(&__adeos_pipeline); + + adp->name = "Linux"; + adp->domid = ADEOS_ROOT_ID; + adp->priority = ADEOS_ROOT_PRI; + adp->ptd_setfun = &__adeos_set_root_ptd; + adp->ptd_getfun = &__adeos_get_root_ptd; + adp->ptd_keymax = ADEOS_ROOT_NPTDKEYS; + + __adeos_init_stage(adp); + + INIT_LIST_HEAD(&adp->p_link); + list_add_tail(&adp->p_link,&__adeos_pipeline); + + __adeos_init_platform(); + + __adeos_printk_virq = adeos_alloc_irq(); /* Cannot fail here. */ + adp->irqs[__adeos_printk_virq].handler = &__adeos_flush_printk; + adp->irqs[__adeos_printk_virq].acknowledge = NULL; + adp->irqs[__adeos_printk_virq].control = IPIPE_HANDLE_MASK; + + printk(KERN_INFO "Adeos %s: Root domain %s registered.\n", + ADEOS_VERSION_STRING, + adp->name); +} + +/* adeos_handle_event() -- Adeos' generic event handler. This routine + calls the per-domain handlers registered for a given + exception/event. Each domain before the one which raised the event + in the pipeline will get a chance to process the event. The latter + will eventually be allowed to process its own event too if a valid + handler exists for it. Handler executions are always scheduled by + the domain which raised the event for the higher priority domains + wanting to be notified of such event. Note: evdata might be + NULL. */ + +#ifdef CONFIG_ADEOS_THREADS + +asmlinkage int __adeos_handle_event (unsigned event, void *evdata) +/* asmlinkage is there just in case CONFIG_REGPARM is enabled... */ +{ + struct list_head *pos, *npos; + adomain_t *this_domain; + unsigned long flags; + adeos_declare_cpuid; + adevinfo_t evinfo; + int propagate = 1; + + adeos_lock_cpu(flags); + + this_domain = adp_cpu_current[cpuid]; + + list_for_each_safe(pos,npos,&__adeos_pipeline) { + + adomain_t *next_domain = list_entry(pos,adomain_t,p_link); + + if (next_domain->events[event].handler != NULL) + { + if (next_domain == this_domain) + { + adeos_unlock_cpu(flags); + evinfo.domid = this_domain->domid; + evinfo.event = event; + evinfo.evdata = evdata; + evinfo.propagate = 0; + this_domain->events[event].handler(&evinfo); + propagate = evinfo.propagate; + goto done; + } + + next_domain->cpudata[cpu