src/ipc/msg.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       msg.cpp, version 1.1                               *
************************************************************
*                                                          *
*draft                                                     *
*                                                          *
*26'05'04- first revision (1.0), based a little on 0.05    *
*experimental branch's message passing                     *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/scheduler.hpp"
#include "src/thread/thread.hpp"
#include "src/ipc/msg.hpp"
#include "src/ipc/sem.hpp"


namespace IPC {
namespace Message {


//create a mailbox
int allocate_mailbox (mailbox *mbx, class ::Thread::thread_t *owner, Memory::Heap::heapbox *hp)
 {
//init vars
        memset(mbx,0,sizeof(mailbox));
        mbx->lock_mail.init(const_cast<char*>("mailbox"));
        sem_init(&mbx->sem_mail,0,"mailbox");
        (*(blist_t*)&mbx->inbox).init(FAC_MSG|FAC_MSGLIST);
        mbx->heap=hp;
        mbx->thread=owner;

        return ESUCCESS;
 }
// 
// //add a message to the inbox
// int mailbox::new_mail(mailbox *sender, void *data, size_t size, uint32 flags)
//  {
// union
//  {
//      uint32 i32[2];
//      uint64 i64;
//  } uu;
// 
// int i;
// message *msg;
// //alloc a message
//      msg=(message*)heap->malloc(sizeof(message)+size, NO_ALIGN, FAC_MSG|FAC_MESSAGE, NULL);
// 
//      if (msg == NULL)
//       {
//              complain("out of memory");
//              return EFAIL;
//       }
//      memset(msg, 0, sizeof(message)+size);
// //prepare a message
//      msg->sender=sender;
//      msg->flags=flags;
//      msg->size=size;
//      msg->time_stamp=Arch::x86::RTC::up_time;
// //copy data
//      memmove(&msg[1], data, size);
// 
//      lock_mail.lock();
// //add to inbox
//      i=((*(blist_t*)&inbox).ptr(msg, NULL)==NULL? EFAIL:ESUCCESS);
//      if (i==EFAIL) {lock_mail.ulock();
// //           asm volatile("popf\ncli");
//              return EFAIL; }
// //increase counter
//      mail++;
// //   asm volatile("pushf\ncli");
// //unblock the owner-thread of the mailbox
//      uu.i64=((Thread::thread_t*)thread)->sem_dt;
// // write_bochs("(");write_bochs(thread->name);write_bochs("A)");
//      if (((Thread::thread_t*)thread)->sem_id==&sem_mail)
//              if (( (mailbox*) uu.i32[1] == NULL) ||
//                      ( (mailbox*) uu.i32[1] == msg->sender))
//                              { Thread::sem_awake(thread); }
// 
//      lock_mail.ulock();
// //   asm volatile("popf\ncli");
// 
//      return i;
//  }
// 
//free memory
void mailbox::done()
 {
        lock_mail.lock();
        sem_destroy(&sem_mail);
        ((blist_t*)&inbox)->done();
 }
// 
// int mailbox::ksend(mailbox *dest, void *data, size_t size, uint32 flags) {
//      return dest->new_mail(this, data, size, flags);
//  }
// 
// int mailbox::kreceive(message **msg)
//  {
// union
//  {
//      uint32 i32[2];
//      uint64 i64;
//  } uu;
// //   asm volatile("pushf\ncli");
//      *msg=NULL;
//      lock_mail.lock();
// //check for messages
//      if (inbox.head == NULL)
//       {
//              asm volatile("pushf\ncli");
//              uu.i32[0]=(uint32)this;
//              uu.i32[1]=0;
//              lock_mail.ulock();
//              Thread::sem_sleep( &sem_mail, uu.i64 );
//              asm volatile("popf");
//       }
// //get and remove the oldest 
//      *msg=bli_dt(inbox.head,message*);
//      (*(blist_t*)&inbox).del(inbox.head);
// //decrease counter
//      mail--;
//      lock_mail.ulock();
// //   asm volatile("popf");
//      return ESUCCESS;
//  }
// 
// int mailbox::kreceive(message **msg, mailbox *sender)
//  {
// union
//  {
//      uint32 i32[2];
//      uint64 i64;
//  } uu;
//      *msg=NULL;
// blist_s *item;
// //wait for messages
// 
//      do {
//      lock_mail.lock();
//      for (item=inbox.head;item;item=item->next)
//              if (bli_dt(item,message*)->sender == sender)
//               {
//              //get and remove
//                      *msg=bli_dt(item,message*);
//                      (*(blist_t*)&inbox).del(item);
//              //decrease counter
//                      mail--;
// 
//                      lock_mail.ulock();
//                      return ESUCCESS;
//               }
// 
//      asm volatile("pushf\ncli");
//      lock_mail.ulock();
// //no messages from that source? block
//      uu.i32[0]=(uint32)this;
//      uu.i32[1]=(uint32)sender;
//      Thread::sem_sleep( &sem_mail, uu.i64 );
//      asm volatile("popf");
//      } while(1);
// 
//      return ESUCCESS;
//  }
// 
// //how many messages are waiting in the inbox
// int mailbox::count() {
//      return mail;
//  }
// 
// int mailbox::free_msg(message *msg) {
//      return heap->free(msg);
//  }


  };    /*namespace Message*/
 };     /*namespace IPC*/


/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---