void _fini() {
pthread_mutex_destroy(&glob_mutex);
size_t i;
for (i = 0; i < HASHSIZE; i++)
destroy_thread(threads[i]);
bdestroy_list(glob_list);
}
void asynnet_delete(asynnet_t asynet)
{
asynnet_stop(asynet);
int32_t i = 0;
for( ;i < asynet->poller_count; ++i){
destroy_thread(&asynet->netpollers[i].poller_thd);
destroy_service(&asynet->netpollers[i].netpoller);
}
free(asynet);
}
/* Clean exited process' pmap and calling thread */
static inline void destroy_all(struct thread *old)
{
kprintf("Thread Exiting");
if(old->states & PROCESS_EXITING)
{
pmap_destroy(old->proc->map->pmap);
vm_map_destroy(old->proc->map);
}
remove_thread(old);
destroy_thread(old);
}
static void *routine(void *arg) {
struct thread_arg *_arg = (struct thread_arg *)arg;
thread_t t = _arg->_thread;
void *custom_arg = _arg->custom_arg;
thread_routine custom_routine = _arg->custom_routine;
custom_routine(custom_arg);
destroy_thread(&t);
free(_arg);
return 0;
}
void close_log_system()
{
COMPARE_AND_SWAP(&(g_log_system->is_close),0,1);
//停止写日志线程,并等待结束
//g_log_system->is_close = 1;
thread_join(g_log_system->worker_thread);
mutex_lock(g_log_system->mtx);
while(!link_list_is_empty(g_log_system->log_files))
{
log_t l = LINK_LIST_POP(log_t,g_log_system->log_files);
destroy_log(&l);
}
mutex_unlock(g_log_system->mtx);
mutex_destroy(&g_log_system->mtx);
destroy_link_list(&g_log_system->log_files);
destroy_thread(&g_log_system->worker_thread);
//DESTROY(&(g_log_system->_wpacket_allocator));
free(g_log_system);
g_log_system = 0;
}
CXSPThread::~CXSPThread()
{
destroy_thread(&m_thread);
sem_destroy(&this->m_sem);
}
void destroy_threads_for_process(struct Process *process) {
while(process->threads)
destroy_thread(process->threads);
}
int AccirrFinalize() {
destroy_thread(master_thread);
return 0;
}
/*
ok, this is pman init stage two. we will execute this code, and then jump to the process
manager main processing loop.
What we will do here, is setup the page pool. And initialize System services, along with structures.
Notice, we are now task 0 on the system.
*/
void pman_init_stage2()
{
UINT32 linear, physical;
struct pm_thread *pmthr = NULL;
struct pm_task *pmtsk = NULL;
int i = 0;
int init_size = 0;
/* get rid of the init stuff */
destroy_thread(INIT_THREAD_NUM);
destroy_task(INIT_TASK_NUM);
/*
Open used ports
*/
for(i = 0; i <= 12; i++)
{
open_port(i, 3, PRIV_LEVEL_ONLY);
}
/*
Init stage 1 has placed bootinfo at PMAN_MULTIBOOTINFO_PHYS
before initializing the pool we need to know memory size
and that information is there. So lets map it on our page table.
*/
linear = PMAN_MULTIBOOT_LINEAR + SARTORIS_PROCBASE_LINEAR;
physical = PMAN_MULTIBOOT_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MULTIBOOT_PAGES, PGATT_WRITE_ENA, 2);
/* Reallocate init image */
init_size = init_reloc();
pman_print_set_color(0x7);
pman_print("Mapping Malloc %i pages", PMAN_MALLOC_PAGES);
/* Pagein remaining pages for kmalloc */
linear = PMAN_MALLOC_LINEAR + SARTORIS_PROCBASE_LINEAR; // place after multiboot (this will invalidate the map src/dest linear address,
// we cannot use that area anymore, but it's ok, we used it for init copy only.)
physical = PMAN_MALLOC_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MALLOC_PAGES, PGATT_WRITE_ENA, 2);
pman_print("Initializing tasks/threads.");
/* Show MMAP information */
if(((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->flags & MB_INFO_MMAP && ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length > 0)
{
//Calculate multiboot mmap linear address.
//Sartoris loader left MMAP just after multiboot info structure.
((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr = PMAN_MULTIBOOT_LINEAR + sizeof(struct multiboot_info);
pman_print("Multiboot MMAP Size: %i ", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length);
pman_print("Multiboot mmap linear address: %x", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr);
struct mmap_entry *entry = NULL;
entry = (struct mmap_entry *)((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr;
int kk = 0, mmlen = ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length / entry->size;
for(kk = 0; kk < mmlen; kk++)
{
pman_print("Multiboot entry size: %i start: %x end: %x type: %i", entry->size, (UINT32)entry->start, (UINT32)entry->end, entry->type);
entry = (struct mmap_entry *)((UINT32)entry + entry->size);
}
}
else
{
pman_print("No MMAP present.");
}
/* Initialize vmm subsystem */
vmm_init((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR, PMAN_INIT_RELOC_PHYS, PMAN_INIT_RELOC_PHYS + init_size);
tsk_init();
thr_init();
/* Mark SCHED_THR as taken! */
pmtsk = tsk_create(PMAN_TASK);
pmtsk->state = TSK_NORMAL;
pmthr = thr_create(SCHED_THR, pmtsk);
pmthr->state = THR_INTHNDL; // ehm... well... it IS an interrupt handler :D
pmthr->task_id = PMAN_TASK;
pmthr->state = THR_INTHNDL;
pman_print("Initializing allocator and interrupts.");
/* Initialize kernel memory allocator */
kmem_init(PMAN_MALLOC_LINEAR, PMAN_MALLOC_PAGES);
/* get our own interrupt handlers, override microkernel defaults */
int_init();
/* Initialize Scheduler subsystem */
sch_init();
pman_print("InitFS2 Service loading...");
/* Load System Services and init Loader */
loader_init((ADDR)PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS));
//pman_print_clr(7);
pman_print("Loading finished, return INIT image memory to POOL...");
/* Put now unused Init-Fs pages onto vmm managed address space again. */
vmm_add_mem((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS)
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS + init_size));
pman_print("Signals Initialization...");
/* Initialize global signals container */
init_signals();
pman_print("Commands Initialization...");
/* Initialize Commands subsystem. */
cmd_init();
pman_print_set_color(12);
pman_print("PMAN: Initialization step 2 completed.");
/* Create Scheduler int handler */
if(create_int_handler(32, SCHED_THR, FALSE, 0) < 0)
pman_print_and_stop("Could not create Scheduler thread.");
/* This is it, we are finished! */
process_manager();
}
int main(int argc, char **argv) {
/* Slave threads */
sgcomm_thread *st_rd; // Reader
sgcomm_thread *st_tx; // Transmitter
shared_buffer *sbtx; // shared buffer for read+transmit
/* Reader message parameters */
char *fmtstr = "/mnt/disks/%u/%u/data/%s";
char *pattern_read = "input.vdif";
char *host = "localhost";
uint16_t port = 61234;
int n_mod = 4;
int mod_list[4] = { 1, 2, 3, 4};
int n_disk = 8;
int disk_list_read[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
int disk_list_write[8] = { 1, 0, 2, 3, 4, 5, 6, 7 };
/* Transmitter message parameters */
if (argc > 1)
pattern_read = argv[1];
if (argc > 2)
fmtstr = argv[2];
if (argc > 3)
host = argv[3];
if (argc > 4)
port = atoi(argv[4]);
log_message(RL_NOTICE,"%s:Using input file '%s' matching pattern '%s'",__FUNCTION__,pattern_read,fmtstr);
log_message(RL_NOTICE,"%s:Transmitting to %s:%u",__FUNCTION__,host,port);
/* This thread */
sgcomm_thread *st = &st_main;
ctrl_state state;
log_message(RL_DEBUG,"%s:Creating shared buffer",__FUNCTION__);
/* Initialize shared data buffer */
sbtx = create_shared_buffer(SHARED_BUFFER_SIZE_TX);
if (sbtx == NULL)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot create shared buffer for read+transmit",__FUNCTION__,__LINE__);
log_message(RL_DEBUG,"%s:Creating slave threads",__FUNCTION__);
/* Create thread instances */
st_rd = create_thread(TT_READER);
if (st_rd == NULL)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot create reader thread",__FUNCTION__,__LINE__);
st_tx = create_thread(TT_TRANSMITTER);
if (st_tx == NULL)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot create transmitter thread",__FUNCTION__,__LINE__);
log_message(RL_DEBUG,"%s:Initializing thread messages",__FUNCTION__);
/* Initialize thread messages */
init_reader_msg((reader_msg *)st_rd->type_msg, sbtx, pattern_read, fmtstr,
mod_list, n_mod, disk_list_read, n_disk);
init_transmitter_msg((transmitter_msg *)st_tx->type_msg, sbtx,
host, port);
/* Start transmitter thread */
if (start_thread(st_tx) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot start transmitter thread",__FUNCTION__,__LINE__);
/* Pause, then see if transmitter has error, if so, abort */
usleep(MAIN_WAIT_PERIOD_US);
if ((get_thread_state(st_tx,&state) == 0) && (state >= CS_STOP)) {
set_thread_state(st,CS_ERROR,"%s(%d):Transmitter terminated prematurely, aborting start.",__FUNCTION__,__LINE__);
} else {
if (start_thread(st_rd) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot start reader thread",__FUNCTION__,__LINE__);
}
//~ log_message(RL_DEBUG,"%s:Entering main thread run loop",__FUNCTION__);
if ((get_thread_state(st,&state) == 0) && !(state >= CS_STOP))
set_thread_state(st,CS_RUN,"%s:Thread running",__FUNCTION__);
while ((get_thread_state(st,&state) == 0) && !(state >= CS_STOP)) {
// TODO: do something
usleep(MAIN_WAIT_PERIOD_US);
/* If any thread has a problem, stop all of them */
if ( ((get_thread_state(st_rd,&state) == 0) && (state >= CS_ERROR)) ||
((get_thread_state(st_tx,&state) == 0) && (state >= CS_ERROR)) ) {
// TODO: Some cleanup?
break;
}
/* If all threads are stopped, break */
if ( ((get_thread_state(st_rd,&state) == 0) && (state >= CS_STOP)) &&
((get_thread_state(st_tx,&state) == 0) && (state >= CS_STOP)) ) {
log_message(RL_NOTICE,"%s:All threads stopped of their own volition",__FUNCTION__);
break;
}
/* If reader thread is done, stop transmitter */
if ( (get_thread_state(st_rd,&state) == 0) && (state >= CS_STOP) &&
(get_thread_state(st_tx,&state) == 0) && (state < CS_STOP)) {
log_message(RL_NOTICE,"%s:Reader is done, stop transmitter",__FUNCTION__);
/* Two wait periods should be enough - reader is the only
* other thread that can cause transmitter to wait on a
* resource, and then it will only be a single wait. */
usleep(MAIN_WAIT_PERIOD_US);
usleep(MAIN_WAIT_PERIOD_US);
if (stop_thread(st_tx) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot stop transmitter thread",__FUNCTION__,__LINE__);
}
}
log_message(RL_DEBUG,"%s:Stopping slave threads",__FUNCTION__);
/* Stop slave threads on tx side */
if ( (get_thread_state(st_rd,&state) == 0) && (state < CS_STOP) && (state > CS_INIT) && stop_thread(st_rd) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot stop reader thread",__FUNCTION__,__LINE__);
log_message(RL_DEBUGVVV,"%s:Reader thread stopped",__FUNCTION__);
if ( (get_thread_state(st_tx,&state) == 0) && (state < CS_STOP) && (state > CS_INIT) && stop_thread(st_tx) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot stop transmitter thread",__FUNCTION__,__LINE__);
log_message(RL_DEBUGVVV,"%s:Transmitter thread stopped",__FUNCTION__);
log_message(RL_DEBUG,"%s:Destroying shared buffer",__FUNCTION__);
/* Destroy shared data buffer */
if (destroy_shared_buffer(&sbtx) != 0)
set_thread_state(st,CS_ERROR,"%s(%d):Cannot destroy shared buffer for read+transmit",__FUNCTION__,__LINE__);
log_message(RL_DEBUG,"%s:Destroying slave threads",__FUNCTION__);
/* Destroy threads */
destroy_thread(&st_rd);
destroy_thread(&st_tx);
log_message(RL_DEBUG,"%s:Everything is done, goodbye",__FUNCTION__);
/* That's all folks! */
// TODO: Report that we're done
return EXIT_SUCCESS;
}
/*
Returns
-1 if failed
0 if ok
>0 if threads where left on KILLING state because of page fault (i.e swap read pending)
*/
int thr_destroy_thread(UINT16 thread_id)
{
struct pm_thread * thr = thr_get(thread_id);
int ret = 0;
/*
NOTE: Don't think about resting VMM info on this function.
It will be used if we already have a pending read/write of a page
for this thread, and thread must stay KILLED.
*/
if(thr == NULL)
{
return -1;
}
else
{
if(thr->state != THR_KILLED && destroy_thread(thread_id) != SUCCESS)
{
return -1;
}
else
{
struct pm_task *task = tsk_get(thr->task_id);
if(task == NULL) return -1;
if(thr->state != THR_KILLED)
{
task->num_threads--;
/* Fix Task List */
if(task->first_thread == thr)
{
task->first_thread = thr->next_thread;
}
else
{
// add a prev thread !!! this is awful
struct pm_thread *currTrhead = task->first_thread;
while(currTrhead != NULL && currTrhead->next_thread != thr)
{
currTrhead = currTrhead->next_thread;
}
currTrhead->next_thread = thr->next_thread;
}
}
// remove the thread signals
remove_thr_signals(thr);
if(thr->state != THR_KILLED && (thr->flags & (THR_FLAG_PAGEFAULT | THR_FLAG_PAGEFAULT_TBL)))
{
/* Thread is waiting for a page fault (either swap or PF) */
thr->state = THR_KILLED;
ret = 1;
}
else
{
thread_info[thr->id] = NULL;
kfree(thr);
thr = NULL;
}
if(thr != NULL)
{
if(thr->state == THR_KILLED)
task->killed_threads--;
if(thr->interrupt != 0)
int_dettach(thr);
/* Remove thread from scheduler */
sch_remove(thr);
}
return ret;
}
}
}
