kernel/fiasco/src/kern/tb_entry.cpp

   1 INTERFACE:
   2
   3 #include "initcalls.h"
   4 #include "l4_error.h"
   5
   6 enum {
   7   Tbuf_unused             = 0,
   8   Tbuf_pf                 = 1,
   9   Tbuf_ipc                = 2,
  10   Tbuf_ipc_res            = 3,
  11   Tbuf_ipc_trace          = 4,
  12   Tbuf_ke                 = 5,
  13   Tbuf_ke_reg             = 6,
  14   Tbuf_unmap              = 7,
  15   Tbuf_shortcut_failed    = 8,
  16   Tbuf_shortcut_succeeded = 9,
  17   Tbuf_context_switch     = 10,
  18   Tbuf_exregs             = 11,
  19   Tbuf_breakpoint         = 12,
  20   Tbuf_trap               = 13,
  21   Tbuf_pf_res             = 14,
  22   Tbuf_sched              = 15,
  23   Tbuf_preemption         = 16,
  24   Tbuf_ke_bin             = 17,
  25   Tbuf_dynentries         = 18,
  26   Tbuf_max                = 0x80,
  27   Tbuf_hidden             = 0x80,
  28 };
  29
  30 #include "l4_types.h"
  31
  32 class Tb_entry;
  33
  34 typedef unsigned Tb_entry_formatter(Tb_entry *e, int max, char *buf);
  35
  36 struct Tb_log_table_entry
  37 {
  38   char const *name;
  39   unsigned char *patch;
  40   Tb_entry_formatter *fmt;
  41 };
  42
  43 extern Tb_log_table_entry _log_table[];
  44 extern Tb_log_table_entry _log_table_end;
  45
  46 class Context;
  47 class Space;
  48 class Sched_context;
  49 class Syscall_frame;
  50 class Trap_state;
  51
  52 class Tb_entry_base
  53 {
  54 protected:
  55   Mword         _number;        ///< event number
  56   Address       _ip;            ///< instruction pointer
  57   Context const *_ctx;          ///< Context
  58   Unsigned64    _tsc;           ///< time stamp counter
  59   Unsigned32    _pmc1;          ///< performance counter value 1
  60   Unsigned32    _pmc2;          ///< performance counter value 2
  61   Unsigned32    _kclock;        ///< lower 32 bits of kernel clock
  62   Unsigned8     _type;          ///< type of entry
  63   Unsigned8     _cpu;           ///< CPU
  64
  65   static Mword (*rdcnt1)();
  66   static Mword (*rdcnt2)();
  67 } __attribute__((packed));
  68
  69 class Tb_entry : public Tb_entry_base
  70 {
  71 public:
  72   template<typename T>
  73   class Payload_traits
  74   {
  75   public:
  76     enum
  77     {
  78       Align  = __alignof__(T), //(sizeof(T) > sizeof(Mword)) ? sizeof(Mword) : sizeof(T),
  79       Offset = sizeof(Tb_entry_base),
  80       Payload_offset = ((Offset + Align -1) & ~(Align-1)) - Offset,
  81       Total = Offset + Payload_offset + sizeof(T),
  82     };
  83
  84     template<int I>
  85     struct TTI
  86     {};
  87
  88     static void tb_entry_size_mismatch(TTI<false> const &) {}
  89     static void payload_too_big(TTI<false> const &) {}
  90     static void payload_too_big()
  91     {
  92       tb_entry_size_mismatch(TTI<(sizeof(Tb_entry) != Tb_entry_size)>());
  93       payload_too_big(TTI<((int)Total > (int)Tb_entry_size)>());
  94     }
  95
  96   };
  97
  98 private:
  99   template< typename T >
 100   T *addr_of_payload() const
 101   {
 102     Payload_traits<T>::payload_too_big();
 103
 104     Address p = reinterpret_cast<Address>(_payload);
 105     return reinterpret_cast<T*>(p + Payload_traits<T>::Payload_offset);
 106   }
 107
 108 public:
 109   char _payload[Tb_entry_size-sizeof(Tb_entry_base)];
 110
 111   template<typename T>
 112   T *payload() { return addr_of_payload<T>(); }
 113
 114   template<typename T>
 115   T const *payload() const { return addr_of_payload<T>(); }
 116
 117
 118 };
 119
 120 /** logged ipc. */
 121 class Tb_entry_ipc : public Tb_entry
 122 {
 123 private:
 124   struct Payload
 125   {
 126     L4_msg_tag  _tag;           ///< message tag
 127     Mword       _dword[2];      ///< first two message words
 128     L4_obj_ref  _dst;           ///< destination id
 129     Mword       _dbg_id;
 130     Mword       _label;
 131     L4_timeout_pair _timeout;   ///< timeout
 132   };
 133 };
 134
 135 /** logged ipc result. */
 136 class Tb_entry_ipc_res : public Tb_entry
 137 {
 138 private:
 139   struct Payload
 140   {
 141     L4_msg_tag  _tag;           ///< message tag
 142     Mword       _dword[2];      ///< first two dwords
 143     L4_error    _result;        ///< result
 144     Mword       _from;          ///< receive descriptor
 145     Mword       _pair_event;    ///< referred event
 146     Unsigned8   _have_snd;      ///< ipc had send part
 147     Unsigned8   _is_np;         ///< next period bit set
 148   };
 149 };
 150
 151 /** logged ipc for user level tracing with Vampir. */
 152 class Tb_entry_ipc_trace : public Tb_entry
 153 {
 154 private:
 155   struct Payload
 156   {
 157     Unsigned64  _snd_tsc;       ///< entry tsc
 158     L4_msg_tag  _result;        ///< result
 159     L4_obj_ref  _snd_dst;       ///< send destination
 160     Mword       _rcv_dst;       ///< rcv partner
 161     Unsigned8   _snd_desc;
 162     Unsigned8   _rcv_desc;
 163   };
 164 };
 165
 166 #if 0
 167 /** logged short-cut ipc failed. */
 168 class Tb_entry_ipc_sfl : public Tb_entry_base
 169 {
 170 private:
 171   Global_id     _from;  ///< short ipc rcv descriptor
 172   L4_timeout_pair       _timeout;       ///< ipc timeout
 173   Global_id     _dst;           ///< partner
 174   Unsigned8     _is_irq, _snd_lst, _dst_ok, _dst_lck, _preempt;
 175 };
 176 #endif
 177
 178 /** logged pagefault. */
 179 class Tb_entry_pf : public Tb_entry
 180 {
 181 private:
 182   struct Payload
 183   {
 184     Address     _pfa;           ///< pagefault address
 185     Mword       _error;         ///< pagefault error code
 186     Space       *_space;
 187   };
 188 };
 189
 190 /** pagefault result. */
 191 class Tb_entry_pf_res : public Tb_entry
 192 {
 193 private:
 194   struct Payload
 195   {
 196     Address     _pfa;
 197     L4_error    _err;
 198     L4_error    _ret;
 199   };
 200 };
 201
 202
 203 /** logged kernel event. */
 204 class Tb_entry_ke : public Tb_entry
 205 {
 206   enum { MSG_POINTER_PAYLOAD_OFFSET
 207            = 5 - ((sizeof(Tb_entry_base) + 2 + 3) % sizeof(Mword)) };
 208 };
 209
 210 /** logged breakpoint. */
 211 class Tb_entry_bp : public Tb_entry
 212 {
 213 private:
 214   struct Payload
 215   {
 216     Address     _address;       ///< breakpoint address
 217     int         _len;           ///< breakpoint length
 218     Mword       _value;         ///< value at address
 219     int         _mode;          ///< breakpoint mode
 220   } __attribute__((packed));
 221 };
 222
 223 /** logged context switch. */
 224 class Tb_entry_ctx_sw : public Tb_entry
 225 {
 226 private:
 227   struct Payload
 228   {
 229     Context const *_dst;                ///< switcher target
 230     Context const *_dst_orig;
 231     Address     _kernel_ip;
 232     Mword       _lock_cnt;
 233     Space       *_from_space;
 234     Sched_context *_from_sched;
 235     Mword       _from_prio;
 236   } __attribute__((packed));
 237 };
 238
 239 /** logged scheduling event. */
 240 class Tb_entry_sched : public Tb_entry
 241 {
 242 private:
 243   struct Payload
 244   {
 245     unsigned short _mode;
 246     Context const *_owner;
 247     unsigned short _id;
 248     unsigned short _prio;
 249     signed long  _left;
 250     unsigned long  _quantum;
 251   } __attribute__((packed));
 252 };
 253
 254
 255 /** logged preemption */
 256 class Tb_entry_preemption : public Tb_entry
 257 {
 258 private:
 259   struct Payload
 260   {
 261     Mword        _preempter;
 262   };
 263 };
 264
 265
 266 /** logged binary kernel event. */
 267 class Tb_entry_ke_bin : public Tb_entry
 268 {
 269 public:
 270   enum { SIZE = 30 };
 271 };
 272
 273
 274
 275 IMPLEMENTATION:
 276
 277 #include <cstring>
 278 #include <cstdarg>
 279
 280 #include "entry_frame.h"
 281 #include "globals.h"
 282 #include "kip.h"
 283 #include "static_init.h"
 284 #include "trap_state.h"
 285
 286
 287 PROTECTED static Mword Tb_entry_base::dummy_read_pmc() { return 0; }
 288
 289 Mword (*Tb_entry_base::rdcnt1)() = dummy_read_pmc;
 290 Mword (*Tb_entry_base::rdcnt2)() = dummy_read_pmc;
 291
 292
 293 PUBLIC static
 294 void
 295 Tb_entry::set_rdcnt(int num, Mword (*f)())
 296 {
 297   if (!f)
 298     f = dummy_read_pmc;
 299
 300   switch (num)
 301     {
 302     case 0: rdcnt1 = f; break;
 303     case 1: rdcnt2 = f; break;
 304     }
 305 }
 306
 307 PUBLIC inline
 308 void
 309 Tb_entry_base::clear()
 310 { _type = Tbuf_unused; }
 311
 312 PUBLIC inline NEEDS["kip.h", "globals.h"]
 313 void
 314 Tb_entry_base::set_global(char type, Context const *ctx, Address ip)
 315 {
 316   _type   = type;
 317   _ctx    = ctx;
 318   _ip     = ip;
 319   _kclock = (Unsigned32)Kip::k()->clock;
 320   _cpu    = current_cpu();
 321 }
 322
 323 PUBLIC inline
 324 void
 325 Tb_entry_base::hide()
 326 { _type |= Tbuf_hidden; }
 327
 328 PUBLIC inline
 329 void
 330 Tb_entry_base::unhide()
 331 { _type &= ~Tbuf_hidden; }
 332
 333 PUBLIC inline
 334 Address
 335 Tb_entry_base::ip() const
 336 { return _ip; }
 337
 338 PUBLIC inline
 339 Context const *
 340 Tb_entry_base::ctx() const
 341 { return _ctx; }
 342
 343 PUBLIC inline
 344 Unsigned8
 345 Tb_entry_base::type() const
 346 { return _type & (Tbuf_max-1); }
 347
 348 PUBLIC inline
 349 int
 350 Tb_entry_base::hidden() const
 351 { return _type & Tbuf_hidden; }
 352
 353 PUBLIC inline
 354 Mword
 355 Tb_entry_base::number() const
 356 { return _number; }
 357
 358 PUBLIC inline
 359 void
 360 Tb_entry_base::number(Mword number)
 361 { _number = number; }
 362
 363 PUBLIC inline
 364 void
 365 Tb_entry_base::rdpmc1()
 366 { _pmc1 = rdcnt1(); }
 367
 368 PUBLIC inline
 369 void
 370 Tb_entry_base::rdpmc2()
 371 { _pmc2 = rdcnt2(); }
 372
 373 PUBLIC inline
 374 Unsigned32
 375 Tb_entry_base::kclock() const
 376 { return _kclock; }
 377
 378 PUBLIC inline
 379 Unsigned8
 380 Tb_entry_base::cpu() const
 381 { return _cpu; }
 382
 383 PUBLIC inline
 384 Unsigned64
 385 Tb_entry_base::tsc() const
 386 { return _tsc; }
 387
 388 PUBLIC inline
 389 Unsigned32
 390 Tb_entry_base::pmc1() const
 391 { return _pmc1; }
 392
 393 PUBLIC inline
 394 Unsigned32
 395 Tb_entry_base::pmc2() const
 396 { return _pmc2; }
 397
 398
 399 PUBLIC inline NEEDS ["entry_frame.h"]
 400 void
 401 Tb_entry_ipc::set(Context const *ctx, Mword ip, Syscall_frame *ipc_regs, Utcb *utcb,
 402                   Mword dbg_id, Unsigned64 left)
 403 {
 404   set_global(Tbuf_ipc, ctx, ip);
 405   Payload *p = payload<Payload>();
 406   p->_dst       = ipc_regs->ref();
 407   p->_label     = ipc_regs->from_spec();
 408
 409
 410   p->_dbg_id = dbg_id;
 411
 412   p->_timeout   = ipc_regs->timeout();
 413   p->_tag       = ipc_regs->tag();
 414   if (ipc_regs->next_period())
 415     {
 416       p->_dword[0]  = (Unsigned32)(left & 0xffffffff);
 417       p->_dword[1]  = (Unsigned32)(left >> 32);
 418     }
 419   else
 420     {
 421       // hint for gcc
 422       register Mword tmp0 = utcb->values[0];
 423       register Mword tmp1 = utcb->values[1];
 424       p->_dword[0]  = tmp0;
 425       p->_dword[1]  = tmp1;
 426     }
 427 }
 428
 429 PUBLIC inline
 430 void
 431 Tb_entry_ipc::set_sc(Context const *ctx, Mword ip, Syscall_frame *ipc_regs,
 432                      Utcb *utcb, Unsigned64 left)
 433 {
 434   set_global(Tbuf_shortcut_succeeded, ctx, ip);
 435   Payload *p = payload<Payload>();
 436   p->_dst       = ipc_regs->ref();
 437   p->_timeout   = ipc_regs->timeout();
 438   if (ipc_regs->next_period())
 439     {
 440       p->_dword[0]  = (Unsigned32)(left & 0xffffffff);
 441       p->_dword[1]  = (Unsigned32)(left >> 32);
 442     }
 443   else
 444     {
 445       // hint for gcc
 446       register Mword tmp0 = utcb->values[0];
 447       register Mword tmp1 = utcb->values[1];
 448       p->_dword[0]  = tmp0;
 449       p->_dword[1]  = tmp1;
 450     }
 451 }
 452
 453
 454 PUBLIC inline
 455 Mword
 456 Tb_entry_ipc::ipc_type() const
 457 { return payload<Payload>()->_dst.op(); }
 458
 459 PUBLIC inline
 460 Mword
 461 Tb_entry_ipc::dbg_id() const
 462 { return payload<Payload>()->_dbg_id; }
 463
 464 PUBLIC inline
 465 L4_obj_ref
 466 Tb_entry_ipc::dst() const
 467 { return payload<Payload>()->_dst; }
 468
 469 PUBLIC inline
 470 L4_timeout_pair
 471 Tb_entry_ipc::timeout() const
 472 { return payload<Payload>()->_timeout; }
 473
 474 PUBLIC inline
 475 L4_msg_tag
 476 Tb_entry_ipc::tag() const
 477 { return payload<Payload>()->_tag; }
 478
 479 PUBLIC inline
 480 Mword
 481 Tb_entry_ipc::label() const
 482 { return payload<Payload>()->_label; }
 483
 484 PUBLIC inline
 485 Mword
 486 Tb_entry_ipc::dword(unsigned index) const
 487 { return payload<Payload>()->_dword[index]; }
 488
 489
 490 PUBLIC inline NEEDS ["entry_frame.h"]
 491 void
 492 Tb_entry_ipc_res::set(Context const *ctx, Mword ip, Syscall_frame *ipc_regs,
 493                       Utcb *utcb,
 494                       Mword result, Mword pair_event, Unsigned8 have_snd,
 495                       Unsigned8 is_np)
 496 {
 497   set_global(Tbuf_ipc_res, ctx, ip);
 498   Payload *p = payload<Payload>();
 499   // hint for gcc
 500   register Mword tmp0 = utcb->values[0];
 501   register Mword tmp1 = utcb->values[1];
 502   p->_dword[0]   = tmp0;
 503   p->_dword[1]   = tmp1;
 504   p->_tag        = ipc_regs->tag();
 505   p->_pair_event = pair_event;
 506   p->_result     = L4_error::from_raw(result);
 507   p->_from       = ipc_regs->from_spec();
 508   p->_have_snd   = have_snd;
 509   p->_is_np      = is_np;
 510 }
 511
 512 PUBLIC inline
 513 int
 514 Tb_entry_ipc_res::have_snd() const
 515 { return payload<Payload>()->_have_snd; }
 516
 517 PUBLIC inline
 518 int
 519 Tb_entry_ipc_res::is_np() const
 520 { return payload<Payload>()->_is_np; }
 521
 522 PUBLIC inline
 523 Mword
 524 Tb_entry_ipc_res::from() const
 525 { return payload<Payload>()->_from; }
 526
 527 PUBLIC inline
 528 L4_error
 529 Tb_entry_ipc_res::result() const
 530 { return payload<Payload>()->_result; }
 531
 532 PUBLIC inline
 533 L4_msg_tag
 534 Tb_entry_ipc_res::tag() const
 535 { return payload<Payload>()->_tag; }
 536
 537 PUBLIC inline
 538 Mword
 539 Tb_entry_ipc_res::dword(unsigned index) const
 540 { return payload<Payload>()->_dword[index]; }
 541
 542 PUBLIC inline
 543 Mword
 544 Tb_entry_ipc_res::pair_event() const
 545 { return payload<Payload>()->_pair_event; }
 546
 547
 548 PUBLIC inline
 549 void
 550 Tb_entry_ipc_trace::set(Context const *ctx, Mword ip, Unsigned64 snd_tsc,
 551                         L4_obj_ref const &snd_dst, Mword rcv_dst,
 552                         L4_msg_tag result, Unsigned8 snd_desc,
 553                         Unsigned8 rcv_desc)
 554 {
 555   set_global(Tbuf_ipc_trace, ctx, ip);
 556   payload<Payload>()->_snd_tsc  = snd_tsc;
 557   payload<Payload>()->_snd_dst  = snd_dst;
 558   payload<Payload>()->_rcv_dst  = rcv_dst;
 559   payload<Payload>()->_result   = result;
 560   payload<Payload>()->_snd_desc = snd_desc;
 561   payload<Payload>()->_rcv_desc = rcv_desc;
 562 }
 563
 564 #if 0
 565 PUBLIC inline
 566 void
 567 Tb_entry_ipc_sfl::set(Context *ctx, Mword ip,
 568                       Global_id from,
 569                       L4_timeout_pair timeout, Global_id dst,
 570                       Unsigned8 is_irq, Unsigned8 snd_lst,
 571                       Unsigned8 dst_ok, Unsigned8 dst_lck,
 572                       Unsigned8 preempt)
 573 {
 574   set_global(Tbuf_shortcut_failed, ctx, ip);
 575   Payload *p = payload<Payload>();
 576   p->_from      = from;
 577   p->_timeout   = timeout;
 578   p->_dst       = dst;
 579   p->_is_irq    = is_irq;
 580   p->_snd_lst   = snd_lst;
 581   p->_dst_ok    = dst_ok;
 582   p->_dst_lck   = dst_lck;
 583   p->_preempt   = preempt;
 584 }
 585
 586 PUBLIC inline
 587 L4_timeout_pair
 588 Tb_entry_ipc_sfl::timeout() const
 589 { return _timeout; }
 590
 591 PUBLIC inline
 592 Global_id
 593 Tb_entry_ipc_sfl::from() const
 594 { return _from; }
 595
 596 PUBLIC inline
 597 Global_id
 598 Tb_entry_ipc_sfl::dst() const
 599 { return _dst; }
 600
 601 PUBLIC inline
 602 Unsigned8
 603 Tb_entry_ipc_sfl::is_irq() const
 604 { return _is_irq; }
 605
 606 PUBLIC inline
 607 Unsigned8
 608 Tb_entry_ipc_sfl::snd_lst() const
 609 { return _snd_lst; }
 610
 611 PUBLIC inline
 612 Unsigned8
 613 Tb_entry_ipc_sfl::dst_ok() const
 614 { return _dst_ok; }
 615
 616 PUBLIC inline
 617 Unsigned8
 618 Tb_entry_ipc_sfl::dst_lck() const
 619 { return _dst_lck; }
 620
 621 PUBLIC inline
 622 Unsigned8
 623 Tb_entry_ipc_sfl::preempt() const
 624 { return _preempt; }
 625 #endif
 626
 627 PUBLIC inline
 628 void
 629 Tb_entry_pf::set(Context const *ctx, Address ip, Address pfa,
 630                  Mword error, Space *spc)
 631 {
 632   set_global(Tbuf_pf, ctx, ip);
 633   Payload *p = payload<Payload>();
 634   p->_pfa   = pfa;
 635   p->_error = error;
 636   p->_space = spc;
 637 }
 638
 639 PUBLIC inline
 640 Mword
 641 Tb_entry_pf::error() const
 642 { return payload<Payload>()->_error; }
 643
 644 PUBLIC inline
 645 Address
 646 Tb_entry_pf::pfa() const
 647 { return payload<Payload>()->_pfa; }
 648
 649 PUBLIC inline
 650 Space*
 651 Tb_entry_pf::space() const
 652 { return payload<Payload>()->_space; }
 653
 654
 655 PUBLIC inline
 656 void
 657 Tb_entry_pf_res::set(Context const *ctx, Address ip, Address pfa,
 658                      L4_error err, L4_error ret)
 659 {
 660   set_global(Tbuf_pf_res, ctx, ip);
 661   Payload *p = payload<Payload>();
 662   p->_pfa = pfa;
 663   p->_err = err;
 664   p->_ret = ret;
 665 }
 666
 667 PUBLIC inline
 668 Address
 669 Tb_entry_pf_res::pfa() const
 670 { return payload<Payload>()->_pfa; }
 671
 672 PUBLIC inline
 673 L4_error
 674 Tb_entry_pf_res::err() const
 675 { return payload<Payload>()->_err; }
 676
 677 PUBLIC inline
 678 L4_error
 679 Tb_entry_pf_res::ret() const
 680 { return payload<Payload>()->_ret; }
 681
 682
 683 PUBLIC inline
 684 void
 685 Tb_entry_bp::set(Context const *ctx, Address ip,
 686                  int mode, int len, Mword value, Address address)
 687 {
 688   set_global(Tbuf_breakpoint, ctx, ip);
 689   payload<Payload>()->_mode    = mode;
 690   payload<Payload>()->_len     = len;
 691   payload<Payload>()->_value   = value;
 692   payload<Payload>()->_address = address;
 693 }
 694
 695
 696
 697 PUBLIC inline
 698 int
 699 Tb_entry_bp::mode() const
 700 { return payload<Payload>()->_mode; }
 701
 702 PUBLIC inline
 703 int
 704 Tb_entry_bp::len() const
 705 { return payload<Payload>()->_len; }
 706
 707 PUBLIC inline
 708 Mword
 709 Tb_entry_bp::value() const
 710 { return payload<Payload>()->_value; }
 711
 712 PUBLIC inline
 713 Address
 714 Tb_entry_bp::addr() const
 715 { return payload<Payload>()->_address; }
 716
 717
 718
 719 PUBLIC inline
 720 void
 721 Tb_entry_ke::set(Context const *ctx, Address ip)
 722 { set_global(Tbuf_ke, ctx, ip); }
 723
 724 PUBLIC inline
 725 void
 726 Tb_entry_ke::set_const(Context const *ctx, Address ip, const char * const msg)
 727 {
 728   set_global(Tbuf_ke, ctx, ip);
 729   char *_msg = payload<char>();
 730   _msg[0] = 0; _msg[1] = 1;
 731   *(char const ** const)(_msg + MSG_POINTER_PAYLOAD_OFFSET) = msg;
 732 }
 733
 734 PUBLIC inline
 735 void
 736 Tb_entry_ke::set_buf(unsigned i, char c)
 737 {
 738   char *_msg = payload<char>();
 739   if (i < sizeof(_payload)-1)
 740     _msg[i] = c >= ' ' ? c : '.';
 741 }
 742
 743 PUBLIC inline
 744 void
 745 Tb_entry_ke::term_buf(unsigned i)
 746 {
 747   char *_msg = payload<char>();
 748   _msg[i < sizeof(_payload)-1 ? i : sizeof(_payload)-1] = '\0';
 749 }
 750
 751 PUBLIC inline
 752 const char *
 753 Tb_entry_ke::msg() const
 754 {
 755   char const *_msg = payload<char>();
 756   return _msg[0] == 0 && _msg[1] == 1
 757     ? *(char const ** const)(_msg + MSG_POINTER_PAYLOAD_OFFSET) : _msg;
 758 }
 759
 760
 761 PUBLIC inline
 762 void
 763 Tb_entry_ctx_sw::set(Context const *ctx, Space *from_space, Address ip,
 764                      Context const *dst, Context const *dst_orig,
 765                      Mword lock_cnt,
 766                      Sched_context *from_sched, Mword from_prio,
 767                      Address kernel_ip)
 768 {
 769   set_global(Tbuf_context_switch, ctx, ip);
 770   payload<Payload>()->_kernel_ip = kernel_ip;
 771   payload<Payload>()->_dst        = dst;
 772   payload<Payload>()->_dst_orig   = dst_orig;
 773   payload<Payload>()->_lock_cnt   = lock_cnt;
 774   payload<Payload>()->_from_space = from_space;
 775   payload<Payload>()->_from_sched = from_sched;
 776   payload<Payload>()->_from_prio  = from_prio;
 777 }
 778
 779 PUBLIC inline
 780 Space*
 781 Tb_entry_ctx_sw::from_space() const
 782 { return payload<Payload>()->_from_space; }
 783
 784 PUBLIC inline
 785 Address
 786 Tb_entry_ctx_sw::kernel_ip() const
 787 { return payload<Payload>()->_kernel_ip; }
 788
 789 PUBLIC inline
 790 Mword
 791 Tb_entry_ctx_sw::lock_cnt() const
 792 { return payload<Payload>()->_lock_cnt; }
 793
 794 PUBLIC inline
 795 Context const *
 796 Tb_entry_ctx_sw::dst() const
 797 { return payload<Payload>()->_dst; }
 798
 799 PUBLIC inline
 800 Context const *
 801 Tb_entry_ctx_sw::dst_orig() const
 802 { return payload<Payload>()->_dst_orig; }
 803
 804 PUBLIC inline
 805 Mword
 806 Tb_entry_ctx_sw::from_prio() const
 807 { return payload<Payload>()->_from_prio; }
 808
 809 PUBLIC inline
 810 Sched_context*
 811 Tb_entry_ctx_sw::from_sched() const
 812 { return payload<Payload>()->_from_sched; }
 813
 814 PUBLIC inline
 815 void
 816 Tb_entry_sched::set (Context const *ctx, Address ip, unsigned short mode,
 817                      Context const *owner, unsigned short id, unsigned short prio,
 818                      signed long left, unsigned long quantum)
 819 {
 820   set_global (Tbuf_sched, ctx, ip);
 821   payload<Payload>()->_mode    = mode;
 822   payload<Payload>()->_owner   = owner;
 823   payload<Payload>()->_id      = id;
 824   payload<Payload>()->_prio    = prio;
 825   payload<Payload>()->_left    = left;
 826   payload<Payload>()->_quantum = quantum;
 827 }
 828
 829 PUBLIC inline
 830 unsigned short
 831 Tb_entry_sched::mode() const
 832 { return payload<Payload>()->_mode; }
 833
 834 PUBLIC inline
 835 Context const *
 836 Tb_entry_sched::owner() const
 837 { return payload<Payload>()->_owner; }
 838
 839 PUBLIC inline
 840 unsigned short
 841 Tb_entry_sched::id() const
 842 { return payload<Payload>()->_id; }
 843
 844 PUBLIC inline
 845 unsigned short
 846 Tb_entry_sched::prio() const
 847 { return payload<Payload>()->_prio; }
 848
 849 PUBLIC inline
 850 unsigned long
 851 Tb_entry_sched::quantum() const
 852 { return payload<Payload>()->_quantum; }
 853
 854 PUBLIC inline
 855 signed long
 856 Tb_entry_sched::left() const
 857 { return payload<Payload>()->_left; }
 858
 859 PUBLIC inline
 860 void
 861 Tb_entry_preemption::set (Context const *ctx, Mword preempter,
 862                           Address ip)
 863 {
 864   set_global (Tbuf_preemption, ctx, ip);
 865   payload<Payload>()->_preempter = preempter;
 866 };
 867
 868 PUBLIC inline
 869 Mword
 870 Tb_entry_preemption::preempter() const
 871 { return payload<Payload>()->_preempter; }
 872
 873
 874
 875 PUBLIC inline
 876 void
 877 Tb_entry_ke_bin::set(Context const *ctx, Address ip)
 878 { set_global(Tbuf_ke_bin, ctx, ip); }
 879
 880 PUBLIC inline
 881 void
 882 Tb_entry_ke_bin::set_buf(unsigned i, char c)
 883 {
 884   char *_bin = payload<char>();
 885   if (i < sizeof(_payload)-1)
 886     _bin[i] = c;
 887 }