int16_t push_stack(void)
/*
This procedure creates new level in stack and copies to it previous one.
*/
{
/*
SPQ.stack-=sizeof(struct state_stack_elem);
*/
SPQ.stack--;
SPQ.st.stack_level++;
copy_prev_level();
check_free_mem();
return(OK);
}
/*------------------------------------------------------------------*/
int16_t do_fragm(void)
/*
This procedure sets up fragm_descr or head of line.
*/
{
SPQ.st.cur_segm->string_lth+=DELTA;
SPQ.free_alloc_mem+=DELTA;
check_free_mem();
if ( (uint32_t)(SPQ.buff_ptr - (uchar*)SPQ.text_buff) > (uint32_t)(SPQ.buff_l - sizeof(struct fragm_disk)) )
return(NO);
SPQ.fragm_disk_ptr=(struct fragm_disk *)SPQ.buff_ptr;
SPQ.cur_fragm=SPQ.fragm_disk_ptr->fragm_numb;
SPQ.ptr_next_segm=(struct segm *)SPQ.free_alloc_mem;
SPQ.str_ptr=SPQ.ptr_next_segm->string;
SPQ.st.cur_segm->next_in_fragm=SPQ.ptr_next_segm;
SPQ.free_alloc_mem=(char *)(SPQ.ptr_next_segm+1);
SPQ.ptr_next_segm->prev_in_fragm=
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm;
if ((SPQ.sheet_flag[SPQ.cur_sheet] == EXIST) &&
SPQ.fragm_flag[SPQ.cur_fragm]==NONEXIST);
{
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].
first_segm=SPQ.ptr_next_segm;
SPQ.fragm_flag[SPQ.cur_fragm]=EXIST;
SPQ.ptr_next_segm->prev_in_fragm=NULL;
}
SPQ.ptr_next_segm->busy_lth=0;
SPQ.ptr_next_segm->string_lth=0;
SPQ.ptr_next_segm->next_in_fragm=NULL;
SPQ.ptr_next_segm->next_in_sheet=NULL;
SPQ.ptr_next_segm->prev_in_sheet=SPQ.st.cur_segm;
if (SPQ.st.cur_segm != NULL)
SPQ.st.cur_segm->next_in_sheet=SPQ.ptr_next_segm;
SPQ.st.cur_segm=SPQ.ptr_next_segm;
SPQ.st.cur_segm->type=1;
SPQ.st.cur_segm->q_vis_symb=0;
SPQ.st.cur_segm->q_v_s_l=0;
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm=SPQ.st.cur_segm;
mvbuf(sizeof(struct fragm_disk));
return(YES);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
//This procedure creats new stack.
void create_new_stack(void)
{
int16_t i;
char * symb;
struct segm * segm;
symb=SPQ.ns_symb;
check_free_mem();
segm = SPQ.st.cur_segm;
SPQ.stack = (struct state_stack_elem *)(SPQ.end_alloc_mem - sizeof(struct state_stack_elem));
stack_to_null();
SPQ.st.stack_level = 0;
SPQ.st.cur_segm = SPQ.tab_ptr->tab_sheet_descr[SPQ.cur_sheet].first_segm;
SPQ.ns_symb = SPQ.st.cur_segm->string;
while (*SPQ.ns_symb != SS_SHEET_DESCR)
{
if(SPQ.ns_symb == NULL)
{
#ifdef SYSPR_ERROR
PRINTF("Wrong file...\n");
#endif
ErrorExit(RLING_ERROR_WRONG_ED_FILE);
}
SPQ.ns_symb = next_symb(NO,YES,NO,SPQ.ns_segm,SPQ.ns_symb);
}
SPQ.h_fragm_disk_descr_ptr = (struct fragm_disk_descr *)(SPQ.ns_symb + sizeof(struct sheet_disk_descr));
for (i=0; i < SPQ.cur_fragm; i++)
SPQ.h_fragm_disk_descr_ptr++;
SPQ.stack->kegl = SPQ.h_fragm_disk_descr_ptr->kegl;
SPQ.stack->font = SPQ.h_fragm_disk_descr_ptr->font;
SPQ.stack->language = SPQ.h_fragm_disk_descr_ptr->language;//03-29-94 02:54pm,Pit
SPQ.stack->font_type = SPQ.h_fragm_disk_descr_ptr->font_type;
SPQ.ns_symb = symb;
SPQ.st.cur_segm = segm;
}
int16_t create_segm(struct segm *prev_adr,uint16_t segm_size,uint16_t type)
/*
This procedure allocates new segment and connects it with old ones.
*/
{
struct segm *sNew;
struct segm *nf;
struct segm *ns;
check_free_mem();
if (prev_adr == NULL)
return(NO);
sNew=(struct segm *)SPQ.free_alloc_mem;
nf=prev_adr->next_in_fragm;
ns=prev_adr->next_in_sheet;
prev_adr->next_in_fragm=sNew;
prev_adr->next_in_sheet=sNew;
if (nf != NULL)
{
nf->prev_in_fragm=sNew;
nf->prev_in_sheet=sNew;
}
else
if (ns != NULL)
ns->prev_in_sheet=sNew;
if (SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm == prev_adr)
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm=sNew;
sNew->next_in_sheet=ns;
sNew->next_in_fragm=nf;
sNew->prev_in_fragm=prev_adr;
sNew->prev_in_sheet=prev_adr;
sNew->string_lth=segm_size;
sNew->busy_lth=0;
sNew->type=(char)type;
SPQ.new_segm=sNew;
SPQ.free_alloc_mem += sizeof(struct segm)+segm_size;
return(YES);
}
int16_t set_descr(char c)
/*
This procedure sets up sheet_descr or head of line.
c=SHEET means sheet_descriptor; c=LINE means line_descriptor.
*/
{
int16_t i /*,k*/;
struct segm *segm_ptr;
/* char * return_str_ptr;*/
check_free_mem();
if (c == SHEET)
{ /* sheet */
SPQ.sheet_disk_descr_ptr=(struct sheet_disk_descr *)SPQ.buff_ptr;
if ((uint32_t)(SPQ.buff_ptr - (uchar*)SPQ.text_buff) > (uint32_t)(SPQ.buff_l - sizeof(struct sheet_disk_descr)))
return(NO);
SPQ.qt_fm=SPQ.sheet_disk_descr_ptr->quant_fragm;
if(SPQ.qt_fm >= MAX_FRAGM ) return TOO_MANY_FRAGMS;
if (SPQ.buff_ptr-(uchar*)SPQ.text_buff >=
SPQ.buff_l-SPQ.sheet_disk_descr_ptr->descr_lth)
/* not enough room in buffer for all fragm descr */
return(NO);
SPQ.cur_sheet_number=SPQ.sheet_disk_descr_ptr->sheet_numb;
SPQ.cur_sheet=0;
SPQ.sheet_flag[SPQ.cur_sheet]=EXIST;
SPQ.tab_ptr->tab_sheet_descr[SPQ.cur_sheet].el_type=2;
SPQ.tab_ptr->tab_sheet_descr[SPQ.cur_sheet].lth=
SPQ.sheet_disk_descr_ptr->descr_lth;
SPQ.tab_ptr->tab_sheet_descr[SPQ.cur_sheet].first_segm=SPQ.st.cur_segm;
for (i=0; i < SPQ.qt_fm; i++)
fill_fragm(i); /* fills descriptors of i-th fragment */
mvbuf(SPQ.sheet_disk_descr_ptr->descr_lth);
}
else
{ /* line */
SPQ.st.cur_segm->string_lth+=DELTA;
SPQ.free_alloc_mem+=DELTA;
check_free_mem();
if ( (uint32_t)(SPQ.buff_ptr - (uchar*)SPQ.text_buff) > (uint32_t)(SPQ.buff_l - sizeof(struct line_beg)) )
return(NO);
SPQ.ptr_next_segm=(struct segm *)SPQ.free_alloc_mem;
SPQ.str_ptr=SPQ.ptr_next_segm->string;
SPQ.free_alloc_mem=( char *)(SPQ.ptr_next_segm+1);
segm_ptr=(struct segm *) SPQ.tab_ptr->
tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm;
segm_ptr->next_in_fragm=SPQ.ptr_next_segm;
SPQ.ptr_next_segm->prev_in_fragm = (struct segm *)
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm;
SPQ.ptr_next_segm->prev_in_sheet=SPQ.st.cur_segm;
SPQ.st.cur_segm->next_in_sheet=SPQ.ptr_next_segm;
SPQ.ptr_next_segm->prev_in_sheet=SPQ.st.cur_segm;
SPQ.st.cur_segm=SPQ.ptr_next_segm;
SPQ.st.cur_segm->next_in_sheet=NULL;
SPQ.st.cur_segm->next_in_fragm=NULL;
SPQ.st.cur_segm->type=1;
SPQ.st.cur_segm->string_lth=0;
SPQ.st.cur_segm->busy_lth=0;
SPQ.st.cur_segm->q_vis_symb=0;
SPQ.st.cur_segm->q_v_s_l=0;
SPQ.str_ptr=SPQ.ptr_next_segm->string;
SPQ.tab_ptr->tab_fragm[SPQ.cur_sheet][SPQ.cur_fragm].last_segm =
SPQ.ptr_next_segm;
mvbuf(sizeof(struct line_beg));
}
return(YES);
}
void puff_last_segm(void)
{
SPQ.st.cur_segm->string_lth+=DELTA;
SPQ.free_alloc_mem+=DELTA;
check_free_mem();
}
void syscall_handler()
{
static int free_vm_proc;
int syscall_num;
unsigned int mem_size;
struct t_process_context* current_process_context;
struct t_processor_reg processor_reg;
int* params;
char data;
unsigned int on_exit_action;
SAVE_PROCESSOR_REG
//call can come from kernel mode (sleep)
SWITCH_DS_TO_KERNEL_MODE
on_exit_action=0;
current_process_context=system.process_info->current_process->val;
t_console_desc *console_desc=current_process_context->console_desc;
syscall_num=processor_reg.eax;
params=processor_reg.ecx;
if (syscall_num==1)
{
params[0]=_fork(processor_reg);
}
else if (syscall_num==2)
{
params[1]=_malloc(params[0]);
}
else if (syscall_num==3)
{
_free(params[0]);
}
else if (syscall_num==150)
{
params[1]=_bigMalloc(params[0]);
}
else if (syscall_num==151)
{
_bigFree(params[0]);
}
else if (syscall_num==4)
{
_write_char(console_desc,params[0]);
}
else if (syscall_num==5)
{
data=_read_char(console_desc);
*((char*)params[0])=data;
if (data==NULL)
{
on_exit_action=1;
}
}
else if (syscall_num==6)
{
_echo_char(console_desc,params[0]);
}
else if (syscall_num==7)
{
_enable_cursor(console_desc);
}
else if (syscall_num==8)
{
_disable_cursor(console_desc);
}
else if (syscall_num==9)
{
_update_cursor(console_desc);
}
else if (syscall_num==10)
{
_delete_char(console_desc);
}
else if (syscall_num==11)
{
_pause();
on_exit_action=1;
}
else if (syscall_num==12)
{
_awake(params[0]);
}
else if (syscall_num==13)
{
_exit(params[0]);
on_exit_action=2;
}
else if (syscall_num==14)
{
params[2]=_exec(params[0],params[1]);
}
else if (syscall_num==15)
{
_sleep_time(params[0]);
on_exit_action=1;
}
else if (syscall_num==18)
{
params[2]=_open(system.root_fs,(char*) params[0],params[1]);
on_exit_action=1;
}
else if (syscall_num==19)
{
params[1]=_close(system.root_fs,params[0]);
on_exit_action=1;
}
else if (syscall_num==20)
{
params[3]=_read(system.root_fs,params[0],params[1],params[2]);
on_exit_action=1;
}
else if (syscall_num==21)
{
params[3]=_write(system.root_fs,(void*)params[0],params[1],params[2]);
on_exit_action=1;
}
else if (syscall_num==22)
{
params[1]=_rm(system.root_fs,(char*)params[0]);
on_exit_action=1;
}
else if (syscall_num==23)
{
params[1]=_mkdir(system.root_fs,params[0]);
on_exit_action=1;
}
//syscall 24 and 25 test only
else if (syscall_num==24)
{
t_io_request* io_request;
io_request=kmalloc(sizeof(t_io_request));
io_request->device_desc=system.device_desc;
io_request->sector_count=params[0];
io_request->lba=params[1];
io_request->io_buffer=params[2];
io_request->process_context=current_process_context;
_read_28_ata(io_request);
kfree(io_request);
}
else if (syscall_num==25)
{
t_io_request* io_request;
io_request=kmalloc(sizeof(t_io_request));
io_request->device_desc=system.device_desc;
io_request->sector_count=params[0];
io_request->lba=params[1];
io_request->io_buffer=params[2];
io_request->process_context=current_process_context;
_write_28_ata(io_request);
kfree(io_request);
}
else if (syscall_num==26)
{
params[1]=_chdir(system.root_fs,(char*) params[0]);
on_exit_action=1;
}
else if (syscall_num==27)
{
params[2]=_stat(system.root_fs,(char*) params[0],params[1]);
}
else if (syscall_num==28)
{
params[1]=_open_socket(system.network_desc->socket_desc,params[0]);
}
else if (syscall_num==29)
{
params[3]=_bind(system.network_desc->socket_desc,params[0],params[1],params[2]);
}
else if (syscall_num==30)
{
params[5]=_recvfrom(system.network_desc->socket_desc,params[0],params[1],params[2],params[3],params[4]);
}
else if (syscall_num==31)
{
params[5]=_sendto(system.network_desc->socket_desc,params[0],params[1],params[2],params[3],params[4]);
}
else if (syscall_num==32)
{
params[1]=_close_socket(system.network_desc->socket_desc,params[0]);
}
else if (syscall_num==101)
{
on_exit_action=1;
}
else if (syscall_num==102)
{
_flush_ata_pending_request();
}
//DEBUG WRAPPER
else if (syscall_num==103)
{
check_free_mem();
}
else if (syscall_num==104)
{
debug_network(params[0],params[1]);
}
else
{
panic();
}
// EXIT_INT_HANDLER(on_exit_action,processor_reg)
static struct t_process_context _current_process_context;
static struct t_process_context _old_process_context;
static struct t_process_context _new_process_context;
static struct t_processor_reg _processor_reg;
static unsigned int _action;
// static short _ds;
CLI
// _ds=ds;
_action=on_exit_action;
_current_process_context=*(struct t_process_context*)system.process_info->current_process->val;
_old_process_context=_current_process_context;
_processor_reg=processor_reg;
if (_action>0)
{
schedule(&_current_process_context,&_processor_reg);
_new_process_context=*(struct t_process_context*)(system.process_info->current_process->val);
_processor_reg=_new_process_context.processor_reg;
SWITCH_PAGE_DIR(FROM_VIRT_TO_PHY(((unsigned int) _new_process_context.page_dir)))
DO_STACK_FRAME(_processor_reg.esp-8);
// unsigned int* xxx;
// unsigned int* yyy;
// unsigned int* zzz;
// xxx=FROM_PHY_TO_VIRT(((unsigned int*)_new_process_context.page_dir)[0]) & 0xFFFFF000;
// zzz=FROM_PHY_TO_VIRT(xxx[256]);
if (_action==2)
{
DO_STACK_FRAME(_processor_reg.esp-8);
// free_vm_process(_old_process_context.page_dir,INIT_VM_USERSPACE);
free_vm_process(&_old_process_context);
// if (_old_process_context.phy_add_space!=NULL)
// {
// buddy_free_page(&system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_add_space));
// buddy_free_page(system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_user_stack));
// }
buddy_free_page(system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_kernel_stack));
}
RESTORE_PROCESSOR_REG
EXIT_SYSCALL_HANDLER
}
