Main Page | Class List | Directories | File List | Class Members | File Members
src

backend.c File Reference

#include "global.h"
#include "fdlib.h"
#include "backend.h"
#include <errno.h>
#include <string.h>
#include "interpret.h"
#include "object.h"
#include "pike_error.h"
#include "fd_control.h"
#include "main.h"
#include "callback.h"
#include "threads.h"
#include "array.h"
#include <math.h>
#include "stuff.h"
#include "bignum.h"
#include "svalue.h"
#include "gc.h"
#include <sys/stat.h>
#include "block_alloc_h.h"
#include "block_alloc.h"

Classes

struct  call_out_s
struct  hash_ent
struct  selectors
struct  active_selectors
struct  Backend_struct
struct  compat_cb_box

Defines

#define PRECOMPILE_API_VERSION   2
#define IF_PD(x)
#define IF_CO(X)
#define THR_NO   getpid()
#define MESS_UP_BLOCK(X)
#define EXIT_BLOCK(X)
#define alloc_call_out()   debug_malloc_pass(alloc_call_out_s())
#define really_free_call_out(X)   really_free_call_out_s(debug_malloc_pass(X))
#define TIMEOUT_IS_TIMEVAL
#define MY_POLLIN   &me->set.read
#define MY_POLLOUT   &me->set.write
#define MY_POLLEXCEPT   &me->set.except
#define MY_POLLRDBAND   &me->set.except
#define MY_POLLWREXCEPT   &me->set.write
#define MY_POLLWRBAND   &me->set.write
#define RDBAND_IS_SPECIAL
#define MY_POLL(SET, TIMEOUT)
#define POLL_SET_SIZE   32
#define CHECK_EVENT(EVENT, MASK)   (GET_EVENTS(EVENT) & (MASK))
#define CHECK_ERROR_EVENT(EVENT, MASK)   CHECK_EVENT(EVENT, MASK)
#define MY_FD_CLR_RDBAND(SET, FD)
#define MY_FD_CLR_WRBAND(SET, FD)
#define MY_POLLERR   POLLERR
#define MY_POLLHUP   POLLHUP
#define class_Backend_defined
#define var_id_Backend_defined
#define var_backend_callbacks_Backend_defined
#define var_exec_thread_Backend_defined_2
#define var_wakeup_pipe_send_fd_Backend_defined
#define var_wakeup_cb_box_Backend_defined
#define var_fd_boxes_Backend_defined
#define var_fd_boxes_size_Backend_defined
#define var_free_inactive_box_Backend_defined
#define var_inactive_boxes_size_Backend_defined
#define var_set_Backend_defined_2
#define var_active_set_Backend_defined
#define var_num_pending_calls_Backend_defined
#define var_call_buffer_Backend_defined
#define var_call_buffer_size_Backend_defined
#define var_hash_size_Backend_defined
#define var_hash_order_Backend_defined
#define var_call_hash_Backend_defined
#define var_backend_obj_Backend_defined
#define THIS   ((struct Backend_struct *)(Pike_interpreter.frame_pointer->current_storage))
#define THIS_BACKEND   ((struct Backend_struct *)(Pike_interpreter.frame_pointer->current_storage))
#define OBJ2_BACKEND(o)   ((struct Backend_struct *)(o->storage+Backend_storage_offset))
#define GET_BACKEND_STORAGE   ((struct Backend_struct *)(o->storage+Backend_storage_offset)
#define CAR(X)   (((X)<<1)+1)
#define CDR(X)   (((X)<<1)+2)
#define PARENT(X)   (((X)-1)>>1)
#define CALL_(X)   (me->call_buffer[(X)])
#define CALL(X)   ((struct call_out_s *)debug_malloc_pass(CALL_(X)))
#define MOVECALL(X, Y)   do { INT32 p_=(X); (CALL_(p_)=CALL(Y))->pos=p_; }while(0)
#define CMP(X, Y)   my_timercmp(& CALL(X)->tv, <, & CALL(Y)->tv)
#define SWAP(X, Y)   do{ call_out *_tmp=CALL(X); (CALL_(X)=CALL(Y))->pos=(X); (CALL_(Y)=_tmp)->pos=(Y); } while(0)
#define PROTECT_CALL_OUTS()
#define UNPROTECT_CALL_OUTS()
#define backend_verify_call_outs(X)
#define LINK(X, c)
#define f_Backend_call_out_defined
#define f_Backend_cq__do_call_outs_defined
#define f_Backend_find_call_out_defined
#define f_Backend_remove_call_out_defined
#define f_Backend_call_out_info_defined
#define GET_ACTIVE_BOX(ME, FD)   ((ME)->fd_boxes[(FD) - (ME)->fd_boxes_start])
#define GET_BOX(ME, FD)
#define SAFE_GET_ACTIVE_BOX(ME, FD)
#define WANT_EVENT(BOX, WHAT)   ((BOX) && (BOX)->events & PIKE_CONCAT (PIKE_BIT_FD_, WHAT))
#define FOR_EACH_ACTIVE_FD_BOX(ME, BOX_VAR)
#define FOR_EACH_INACTIVE_FD_BOX(ME, BOX_VAR)
#define check_box(box, fd)   do {} while (0)
#define register_backend(X)
#define unregister_backend(X)
#define f_Backend_cq__backtick_28_29_defined
#define tObjImpl_THREAD   tObjImpl_THREAD_ID
#define f_Backend_executing_thread_defined
#define f_Backend_add_file_defined
#define f_Backend_id_defined
#define f_Backend_cq__sprintf_defined
#define internal_gc_check_Backend_defined
#define Backend_event_handler_defined
#define internal_gc_recurse_Backend_defined
#define Backend_event_handler_defined
#define internal_init_Backend_defined
#define Backend_event_handler_defined
#define internal_exit_Backend_defined
#define Backend_event_handler_defined
#define BLOCK_ALLOC_NEXT   read_data
#define DMALLOC_DESCRIBE_BLOCK(X)
#define WRAP(CB, EVENT_BIT)

Typedefs

typedef call_out_s call_out

Functions

 BLOCK_ALLOC (compat_cb_box, N/A)
Backend_struct * get_backend_for_fd (int fd)
Backend_struct * really_get_backend_for_fd (int fd)
void MY_FD_CLR (struct selectors *me, int fd, my_fd_set *s)
void MY_FD_SET (struct selectors *me, int fd, my_fd_set *s)
PMOD_EXPORT struct object * get_backend_obj (struct Backend_struct *b)
void backend_wake_up_backend (struct Backend_struct *me)
PMOD_EXPORT struct callback * backend_debug_add_backend_callback (struct Backend_struct *me, callback_func call, void *arg, callback_func free_func)
void f_Backend_call_out (INT32 args)
void f_Backend_cq__do_call_outs (INT32 args)
void f_Backend_find_call_out (INT32 args)
void f_Backend_remove_call_out (INT32 args)
array * backend_get_all_call_outs (struct Backend_struct *me)
void f_Backend_call_out_info (INT32 args)
PMOD_EXPORT void hook_fd_callback_box (struct fd_callback_box *box)
PMOD_EXPORT void unhook_fd_callback_box (struct fd_callback_box *box)
PMOD_EXPORT void set_fd_callback_events (struct fd_callback_box *box, int events)
PMOD_EXPORT void change_backend_for_box (struct fd_callback_box *box, struct Backend_struct *new)
PMOD_EXPORT void change_fd_for_box (struct fd_callback_box *box, int new_fd)
void low_backend_once (struct Backend_struct *me, struct timeval *timeout)
void f_Backend_cq__backtick_28_29 (INT32 args)
void f_Backend_executing_thread (INT32 args)
void f_Backend_add_file (INT32 args)
void f_Backend_id (INT32 args)
void f_Backend_cq__sprintf (INT32 args)
int pike_make_pipe (int *)
PMOD_EXPORT int write_to_stderr (char *a, size_t len)
PMOD_EXPORT struct object * get_backend_obj_for_fd (int fd)
PMOD_EXPORT void set_backend_for_fd (int fd, struct Backend_struct *new)
 WRAP (read, PIKE_BIT_FD_READ)
 WRAP (write, PIKE_BIT_FD_WRITE)
PMOD_EXPORT struct callback * debug_add_backend_callback (callback_func call, void *arg, callback_func free_func)
void wake_up_backend (void)
void do_call_outs (void)
void init_backend (void)

Variables

callback_list do_debug_callbacks
timeval current_time
timeval next_timeout
PMOD_EXPORT struct Backend_struct * default_backend = NULL
program * Backend_program = NULL
ptrdiff_t f_Backend_call_out_fun_num = 0
ptrdiff_t f_Backend_cq__do_call_outs_fun_num = 0
ptrdiff_t f_Backend_find_call_out_fun_num = 0
ptrdiff_t f_Backend_remove_call_out_fun_num = 0
ptrdiff_t f_Backend_call_out_info_fun_num = 0
ptrdiff_t f_Backend_cq__backtick_28_29_fun_num = 0
ptrdiff_t f_Backend_executing_thread_fun_num = 0
ptrdiff_t f_Backend_add_file_fun_num = 0
ptrdiff_t f_Backend_id_fun_num = 0
ptrdiff_t f_Backend_cq__sprintf_fun_num = 0

Define Documentation

 
#define alloc_call_out (   )     debug_malloc_pass(alloc_call_out_s())
 

#define Backend_event_handler_defined
 

#define Backend_event_handler_defined
 

#define Backend_event_handler_defined
 

#define Backend_event_handler_defined
 

#define backend_verify_call_outs (  X   ) 
 

#define BLOCK_ALLOC_NEXT   read_data
 

#define CALL (  X   )     ((struct call_out_s *)debug_malloc_pass(CALL_(X)))
 

#define CALL_ (  X   )     (me->call_buffer[(X)])
 

#define CAR (  X   )     (((X)<<1)+1)
 

#define CDR (  X   )     (((X)<<1)+2)
 

#define check_box (  box,
fd   )     do {} while (0)
 

#define CHECK_ERROR_EVENT (  EVENT,
MASK   )     CHECK_EVENT(EVENT, MASK)
 

#define CHECK_EVENT (  EVENT,
MASK   )     (GET_EVENTS(EVENT) & (MASK))
 

#define class_Backend_defined
 

#define CMP (  X,
Y   )     my_timercmp(& CALL(X)->tv, <, & CALL(Y)->tv)
 

#define DMALLOC_DESCRIBE_BLOCK (  X   ) 
 

Value:

do {                                    \
    fprintf (stderr, "  backend: %p, fd: %d, events: 0x%x\n",           \
             X->box.backend, X->box.fd, X->box.events);                 \
  } while (0)

#define EXIT_BLOCK (  X   ) 
 

Value:

do { \
  *(X->prev_arr)=X->next_arr; \
  if(X->next_arr) X->next_arr->prev_arr=X->prev_arr; \
  *(X->prev_fun)=X->next_fun; \
  if(X->next_fun) X->next_fun->prev_fun=X->prev_fun; \
  MESS_UP_BLOCK(X); \
  } while(0)

#define f_Backend_add_file_defined
 

#define f_Backend_call_out_defined
 

#define f_Backend_call_out_info_defined
 

#define f_Backend_cq__backtick_28_29_defined
 

#define f_Backend_cq__do_call_outs_defined
 

#define f_Backend_cq__sprintf_defined
 

#define f_Backend_executing_thread_defined
 

#define f_Backend_find_call_out_defined
 

#define f_Backend_id_defined
 

#define f_Backend_remove_call_out_defined
 

#define FOR_EACH_ACTIVE_FD_BOX (  ME,
BOX_VAR   ) 
 

Value:

struct Backend_struct *me_ = (ME);                                      \
   struct fd_callback_box *BOX_VAR, **boxes_ = me_->fd_boxes;           \
   int b_, max_ = me_->fd_boxes_size;                                   \
   for (b_ = 0; b_ < max_; b_++)                                        \
     if ((BOX_VAR = boxes_[b_]))

#define FOR_EACH_INACTIVE_FD_BOX (  ME,
BOX_VAR   ) 
 

Value:

struct Backend_struct *me_ = (ME);                                      \
   struct fd_callback_box *BOX_VAR, **boxes_ = me_->inactive_boxes;     \
   int b_ = 0, max_ = me_->inactive_boxes_size;                         \
   for (b_ = 0; b_ < max_; b_++)                                        \
     if ((BOX_VAR = boxes_[b_]) &&                                      \
         /* Avoid free list pointers. */                                \
         ((struct fd_callback_box **) BOX_VAR < boxes_ ||               \
          (struct fd_callback_box **) BOX_VAR >= boxes_+max_))

#define GET_ACTIVE_BOX (  ME,
FD   )     ((ME)->fd_boxes[(FD) - (ME)->fd_boxes_start])
 

#define GET_BACKEND_STORAGE   ((struct Backend_struct *)(o->storage+Backend_storage_offset)
 

#define GET_BOX (  ME,
FD   ) 
 

Value:

((FD) < 0 ?                                                             \
    (ME)->inactive_boxes[~(FD)] :                                       \
    (ME)->fd_boxes[(FD) - (ME)->fd_boxes_start])

#define IF_CO (  X   ) 
 

#define IF_PD (  x   ) 
 

#define internal_exit_Backend_defined
 

#define internal_gc_check_Backend_defined
 

#define internal_gc_recurse_Backend_defined
 

#define internal_init_Backend_defined
 

#define LINK (  X,
c   ) 
 

Value:

hval%=me->hash_size;                                    \
             if((c->PIKE_CONCAT(next_,X)=me->call_hash[hval].X))        \
               c->PIKE_CONCAT(next_,X)->PIKE_CONCAT(prev_,X)=           \
                 &c->PIKE_CONCAT(next_,X);                              \
             c->PIKE_CONCAT(prev_,X)=&me->call_hash[hval].X;            \
             me->call_hash[hval].X=c;

#define MESS_UP_BLOCK (  X   ) 
 

#define MOVECALL (  X,
Y   )     do { INT32 p_=(X); (CALL_(p_)=CALL(Y))->pos=p_; }while(0)
 

#define MY_FD_CLR_RDBAND (  SET,
FD   ) 
 

#define MY_FD_CLR_WRBAND (  SET,
FD   ) 
 

#define MY_POLL (  SET,
TIMEOUT   ) 
 

Value:

fd_select((SET).max_fd + 1, &(SET).rset, &(SET).wset, &(SET).eset,      \
            (TIMEOUT).tv_sec >= 100000000 ? NULL : &(TIMEOUT))

#define MY_POLLERR   POLLERR
 

#define MY_POLLEXCEPT   &me->set.except
 

#define MY_POLLHUP   POLLHUP
 

#define MY_POLLIN   &me->set.read
 

#define MY_POLLOUT   &me->set.write
 

#define MY_POLLRDBAND   &me->set.except
 

#define MY_POLLWRBAND   &me->set.write
 

#define MY_POLLWREXCEPT   &me->set.write
 

#define OBJ2_BACKEND (  o   )     ((struct Backend_struct *)(o->storage+Backend_storage_offset))
 

#define PARENT (  X   )     (((X)-1)>>1)
 

#define POLL_SET_SIZE   32
 

#define PRECOMPILE_API_VERSION   2
 

 
#define PROTECT_CALL_OUTS (   ) 
 

#define RDBAND_IS_SPECIAL
 

#define really_free_call_out (  X   )     really_free_call_out_s(debug_malloc_pass(X))
 

#define register_backend (  X   ) 
 

#define SAFE_GET_ACTIVE_BOX (  ME,
FD   ) 
 

Value:

((FD) >= (ME)->fd_boxes_start &&                                        \
    (FD) < (ME)->fd_boxes_start + (ME)->fd_boxes_size ?                 \
    GET_ACTIVE_BOX (ME, FD) : NULL)

#define SWAP (  X,
Y   )     do{ call_out *_tmp=CALL(X); (CALL_(X)=CALL(Y))->pos=(X); (CALL_(Y)=_tmp)->pos=(Y); } while(0)
 

#define THIS   ((struct Backend_struct *)(Pike_interpreter.frame_pointer->current_storage))
 

#define THIS_BACKEND   ((struct Backend_struct *)(Pike_interpreter.frame_pointer->current_storage))
 

#define THR_NO   getpid()
 

#define TIMEOUT_IS_TIMEVAL
 

#define tObjImpl_THREAD   tObjImpl_THREAD_ID
 

 
#define UNPROTECT_CALL_OUTS (   ) 
 

#define unregister_backend (  X   ) 
 

#define var_active_set_Backend_defined
 

#define var_backend_callbacks_Backend_defined
 

#define var_backend_obj_Backend_defined
 

#define var_call_buffer_Backend_defined
 

#define var_call_buffer_size_Backend_defined
 

#define var_call_hash_Backend_defined
 

#define var_exec_thread_Backend_defined_2
 

#define var_fd_boxes_Backend_defined
 

#define var_fd_boxes_size_Backend_defined
 

#define var_free_inactive_box_Backend_defined
 

#define var_hash_order_Backend_defined
 

#define var_hash_size_Backend_defined
 

#define var_id_Backend_defined
 

#define var_inactive_boxes_size_Backend_defined
 

#define var_num_pending_calls_Backend_defined
 

#define var_set_Backend_defined_2
 

#define var_wakeup_cb_box_Backend_defined
 

#define var_wakeup_pipe_send_fd_Backend_defined
 

#define WANT_EVENT (  BOX,
WHAT   )     ((BOX) && (BOX)->events & PIKE_CONCAT (PIKE_BIT_FD_, WHAT))
 

#define WRAP (  CB,
EVENT_BIT   ) 
 

Typedef Documentation

typedef struct call_out_s call_out
 

Function Documentation

PMOD_EXPORT struct callback* backend_debug_add_backend_callback (  struct Backend_struct *  me,
callback_func  call,
void *  arg,
callback_func  free_func
) 
 

struct array* backend_get_all_call_outs (  struct Backend_struct *  me  ) 
 

void backend_wake_up_backend (  struct Backend_struct *  me  ) 
 

BLOCK_ALLOC (  compat_cb_box  ,
N/  A
) 
 

PMOD_EXPORT void change_backend_for_box (  struct fd_callback_box *  box,
struct Backend_struct *  new
) 
 

PMOD_EXPORT void change_fd_for_box (  struct fd_callback_box *  box,
int  new_fd
) 
 

PMOD_EXPORT struct callback* debug_add_backend_callback (  callback_func  call,
void *  arg,
callback_func  free_func
) 
 

void do_call_outs (  void   ) 
 

void f_Backend_add_file (  INT32  args  ) 
 

void f_Backend_call_out (  INT32  args  ) 
 

void f_Backend_call_out_info (  INT32  args  ) 
 

void f_Backend_cq__backtick_28_29 (  INT32  args  ) 
 

void f_Backend_cq__do_call_outs (  INT32  args  ) 
 

void f_Backend_cq__sprintf (  INT32  args  ) 
 

void f_Backend_executing_thread (  INT32  args  ) 
 

void f_Backend_find_call_out (  INT32  args  ) 
 

void f_Backend_id (  INT32  args  ) 
 

void f_Backend_remove_call_out (  INT32  args  ) 
 

struct Backend_struct* get_backend_for_fd (  int  fd  ) 
 

PMOD_EXPORT struct object* get_backend_obj (  struct Backend_struct *  b  ) 
 

PMOD_EXPORT struct object* get_backend_obj_for_fd (  int  fd  ) 
 

PMOD_EXPORT void hook_fd_callback_box (  struct fd_callback_box *  box  ) 
 

void init_backend (  void   ) 
 

void low_backend_once (  struct Backend_struct *  me,
struct timeval *  timeout
) 
 

void MY_FD_CLR (  struct selectors *  me,
int  fd,
my_fd_set *  s
) 
 

void MY_FD_SET (  struct selectors *  me,
int  fd,
my_fd_set *  s
) 
 

int pike_make_pipe (  int *   ) 
 

struct Backend_struct* really_get_backend_for_fd (  int  fd  ) 
 

PMOD_EXPORT void set_backend_for_fd (  int  fd,
struct Backend_struct *  new
) 
 

PMOD_EXPORT void set_fd_callback_events (  struct fd_callback_box *  box,
int  events
) 
 

PMOD_EXPORT void unhook_fd_callback_box (  struct fd_callback_box *  box  ) 
 

void wake_up_backend (  void   ) 
 

WRAP (  write  ,
PIKE_BIT_FD_WRITE 
) 
 

WRAP (  read  ,
PIKE_BIT_FD_READ 
) 
 

PMOD_EXPORT int write_to_stderr (  char *  a,
size_t  len
) 
 

Variable Documentation

struct program* Backend_program = NULL
 

struct timeval current_time
 

PMOD_EXPORT struct Backend_struct* default_backend = NULL
 

struct callback_list do_debug_callbacks
 

ptrdiff_t f_Backend_add_file_fun_num = 0
 

ptrdiff_t f_Backend_call_out_fun_num = 0
 

ptrdiff_t f_Backend_call_out_info_fun_num = 0
 

ptrdiff_t f_Backend_cq__backtick_28_29_fun_num = 0
 

ptrdiff_t f_Backend_cq__do_call_outs_fun_num = 0
 

ptrdiff_t f_Backend_cq__sprintf_fun_num = 0
 

ptrdiff_t f_Backend_executing_thread_fun_num = 0
 

ptrdiff_t f_Backend_find_call_out_fun_num = 0
 

ptrdiff_t f_Backend_id_fun_num = 0
 

ptrdiff_t f_Backend_remove_call_out_fun_num = 0
 

struct timeval next_timeout
 

Generated on Fri Jul 22 23:44:28 2005 for Pike by  doxygen 1.3.9.1