Root/invoke.ccp

1#pypp 0
2// Iris: micro-kernel for a capability-based operating system.
3// invoke.ccp: Capability invocation and kernel responses.
4// Copyright 2009 Bas Wijnen <wijnen@debian.org>
5//
6// This program is free software: you can redistribute it and/or modify
7// it under the terms of the GNU General Public License as published by
8// the Free Software Foundation, either version 3 of the License, or
9// (at your option) any later version.
10//
11// This program is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15//
16// You should have received a copy of the GNU General Public License
17// along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19#include "kernel.hh"
20
21static void log_message (char const *prefix, unsigned target, unsigned pdata, kCapability::Context *c):
22    kdebug (prefix)
23    kdebug (": caller=")
24    if old_current:
25        kdebug_num (old_current->id, 2)
26    else
27        kdebug ("xx")
28    kdebug (":")
29    kdebug_num ((unsigned)old_current)
30    kdebug ("; target=")
31    kdebug_num (target)
32    kdebug ("; pdata=")
33    kdebug_num (pdata)
34    kdebug ("; data=")
35    kdebug_num (c->data[0].h)
36    kdebug (":")
37    kdebug_num (c->data[0].l)
38    kdebug (",")
39    kdebug_num (c->data[1].h)
40    kdebug (":")
41    kdebug_num (c->data[1].l)
42    if c->reply.valid ():
43        kdebug ("; reply target=")
44        kdebug_num ((unsigned)c->reply->target)
45        kdebug ("; pdata=")
46        kdebug_num (c->reply->protected_data.l)
47    if c->arg.valid ():
48        kdebug ("; arg target=")
49        kdebug_num ((unsigned)c->arg->target)
50        kdebug ("; pdata=")
51        kdebug_num (c->arg->protected_data.l)
52    kdebug ("\n")
53
54void kThread::raise (unsigned code, unsigned data):
55    kdebug ("raise ")
56    if old_current:
57        kdebug_num (old_current->id, 2)
58    else:
59        kdebug ("xx")
60    kdebug (':')
61    kdebug_num ((unsigned)old_current)
62    kdebug ('/')
63    if code < Iris::NUM_EXCEPTION_CODES:
64        kdebug (Iris::exception_name[code])
65    else:
66        kdebug ("invalid code:")
67        kdebug_num (code)
68    kdebug ('/')
69    kdebug_num (data)
70    kdebug ('\n')
71    dpanic (code, "raise")
72    unrun ()
73    if slots < 1 || !slot[0].caps || !slot[0].caps->cap (0)->target:
74        return
75    kCapability::Context c
76    c.data[0] = Iris::Num (code, data)
77    slot[0].caps->cap (0)->invoke (&c)
78
79// From user-provided, thus untrusted, data, find a capability.
80kCapRef kThread::find_capability (unsigned code, bool *copy):
81    *copy = code & CAP_COPY
82    unsigned c = code & ~CAP_COPY
83    unsigned s = c >> 16
84    unsigned num = c & 0xffff
85    if s >= slots || !slot[s].caps || num >= slot[s].caps->size:
86        if c != CAP_NONE:
87            kdebug_num ((unsigned)old_current)
88            kdebug (": invalid capability ")
89            kdebug_num (code)
90            kdebug ('\n')
91            kdebug_num (num)
92            kdebug (':')
93            kdebug_num (s)
94            kdebug (" > ")
95            if slot[s].caps:
96                kdebug_num (slot[s].caps->size)
97            else:
98                kdebug ("no caps")
99            kdebug ('\n')
100            dpanic (code, "invalid capability")
101        return kCapRef ()
102    return kCapRef (slot[s].caps, num)
103
104// Try to deliver a message.
105bool kReceiver::try_deliver ():
106    if !messages:
107        return false
108    if !owner || !owner->is_waiting ():
109        return false
110    kMessage *m = last_message
111    if protected_only:
112        for ; m; m = (kMessage *)m->prev:
113            if m->protected_data.value () == reply_protected_data.value ():
114                protected_only = false
115                break
116    if !m:
117        return false
118    bool dummy
119    kCapRef c = owner->find_capability (owner->recv_reply, &dummy)
120    if c.valid ():
121        c.clone (kCapRef (&m->caps, 0), true)
122    c = owner->find_capability (owner->recv_arg, &dummy)
123    if c.valid ():
124        c.clone (kCapRef (&m->caps, 1), true)
125    kThread_arch_receive (owner, m->protected_data, m->data)
126    address_space->free_message (this, m)
127    owner->unwait ()
128    return true
129
130// Send a message to a receiver; try to deliver it immediately.
131bool kReceiver::send_message (Iris::Num protected_data, kCapability::Context *c):
132    //log_message ("send_message", (unsigned)this, protected_data.l, c)
133    if owner && owner->is_waiting () && (!protected_only || protected_data.value () == reply_protected_data.value ()):
134        if protected_only:
135            protected_only = false
136        bool dummy
137        kCapRef cap = owner->find_capability (owner->recv_reply, &dummy)
138        if cap.valid ():
139            cap.clone (c->reply, c->copy[0])
140        cap = owner->find_capability (owner->recv_arg, &dummy)
141        if cap.valid ():
142            cap.clone (c->arg, c->copy[1])
143        kThread_arch_receive (owner, protected_data, c->data)
144        owner->unwait ()
145        return true
146    // The owner was not waiting, or it was not possible to deliver the message. Put it in the queue.
147    kMessage *msg = NULL;
148    if queue_limit:
149        msg = address_space->alloc_message (this)
150        if msg:
151            --queue_limit
152    if !msg:
153        // TODO: use sender-provided storage.
154    if !msg:
155        return false
156    msg->protected_data = protected_data
157    for unsigned i = 0; i < 2; ++i:
158        msg->data[i] = c->data[i]
159    msg->caps.clone (0, c->reply, c->copy[0])
160    msg->caps.clone (1, c->arg, c->copy[1])
161    return true
162
163static kCapability::Context *context
164
165static void reply_num (Iris::Num num):
166    kCapability::Context c
167    c.data[0] = num
168    c.data[1] = 0
169    if reply_target:
170        reply_target->send_message (reply_protected, &c)
171    else
172        dpanic (0, "nothing to reply to")
173
174static void reply_num (unsigned num1, unsigned num2 = 0, unsigned num3 = 0):
175    kCapability::Context c
176    c.data[0] = Iris::Num (num1, num2)
177    c.data[1] = num3
178    if reply_target:
179        reply_target->send_message (reply_protected, &c)
180    else
181        dpanic (0, "nothing to reply to")
182
183static void reply_cap (unsigned target, Iris::Num protected_data, kCapRef *ref, unsigned num = 0):
184    if !reply_target:
185        dpanic (0, "nothing to reply to")
186        return
187    replied_caps.set (0, (kReceiver *)target, protected_data, kCapRef (), ref)
188    kCapability::Context c
189    c.arg = kCapRef (&replied_caps, 0)
190    c.copy[1] = true
191    c.data[0] = Iris::Num (num, 0)
192    reply_target->send_message (reply_protected, &c)
193    c.arg->invalidate ()
194
195static void receiver_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
196    kReceiver *receiver = (kReceiver *)protected_data.l
197    switch cmd:
198        case Iris::Receiver::SET_OWNER & REQUEST_MASK:
199            if !c->arg.valid ():
200                reply_num (Iris::ERR_INVALID_ARGUMENT)
201                return
202            unsigned cap = (unsigned)c->arg->target
203            if cap != (CAPTYPE_THREAD | CAP_MASTER) && cap != (CAPTYPE_THREAD | Iris::Thread::SET_OWNER):
204                // FIXME: This makes it impossible to use a fake kThread capability.
205                return
206            receiver->own ((kThread *)c->arg->protected_data.l)
207            break
208        case Iris::Receiver::CREATE_CAPABILITY & REQUEST_MASK:
209            reply_cap ((unsigned)receiver, c->data[1], &receiver->capabilities)
210            return
211        case Iris::Receiver::CREATE_CALL_CAPABILITY & REQUEST_MASK:
212            reply_cap (CAPTYPE_RECEIVER | (c->data[0].h ? Iris::Receiver::CALL_ASYNC : Iris::Receiver::CALL), protected_data, &((kObject *)protected_data.l)->refs)
213            return
214        case Iris::Receiver::GET_PROTECTED & REQUEST_MASK:
215            if !c->arg.valid () || c->arg->target != receiver:
216                if !c->arg.valid ():
217                    kdebug ("invalid arg\n")
218                else:
219                    kdebug ("target: ")
220                    kdebug_num ((unsigned)c->arg->target)
221                    kdebug ("/")
222                    kdebug_num ((unsigned)c->arg->protected_data.h)
223                    kdebug (":")
224                    kdebug_num ((unsigned)c->arg->protected_data.l)
225                    kdebug ("\n")
226                dpanic (0, "wrong argument for get_protected")
227                reply_num (Iris::ERR_INVALID_ARGUMENT)
228                return
229            reply_num (c->arg->protected_data)
230            return
231        case Iris::Receiver::GET_REPLY_PROTECTED_DATA & REQUEST_MASK:
232            reply_num (receiver->reply_protected_data.l, receiver->reply_protected_data.h, receiver->protected_only ? 1 : 0)
233            return
234        case Iris::Receiver::SET_REPLY_PROTECTED_DATA & REQUEST_MASK:
235            receiver->reply_protected_data = c->data[1]
236            // Adjust target protected data, so the reply will reach the caller.
237            if receiver == reply_target:
238                reply_protected = receiver->reply_protected_data
239            break
240        case Iris::Receiver::GET_ALARM & REQUEST_MASK:
241            reply_num (receiver->alarm_count)
242            return
243        case Iris::Receiver::SET_ALARM & REQUEST_MASK:
244        case Iris::Receiver::ADD_ALARM & REQUEST_MASK:
245            unsigned old = receiver->alarm_count
246            if cmd == (Iris::Receiver::SET_ALARM & REQUEST_MASK):
247                receiver->alarm_count = c->data[1].l
248            else:
249                receiver->alarm_count += c->data[1].l
250            if (old == ~0) ^ (receiver->alarm_count == ~0):
251                // The alarm stopped or started.
252                if old == ~0:
253                    // It started.
254                    receiver->prev_alarm = NULL
255                    receiver->next_alarm = first_alarm
256                    if receiver->next_alarm:
257                        receiver->next_alarm->prev_alarm = receiver
258                    first_alarm = receiver
259                else:
260                    // It stopped.
261                    if receiver->prev_alarm:
262                        receiver->prev_alarm->next_alarm = receiver->next_alarm
263                    else:
264                        first_alarm = receiver->next_alarm
265                    if receiver->next_alarm:
266                        receiver->next_alarm->prev_alarm = receiver->prev_alarm
267            reply_num (receiver->alarm_count)
268            return
269        default:
270            dpanic (cmd, "invalid receiver operation")
271            reply_num (Iris::ERR_INVALID_OPERATION)
272            return
273    reply_num (0)
274
275static void memory_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
276    kMemory *mem = (kMemory *)protected_data.l
277    switch cmd:
278        case Iris::Memory::CREATE & REQUEST_MASK:
279            switch c->data[0].h:
280                case CAPTYPE_RECEIVER:
281                    kReceiver *ret = mem->alloc_receiver ()
282                    if ret:
283                        reply_cap (CAPTYPE_RECEIVER | CAP_MASTER, (unsigned)ret, &ret->refs)
284                    else:
285                        dpanic (0x03311992, "out of memory creating receiver")
286                        reply_num (Iris::ERR_OUT_OF_MEMORY)
287                    return
288                case CAPTYPE_MEMORY:
289                    kMemory *ret = mem->alloc_memory ()
290                    if ret:
291                        reply_cap (CAPTYPE_MEMORY | CAP_MASTER, (unsigned)ret, &ret->refs)
292                    else:
293                        dpanic (0x13311992, "out of memory creating memory")
294                        reply_num (Iris::ERR_OUT_OF_MEMORY)
295                    return
296                case CAPTYPE_THREAD:
297                    kThread *ret = mem->alloc_thread (c->data[1].l)
298                    if ret:
299                        reply_cap (CAPTYPE_THREAD | CAP_MASTER, (unsigned)ret, &ret->refs)
300                        kdebug ("(created thread ")
301                        kdebug_num ((unsigned)ret)
302                        kdebug (")\n")
303                    else:
304                        dpanic (0x23311992, "out of memory creating thread")
305                        reply_num (Iris::ERR_OUT_OF_MEMORY)
306                    return
307                case CAPTYPE_PAGE:
308                    kPage *ret = mem->alloc_page ()
309                    if ret:
310                        reply_cap (CAPTYPE_PAGE | CAP_MASTER, (unsigned)ret, &ret->refs)
311                    else:
312                        dpanic (0x33311992, "out of memory creating page")
313                        reply_num (Iris::ERR_OUT_OF_MEMORY)
314                    return
315                case CAPTYPE_CAPS:
316                    kCaps *ret = mem->alloc_caps (c->data[1].l)
317                    if ret:
318                        reply_cap (CAPTYPE_CAPS | CAP_MASTER, (unsigned)ret, &ret->refs)
319                    else:
320                        dpanic (0x43311992, "out of memory creating caps")
321                        reply_num (Iris::ERR_OUT_OF_MEMORY)
322                    return
323                case CAPTYPE_LIST:
324                    kList *ret = mem->alloc_list ()
325                    if ret:
326                        reply_cap (CAPTYPE_LIST | CAP_MASTER, (unsigned)ret, &ret->refs)
327                    else:
328                        dpanic (0x13311995, "out of memory creating list")
329                        reply_num (Iris::ERR_OUT_OF_MEMORY)
330                    return
331                case CAPTYPE_LISTITEM:
332                    kListitem *ret = mem->alloc_listitem ()
333                    if ret:
334                        reply_cap (CAPTYPE_LISTITEM | CAP_MASTER, (unsigned)ret, &ret->refs)
335                    else:
336                        dpanic (0x13311997, "out of memory creating list")
337                        reply_num (Iris::ERR_OUT_OF_MEMORY)
338                    return
339                default:
340                    dpanic (0, "invalid create type")
341                    reply_num (Iris::ERR_INVALID_ARGUMENT)
342                    return
343            break
344        case Iris::Memory::DESTROY & REQUEST_MASK:
345            if !c->arg.valid () || (unsigned)c->arg->target & ~KERNEL_MASK || !c->arg->target || ((kObject *)c->arg->protected_data.l)->address_space != mem:
346                reply_num (Iris::ERR_INVALID_ARGUMENT)
347                return
348            // Send the reply before destroying things, because the target may be destroyed.
349            reply_num (0)
350            switch (unsigned)c->arg->target & CAPTYPE_MASK:
351                case CAPTYPE_RECEIVER:
352                    mem->free_receiver ((kReceiver *)c->arg->protected_data.l)
353                    break
354                case CAPTYPE_MEMORY:
355                    mem->free_memory ((kMemory *)c->arg->protected_data.l)
356                    break
357                case CAPTYPE_THREAD:
358                    mem->free_thread ((kThread *)c->arg->protected_data.l)
359                    break
360                case CAPTYPE_PAGE:
361                    mem->free_page ((kPage *)c->arg->protected_data.l)
362                    break
363                case CAPTYPE_CAPS:
364                    mem->free_caps ((kCaps *)c->arg->protected_data.l)
365                    break
366                default:
367                    panic (0x55228930, "invalid case")
368                    return
369            return
370        case Iris::Memory::LIST & REQUEST_MASK:
371            // TODO
372            break
373        case Iris::Memory::MAP & REQUEST_MASK:
374            // FIXME: this should work for fake pages as well.
375            if !c->arg.valid () || (unsigned)c->arg->target & ~KERNEL_MASK || ((unsigned)c->arg->target & CAPTYPE_MASK) != CAPTYPE_PAGE:
376                dpanic (0x22993341, "Trying to map non-page")
377                reply_num (Iris::ERR_INVALID_ARGUMENT)
378                return
379            kPage *page = (kPage *)c->arg->protected_data.l
380            if page->address_space != mem:
381                dpanic (0x52993341, "Trying to map foreign page")
382                reply_num (Iris::ERR_INVALID_ARGUMENT)
383                return
384            if c->data[1].l & (unsigned)c->arg->target & Iris::Page::READONLY:
385                kdebug ("Mapping readonly because capability is readonly\n")
386                page->flags |= Iris::Page::MAPPED_READONLY
387            mem->map (page, c->data[1].l & PAGE_MASK)
388            break
389        case Iris::Memory::MAPPING & REQUEST_MASK:
390            kPage *page = mem->get_mapping (c->data[1].l)
391            if !page:
392                reply_num (Iris::ERR_UNMAPPED_READ)
393                return
394            unsigned t = CAPTYPE_PAGE | CAP_MASTER
395            if page->flags & Iris::Page::MAPPED_READONLY:
396                t |= Iris::Page::READONLY
397            reply_cap (t, (unsigned)page, &page->refs)
398            return
399        case Iris::Memory::GET_LIMIT & REQUEST_MASK:
400            reply_num (mem->limit)
401            return
402        case Iris::Memory::SET_LIMIT & REQUEST_MASK:
403            mem->limit = c->data[1].l
404            break
405        default:
406            dpanic (0, "invalid memory operation")
407            reply_num (Iris::ERR_INVALID_OPERATION)
408            return
409    reply_num (0)
410
411static void thread_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
412    kThread *thread = (kThread *)protected_data.l
413    switch cmd:
414        case Iris::Thread::GET_INFO & REQUEST_MASK:
415            switch c->data[0].h:
416                case Iris::Thread::PC:
417                    reply_num (thread->pc)
418                    return
419                case Iris::Thread::SP:
420                    reply_num (thread->sp)
421                    return
422                case Iris::Thread::FLAGS:
423                    reply_num (thread->flags)
424                    return
425                default:
426                    reply_num (*kThread_arch_info (thread, c->data[0].h))
427                    return
428        case Iris::Thread::SET_INFO & REQUEST_MASK:
429            unsigned *value
430            switch c->data[0].h:
431                case Iris::Thread::PC:
432                    value = &thread->pc
433                    break
434                case Iris::Thread::SP:
435                    value = &thread->sp
436                    break
437                case Iris::Thread::FLAGS:
438                    // It is not possible to set the PRIV flag (but it can be reset).
439                    if c->data[1].l & Iris::Thread::PRIV:
440                        c->data[1].h &= ~Iris::Thread::PRIV
441                    value = &thread->flags
442                    if c->data[1].h & ~Iris::Thread::USER_FLAGS:
443                        unsigned v = (*value & ~c->data[1].h) | (c->data[1].l & c->data[1].h)
444                        if (v & Iris::Thread::WAITING) != (*value & Iris::Thread::WAITING):
445                            if v & Iris::Thread::WAITING:
446                                thread->wait ()
447                            else
448                                thread->unwait ()
449                        if (v & Iris::Thread::RUNNING) != (*value & Iris::Thread::RUNNING):
450                            if v & Iris::Thread::RUNNING:
451                                thread->run ()
452                            else:
453                                thread->unrun ()
454                    break
455                default:
456                    value = kThread_arch_info (thread, c->data[0].h)
457                    break
458            if value:
459                *value = (*value & ~c->data[1].h) | (c->data[1].l & c->data[1].h)
460            break
461        case Iris::Thread::USE_SLOT & REQUEST_MASK:
462            if c->data[1].l >= thread->slots || !c->arg.valid ():
463                if c->data[1].l == 0xdeadbeef:
464                    bool dummy
465                    dbg_code.h = (unsigned)c->arg.deref ()
466                    break
467                dbg_send (5, 3)
468                dpanic (c->data[1].l, "no argument given for USE_SLOT")
469                reply_num (Iris::ERR_INVALID_ARGUMENT)
470                return
471            // FIXME: This doesn't allow using a fake caps.
472            if (unsigned)c->arg->target != (CAPTYPE_CAPS | CAP_MASTER) && (unsigned)c->arg->target != (CAPTYPE_CAPS | Iris::Caps::USE):
473                dpanic ((unsigned)c->arg->target, "argument for USE_SLOT is not a caps")
474                reply_num (Iris::ERR_INVALID_ARGUMENT)
475                return
476            unsigned slot = c->data[1].l
477            kCaps *new_caps = (kCaps *)c->arg->protected_data.l
478            if slot >= thread->slots:
479                dpanic (0, "using invalid slot")
480                return
481            thread->unset_slot (slot)
482            thread->slot[slot].caps = new_caps
483            if new_caps:
484                thread->slot[slot].next = new_caps->first_slot
485                thread->slot[slot].caps = new_caps
486                new_caps->first_slot.thread = thread
487                new_caps->first_slot.index = slot
488            break
489        case Iris::Thread::GET_CAPS & REQUEST_MASK:
490            unsigned slot = c->data[1].l
491            if slot < thread->slots:
492                reply_cap (CAPTYPE_CAPS | CAP_MASTER, (unsigned)thread->slot[slot].caps, &thread->slot[slot].caps->refs, thread->slots)
493            else:
494                reply_num (thread->slots)
495            return
496        case Iris::Thread::SCHEDULE & REQUEST_MASK:
497            do_schedule = true
498            return
499        default:
500            if !(thread->flags & Iris::Thread::PRIV):
501                dpanic (0, "invalid thread operation")
502                reply_num (Iris::ERR_INVALID_OPERATION)
503                return
504            switch cmd:
505                case Iris::Thread::PRIV_REGISTER_INTERRUPT & REQUEST_MASK:
506                    arch_register_interrupt (c->data[1].l, c->arg.valid () && (((unsigned)c->arg->target) & ~REQUEST_MASK) == CAPTYPE_RECEIVER ? (kReceiver *)c->arg->protected_data.l : NULL)
507                    break
508                case Iris::Thread::PRIV_GET_TOP_MEMORY & REQUEST_MASK:
509                    reply_cap (CAPTYPE_MEMORY | CAP_MASTER, (unsigned)&top_memory, &top_memory.refs)
510                    return
511                case Iris::Thread::PRIV_MAKE_PRIV & REQUEST_MASK:
512                    if !c->arg.valid () || ((unsigned)c->arg->target) & ~REQUEST_MASK != CAPTYPE_THREAD:
513                        dpanic (0, "not a thread argument for make priv")
514                        reply_num (Iris::ERR_INVALID_ARGUMENT)
515                        return
516                    ((kThread *)c->arg->protected_data.l)->flags |= Iris::Thread::PRIV
517                    break
518                case Iris::Thread::PRIV_ALLOC_RANGE & REQUEST_MASK:
519                    if !c->arg.valid () || ((unsigned)c->arg->target) & ~REQUEST_MASK != CAPTYPE_MEMORY:
520                        dpanic (0x54365435, "non-memory argument to alloc_range")
521                        reply_num (Iris::ERR_INVALID_ARGUMENT)
522                        return
523                    kMemory *mem = (kMemory *)c->arg->protected_data.l
524                    if !mem->use (c->data[1].l):
525                        dpanic (0x34365435, "out of memory during alloc_range")
526                        reply_num (Iris::ERR_OUT_OF_MEMORY)
527                        return
528                    unsigned data = phys_alloc (c->data[1].l)
529                    if !data:
530                        mem->unuse (c->data[1].l)
531                        dpanic (0x14365435, "out of memory during alloc_range")
532                        reply_num (Iris::ERR_OUT_OF_MEMORY)
533                        return
534                    reply_num (data & ~0xc0000000)
535                    return
536                case Iris::Thread::PRIV_ALLOC_PHYSICAL & REQUEST_MASK:
537                    if !c->arg.valid ():
538                        panic (0x71342134, "no argument provided for alloc physical")
539                        reply_num (Iris::ERR_INVALID_ARGUMENT)
540                        return
541                    if ((unsigned)c->arg->target & ~REQUEST_MASK) != CAPTYPE_PAGE:
542                        panic (0x21342134, "no page provided for alloc physical")
543                        reply_num (Iris::ERR_INVALID_ARGUMENT)
544                        return
545                    kPage *page = (kPage *)c->arg->protected_data.l
546                    page->forget ()
547                    if !(c->data[1].l & 2):
548                        if page->flags & Iris::Page::PAYING:
549                            page->flags &= ~Iris::Page::PAYING
550                            page->address_space->unuse ()
551                    else:
552                        // This is for mapping allocated ranges. They are already paid for. Record that.
553                        if page->flags & Iris::Page::PAYING:
554                            page->address_space->unuse ()
555                        else:
556                            page->flags |= Iris::Page::PAYING
557                    page->frame = (c->data[1].l & PAGE_MASK) | 0x80000000
558                    page->flags |= Iris::Page::FRAME
559                    if !(c->data[1].l & 1):
560                        page->flags |= Iris::Page::UNCACHED
561                    if !(c->data[1].l & 2):
562                        page->flags |= Iris::Page::PHYSICAL
563                    kPage_arch_update_mapping (page)
564                    break
565                case Iris::Thread::PRIV_PHYSICAL_ADDRESS & REQUEST_MASK:
566                    if !c->arg.valid () || ((unsigned)c->arg->target) & ~REQUEST_MASK != CAPTYPE_PAGE:
567                        dpanic (0x99049380, "invalid page for physical address")
568                        reply_num (Iris::ERR_INVALID_ARGUMENT)
569                        return
570                    kPage *page = (kPage *)c->arg->protected_data.l
571                    reply_num (page->frame & ~0xc0000000)
572                    return
573                case Iris::Thread::PRIV_REBOOT & REQUEST_MASK:
574                    arch_reboot ()
575                case Iris::Thread::PRIV_POWEROFF & REQUEST_MASK:
576                    arch_poweroff ()
577                case Iris::Thread::PRIV_BOOT & REQUEST_MASK:
578                    arch_boot (c->data[1].l, c->data[1].h)
579                case Iris::Thread::PRIV_PANIC & REQUEST_MASK:
580                    if c->data[1].l == 0xdeaddead:
581                        dbg_code.l = 1
582                        break
583                    panic (c->data[1].l, "panic requested by thread")
584                    reply_num (~0)
585                    return
586                case Iris::Thread::DBG_SEND & REQUEST_MASK:
587                    dbg_send (c->data[1].l, c->data[1].h)
588                    break
589                default:
590                    dpanic (0, "invalid priv thread operation")
591                    reply_num (Iris::ERR_INVALID_OPERATION)
592                    return
593    reply_num (0)
594    return
595
596static void page_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
597    kPage *page = (kPage *)protected_data.l
598    switch cmd & ~Iris::Page::READONLY:
599        case Iris::Page::SHARE & REQUEST_MASK:
600            if !c->arg.valid ():
601                // Cannot share without a target page.
602                dpanic (0, "no target page for share")
603                reply_num (Iris::ERR_INVALID_ARGUMENT)
604                return
605            if ((unsigned)c->arg->target & ~REQUEST_MASK) != CAPTYPE_PAGE:
606                // FIXME: This makes it impossible to use a fake kPage capability.
607                dpanic (0, "share target is no page")
608                reply_num (Iris::ERR_INVALID_ARGUMENT)
609                return
610            kPage *t = (kPage *)c->arg->protected_data.l
611            //kdebug ("sharing from ")
612            //kdebug_num ((unsigned)page)
613            //kdebug (" (frame ")
614            //kdebug_num (page->frame)
615            //kdebug (") to ")
616            //kdebug_num ((unsigned)t)
617            //kdebug (" (frame ")
618            //kdebug_num (t->frame)
619            //kdebug (")\n")
620            if t != page:
621                t->forget ()
622            if c->data[0].h & Iris::Page::READONLY || cmd & Iris::Page::READONLY:
623                t->flags |= Iris::Page::READONLY
624            if !(page->flags & Iris::Page::FRAME):
625                kdebug ("share problem: ")
626                kdebug_num (page->flags)
627                kdebug ("\n")
628                dpanic (0, "sharing nothing results in lost page")
629                kPage_arch_update_mapping (t)
630                break
631            if c->data[0].h & Iris::Page::COPY:
632                if ~t->flags & Iris::Page::PAYING:
633                    kPage_arch_update_mapping (t)
634                    break
635                if !(c->data[0].h & Iris::Page::FORGET) || page->flags & Iris::Page::SHARED:
636                    unsigned *d = (unsigned *)page->frame
637                    if t == page:
638                        kPage *other = page->share_next ? page->share_next : page->share_prev
639                        if !other:
640                            kPage_arch_update_mapping (t)
641                            break
642                        if page->share_next:
643                            page->share_next->share_prev = page->share_prev
644                        if page->share_prev:
645                            page->share_prev->share_next = page->share_next
646                        page->share_next = NULL
647                        page->share_prev = NULL
648                        other->check_payment ()
649                    else:
650                        t->flags |= Iris::Page::FRAME
651                    t->frame = raw_zalloc ()
652                    for unsigned i = 0; i < PAGE_SIZE; i += 4:
653                        ((unsigned *)t->frame)[i >> 2] = d[i >> 2]
654                    if c->data[0].h & Iris::Page::FORGET:
655                        page->frame = NULL
656                        page->flags &= ~Iris::Page::FRAME
657                        kPage_arch_update_mapping (page)
658                else:
659                    if t != page:
660                        t->frame = page->frame
661                        t->flags |= Iris::Page::FRAME
662                        page->frame = NULL
663                        page->flags &= ~Iris::Page::FRAME
664                        kPage_arch_update_mapping (page)
665                    else:
666                        dpanic (0, "sharing page with itself...")
667            else:
668                if t == page:
669                    dpanic (0, "sharing page with itself")
670                    kPage_arch_update_mapping (t)
671                    break
672                if c->data[0].h & Iris::Page::FORGET:
673                    if ~page->flags & Iris::Page::SHARED:
674                        if t->flags & Iris::Page::PAYING:
675                            t->frame = page->frame
676                            t->flags |= Iris::Page::FRAME
677                        else:
678                            dpanic (0, "move page failed because target is not paying")
679                        page->frame = NULL
680                        page->flags &= ~Iris::Page::FRAME
681                        kPage_arch_update_mapping (page)
682                    else:
683                        t->share_prev = page->share_prev
684                        t->share_next = page->share_next
685                        if t->share_prev:
686                            t->share_prev->share_next = t
687                        if t->share_next:
688                            t->share_next->share_prev = t
689                        page->share_prev = NULL
690                        page->share_next = NULL
691                        page->forget ()
692                        t->check_payment ()
693                else:
694                    t->share_prev = page->share_prev
695                    t->share_next = page
696                    page->share_prev = t
697                    if t->share_prev:
698                        t->share_prev->share_next = t
699                    t->frame = page->frame
700                    t->flags |= Iris::Page::FRAME
701            kPage_arch_update_mapping (t)
702            break
703        case Iris::Page::GET_FLAGS & REQUEST_MASK:
704            reply_num (page->flags)
705            return
706        case Iris::Page::SET_FLAGS & REQUEST_MASK:
707            if cmd & Iris::Page::READONLY:
708                dpanic (0, "setting page flags denied")
709                reply_num (Iris::ERR_WRITE_DENIED)
710                return
711            // Always refuse to set reserved flags.
712            c->data[1].h &= ~(Iris::Page::PHYSICAL | Iris::Page::UNCACHED)
713            // Remember the old flags.
714            unsigned old = page->flags
715            // Compute the new flags.
716            page->flags = (page->flags & ~c->data[1].h) | (c->data[1].l & c->data[1].h)
717
718            // If we stop paying, see if the frame is still paid for. If not, free it.
719            if ~page->flags & old & Iris::Page::PAYING:
720                // Decrease the use counter in any case.
721                page->address_space->unuse ()
722                page->check_payment ()
723
724            // If we start paying, increase the use counter.
725            if page->flags & ~old & Iris::Page::PAYING:
726                if !page->address_space->use():
727                    dpanic (0, "cannot pay for frame")
728                    // If it doesn't work, refuse to set the flag, and refuse to allocate a frame.
729                    page->flags &= ~(Iris::Page::PAYING | Iris::Page::FRAME)
730                    // However, if there already was a frame, keep it.
731                    if old & Iris::Page::FRAME:
732                        page->flags |= Iris::Page::FRAME
733
734            // If we want a frame, see if we can get it.
735            if ~old & page->flags & Iris::Page::FRAME:
736                if ~page->flags & Iris::Page::PAYING:
737                    dpanic (0, "cannot have frame without paying")
738                    page->flags &= ~Iris::Page::FRAME
739                else:
740                    page->frame = page->address_space->zalloc ()
741                    kPage_arch_update_mapping (page)
742            // If we lose a frame, handle it.
743            if old & ~page->flags & Iris::Page::FRAME:
744                page->forget ()
745            break
746        default:
747            dpanic (0, "invalid page operation")
748            reply_num (Iris::ERR_INVALID_OPERATION)
749            return
750    if page->flags > 0x7f:
751        dpanic (page->flags, "weird output from page operation")
752    reply_num (0)
753
754static void print_cap (kCapRef cap, kCapRef self):
755    if cap.deref () == self.deref ():
756        kdebug ('{')
757    else:
758        kdebug ('[')
759    kdebug_num ((unsigned)cap.caps)
760    kdebug (':')
761    kdebug_num (cap.index, 1)
762    if !cap.valid ():
763        kdebug ('!')
764    else:
765        kdebug ('=')
766        kdebug_num ((unsigned)cap->target)
767        kdebug (':')
768        kdebug_num (cap->protected_data.l)
769    for kCapRef c = cap->children; c.valid (); c = c->sibling_next:
770        print_cap (c, self)
771    if cap.deref () == self.deref ():
772        kdebug ('}')
773    else:
774        kdebug (']')
775
776static void caps_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
777    kCaps *caps = (kCapsP)protected_data.l
778    switch cmd:
779        case Iris::Caps::GET & REQUEST_MASK:
780            if c->data[1].l >= caps->size:
781                reply_num (Iris::ERR_INVALID_ARGUMENT)
782                kdebug_num ((unsigned)caps)
783                kdebug (" size: ")
784                kdebug_num (caps->size)
785                kdebug ('\n')
786                dpanic (c->data[1].l, "invalid index for get caps")
787                return
788            kCapability *ret = caps->cap (c->data[1].l)
789            #if 0
790            kdebug_num ((unsigned)caps)
791            kdebug (" get cap ")
792            kdebug_num (c->data[1].l)
793            kdebug (" = ")
794            kdebug_num ((unsigned)ret->target)
795            kdebug ("/")
796            kdebug_num (ret->protected_data.h)
797            kdebug (":")
798            kdebug_num (ret->protected_data.l)
799            kdebug ("\n")
800            #endif
801            reply_cap ((unsigned)ret->target, ret->protected_data, ((unsigned)ret->target & ~KERNEL_MASK) == 0 ? &((kObject *)ret->protected_data.l)->refs : &ret->target->capabilities)
802            return
803        case Iris::Caps::GET_SIZE & REQUEST_MASK:
804            reply_num (caps->size)
805            return
806        case Iris::Caps::SET & REQUEST_MASK:
807            if c->data[1].l >= caps->size:
808                dpanic (0, "invalid index for set caps")
809                return
810            caps->clone (c->data[1].l, c->arg, c->copy[1])
811            reply_num (0)
812            //kdebug_num ((unsigned)caps)
813            //kdebug (" set cap ")
814            //kdebug_num (c->data[1].l)
815            //kdebug (" to ")
816            //kdebug_num ((unsigned)caps->caps[c->data[1].l].target)
817            //kdebug ("/")
818            //kdebug_num (caps->caps[c->data[1].l].protected_data.h)
819            //kdebug (":")
820            //kdebug_num (caps->caps[c->data[1].l].protected_data.l)
821            //kdebug ("\n")
822            return
823        case Iris::Caps::TRUNCATE & REQUEST_MASK:
824            dpanic (0, "truncate caps is not implemented yet.")
825            return
826        case Iris::Caps::PRINT & REQUEST_MASK:
827            if c->data[1].l >= caps->size:
828                dpanic (0, "invalid caps for print")
829                return
830            kCapRef cap (caps, c->data[1].l)
831            kCapRef orig (caps, c->data[1].l)
832            while cap->parent.valid ():
833                while cap->sibling_prev.valid ():
834                    if cap->parent.deref () != cap->sibling_prev->parent.deref ():
835                        dpanic (0, "parent problem in cap data")
836                        return
837                    if cap.deref () != cap->sibling_prev->sibling_next.deref ():
838                        dpanic (0, "prev error in cap data")
839                        return
840                    cap = cap->sibling_prev
841                if cap->parent->children.deref () != cap.deref ():
842                    dpanic (0, "parent error in cap data")
843                    return
844                cap = cap->parent
845            while cap->sibling_prev.valid ():
846                if cap->parent.deref () != cap->sibling_prev->parent.deref ():
847                    dpanic (0, "parent parent problem in cap data")
848                    return
849                if cap.deref () != cap->sibling_prev->sibling_next.deref ():
850                    dpanic (0, "parent prev error in cap data")
851                    return
852                cap = cap->sibling_prev
853            while cap.valid ():
854                print_cap (cap, orig)
855                cap = cap->sibling_next
856            kdebug ('\n')
857            return
858        default:
859            dpanic (cmd, "invalid caps operation")
860            reply_num (Iris::ERR_INVALID_OPERATION)
861            return
862
863static void list_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
864    kList *list = (kListP)protected_data.l
865    if cmd == Iris::List::SET_CB & REQUEST_MASK:
866        list->owner.clone (0, c->arg, c->copy[1])
867        return
868    kListitem *item
869    if !c->arg.valid ():
870        item = NULL
871    else:
872        if ((unsigned)c->arg->target & ~REQUEST_MASK) != CAPTYPE_LISTITEM:
873            dpanic (0, "invalid request for list: arg is no listitem")
874            reply_num (Iris::ERR_INVALID_ARGUMENT)
875            return
876        item = (kListitem *)c->arg->protected_data.l
877        if item->list != list:
878            dpanic (0, "item list is not equal to called object")
879            reply_num (Iris::ERR_INVALID_ARGUMENT)
880            return
881    switch cmd:
882        case Iris::List::GET_NEXT & REQUEST_MASK:
883            if !item:
884                item = list->first_listitem
885            else:
886                if ((unsigned)c->arg->target & REQUEST_MASK) != CAP_MASTER && ((unsigned)c->arg->target & REQUEST_MASK) != Iris::Listitem::LIST:
887                    dpanic (0, "trying to get next listitem with insufficient rights")
888                    reply_num (Iris::ERR_INVALID_ARGUMENT)
889                    return
890                item = item->next_item
891            if !item:
892                reply_num (~0)
893                return
894            reply_cap (CAPTYPE_LISTITEM | Iris::Listitem::LIST, (unsigned)item, &item->refs)
895            return
896        case Iris::List::ADD_ITEM & REQUEST_MASK:
897            if !item:
898                dpanic (0, "invalid request: no listitem for List::ADD_ITEM")
899                reply_num (Iris::ERR_INVALID_ARGUMENT)
900                return
901            if ((unsigned)c->arg->target & REQUEST_MASK) != CAP_MASTER && ((unsigned)c->arg->target & REQUEST_MASK) != Iris::Listitem::ADD:
902                dpanic (0, "trying to add listitem with insufficient rights")
903                reply_num (Iris::ERR_INVALID_ARGUMENT)
904                return
905            ((kListitem *)c->arg->protected_data.l)->add (list)
906            break
907        case Iris::List::GET_INFO & REQUEST_MASK:
908            if !item:
909                dpanic (0, "no item for List::GET_INFO")
910                reply_num (Iris::ERR_INVALID_ARGUMENT, ~0, ~0)
911                return
912            reply_num (item->info)
913            return
914        case Iris::List::SET_INFO & REQUEST_MASK:
915            if !item:
916                dpanic (0, "no item for List::SET_INFO")
917                reply_num (Iris::ERR_INVALID_ARGUMENT)
918                return
919            item->info = c->data[1]
920            break
921        case Iris::List::GET_CAP & REQUEST_MASK:
922            if !item:
923                dpanic (0, "no item for List::GET_CAP")
924                reply_num (Iris::ERR_INVALID_ARGUMENT)
925                return
926            kCapability *cap = item->target.cap (0)
927            reply_cap ((unsigned)cap->target, cap->protected_data, ((unsigned)cap->target & ~KERNEL_MASK) == 0 ? &((kObject *)cap->target)->refs : &cap->target->capabilities)
928            return
929        default:
930            dpanic (0, "invalid list operation")
931            reply_num (Iris::ERR_INVALID_OPERATION)
932            return
933    reply_num (0)
934
935static void listitem_invoke (unsigned cmd, unsigned target, Iris::Num protected_data, kCapability::Context *c):
936    kListitem *item = (kListitemP)protected_data.l
937    switch cmd:
938        case Iris::Listitem::CLEAR & REQUEST_MASK:
939            // Disable linked capability.
940            item->add (NULL)
941            break
942        case Iris::Listitem::SET_CAP & REQUEST_MASK:
943            // Set linked capability.
944            item->target.clone (0, c->arg, c->copy[1])
945            break
946        default:
947            dpanic (0, "invalid listitem operation")
948            reply_num (Iris::ERR_INVALID_OPERATION)
949            return
950    reply_num (0)
951
952static void kill_reply (kReceiver *r):
953    kCapRef cap = r->refs
954    while cap.valid ():
955        kCapability *c = cap.deref ()
956        cap = c->sibling_next
957        if (unsigned)c->target == (CAPTYPE_RECEIVER | Iris::Receiver::REPLY):
958            c->invalidate ()
959
960static void kernel_invoke (unsigned target, Iris::Num protected_data, kCapability::Context *c):
961    // Kernel calling convention:
962    // data[0].l is the request.
963    // reply is the reply capability, or (for call capabilities) the target to call.
964    // other parameters' meanings depend on the operation.
965    if target == (CAPTYPE_RECEIVER | Iris::Receiver::CALL) || target == (CAPTYPE_RECEIVER | Iris::Receiver::CALL_ASYNC):
966        // This is a call capability. reply is the capability to call.
967        kReceiver *owner = (kReceiver *)protected_data.l
968        owner->protected_only = target == (CAPTYPE_RECEIVER | Iris::Receiver::CALL)
969        if must_wait:
970            old_current->wait ()
971        if !reply_target:
972            if (c->reply.index & ~CAP_COPY) != CAP_NONE:
973                kdebug ("target index: ")
974                kdebug_num (c->reply.index)
975                kdebug ("\n")
976                dpanic (0x54635675, "no target to call")
977            return
978        if ((unsigned)reply_target & ~KERNEL_MASK) != 0:
979            // This is a user-implemented object. Create a real reply capability.
980            kReceiver *call_target = reply_target
981            c->reply = kCapRef (&reply_caps, 0)
982            c->reply.set ((kReceiver *)(CAPTYPE_RECEIVER | Iris::Receiver::REPLY), protected_data, kCapRef (), &((kReceiver *)protected_data.l)->refs)
983            c->copy[0] = true
984            call_target->send_message (reply_protected, c)
985            c->reply->invalidate ()
986        else if (unsigned)reply_target == (CAPTYPE_RECEIVER | Iris::Receiver::REPLY):
987            // Reply capability: destroy all before invoke.
988            kReceiver *r = (kReceiver *)reply_protected.l
989            kill_reply (r)
990            r->send_message (r->reply_protected_data, c)
991        else:
992            // Kernel call: don't create actual capablities.
993            kCapRef call_target = c->reply
994            c->reply.reset ()
995            reply_target = (kReceiver *)protected_data.l
996            reply_protected = reply_target->reply_protected_data
997            kernel_invoke ((unsigned)call_target->target, call_target->protected_data, c)
998        return
999    if must_wait:
1000        old_current->wait ()
1001    if target == (CAPTYPE_RECEIVER | Iris::Receiver::REPLY):
1002        // This is a reply capability.
1003        kReceiver *r = (kReceiver *)protected_data.l
1004        kill_reply (r)
1005        r->send_message (r->reply_protected_data, c)
1006        return
1007    if !target:
1008        return
1009    unsigned cmd
1010    if (target & REQUEST_MASK) == CAP_MASTER:
1011        if c->data[0].l & CAP_MASTER_CREATE:
1012            reply_cap (target | (c->data[0].l & REQUEST_MASK), protected_data, &((kObject *)protected_data.l)->refs)
1013            return
1014        cmd = c->data[0].l
1015        c->data[0].l = 0
1016    else:
1017        cmd = target
1018    cmd &= REQUEST_MASK
1019    switch target & CAPTYPE_MASK:
1020        case CAPTYPE_RECEIVER:
1021            receiver_invoke (cmd, target, protected_data, c)
1022            break
1023        case CAPTYPE_MEMORY:
1024            memory_invoke (cmd, target, protected_data, c)
1025            break
1026        case CAPTYPE_THREAD:
1027            thread_invoke (cmd, target, protected_data, c)
1028            break
1029        case CAPTYPE_PAGE:
1030            page_invoke (cmd, target, protected_data, c)
1031            break
1032        case CAPTYPE_CAPS:
1033            caps_invoke (cmd, target, protected_data, c)
1034            break
1035        case CAPTYPE_LIST:
1036            list_invoke (cmd, target, protected_data, c)
1037            break
1038        case CAPTYPE_LISTITEM:
1039            listitem_invoke (cmd, target, protected_data, c)
1040            break
1041        default:
1042            panic (0x99337744, "invalid capability type invoked")
1043            return
1044    return
1045
1046void invoke (kReceiverP target, Iris::Num protected_data, kCapability::Context *c):
1047    if dbg_code.l && old_current->id != 1:
1048        log_message ("invoke", (unsigned)target, protected_data.l, c)
1049    if (unsigned)target & ~KERNEL_MASK:
1050        // This is not a kernel capability: send a message to the receiver.
1051        if must_wait:
1052            old_current->wait ()
1053        //else
1054        // log_message ("user invoke", (unsigned)target, protected_data.l, c)
1055        target->send_message (protected_data, c)
1056        return
1057    // This is a kernel capability. Use a function to allow optimized call capabilities.
1058    //if !must_wait && old_current->id == ~0
1059    // log_message ("kernel invoke", (unsigned)target, protected_data.l, c)
1060    context = c
1061    if c->reply.valid ():
1062        reply_target = c->reply->target
1063        reply_protected = c->reply->protected_data
1064    else:
1065        reply_target = NULL
1066        reply_protected.l = 0
1067    kernel_invoke ((unsigned)target, protected_data, c)
1068

Archive Download this file

Branches:
master



interactive