void menu_nibpcal_closeproc(void) { nibp_data_t nibp_data; unsigned short ids; sched_stop(SCHED_NIBP); if (unit_get_data(NIBP, &nibp_data) <= 0) { debug("%s: error reading nibp data\n", __FUNCTION__); } if (nibp_data.meas_interval == NIBP_MEAS_INTERVAL_MANU) { ids = IDS_MANUALLY; sched_stop(SCHED_NIBP); } else { switch (nibp_meas_interval[nibp_data.meas_interval]) { case 1: ids = IDS_1MIN; break; case 2: ids = IDS_2MIN; break; case 5: ids = IDS_5MIN; break; case 10: ids = IDS_10MIN; break; case 15: ids = IDS_15MIN; break; case 30: ids = IDS_30MIN; break; case 60: ids = IDS_60MIN; break; default: ids = IDS_UNDEF7; } sched_start(SCHED_NIBP, nibp_meas_interval[nibp_data.meas_interval]*60*1000, nibp_do_bp, SCHED_NORMAL); } unit_ioctl(NIBP, SET_VALUE, UNIT_NIBP_MEAS_INTERVAL, ids); sched_start(SCHED_NIBP_REQDATA, NIBP_UPDATE_CUFFDATA_PERIOD, nibp_reqdata, SCHED_NORMAL); nibp_service(0); unsigned int v; v = (ON<<0) | (OPEN<<8) | (OPEN<<16); nibp_command(NIBP_CMD_CONTROL_PNEUMATICS, v); }
/*===========================================================================* * init_scheduling * *===========================================================================*/ PUBLIC void sched_init(void) { struct mproc *trmp; endpoint_t parent_e; int proc_nr, s; for (proc_nr=0, trmp=mproc; proc_nr < NR_PROCS; proc_nr++, trmp++) { /* Don't take over system processes. When the system starts, * init is blocked on RTS_NO_QUANTUM until PM assigns a * scheduler, from which other. Given that all other user * processes are forked from init and system processes are * managed by RS, there should be no other process that needs * to be assigned a scheduler here */ if (trmp->mp_flags & IN_USE && !(trmp->mp_flags & PRIV_PROC)) { assert(_ENDPOINT_P(trmp->mp_endpoint) == INIT_PROC_NR); parent_e = mproc[trmp->mp_parent].mp_endpoint; assert(parent_e == trmp->mp_endpoint); s = sched_start(SCHED_PROC_NR, /* scheduler_e */ trmp->mp_endpoint, /* schedulee_e */ parent_e, /* parent_e */ USER_Q, /* maxprio */ USER_QUANTUM, /* quantum */ -1, /* don't change cpu */ &trmp->mp_scheduler); /* *newsched_e */ if (s != OK) { printf("PM: SCHED denied taking over scheduling of %s: %d\n", trmp->mp_name, s); } } } }
void start_hypervisor() { int i; uint8_t nr_vcpus = 1; // TODO: It will be read from configuration file. uint32_t pcpu = smp_processor_id(); if (pcpu == 0) { timemanager_init(); sched_init(); vm_setup(); for (i = 0; i < NUM_GUESTS_STATIC; i++) { vmid_t vmid; if ((vmid = vm_create(nr_vcpus)) == VM_CREATE_FAILED) { printf("vm_create(vm[%d]) is failed\n", i); goto error; } if (vm_init(vmid) != HALTED) { printf("vm_init(vm[%d]) is failed\n", i); goto error; } if (vm_start(vmid) != RUNNING) { printf("vm_start(vm[%d]) is failed\n", i); goto error; } } smp_pen = 1; } else { while (!smp_pen) ; printf("cpu[%d] is enabled\n", pcpu); } /* * TODO: Add a function - return vmid or vcpu_id to execute for the first time. * TODO: Rename guest_sched_start to do_schedule or something others. * do_schedule(vmid) or do_schedule(vcpu_id) */ printf("sched_start!!!\n"); sched_start(); /* The code flow must not reach here */ error: printf("-------- [%s] ERROR: K-Hypervisor must not reach here\n", __func__); abort(); }
/*! \details This function runs the operating system. * */ int _main(void){ init_hw(); if ( sched_start(initial_thread, 10) < 0 ){ hwpl_debug("Error: Failed to start scheduler\n"); _hwpl_core_priv_disable_interrupts(NULL); gled_priv_error(0); } hwpl_debug("Error: return to main\n"); _hwpl_core_priv_disable_interrupts(NULL); gled_priv_error(0); while(1); return 0; }
/*===========================================================================* * init_scheduling * *===========================================================================*/ PUBLIC void sched_init(void) { struct mproc *trmp; int proc_nr; printf("-------------------sched_init() of pm\n"); for (proc_nr=0, trmp=mproc; proc_nr < NR_PROCS; proc_nr++, trmp++) { /* Don't take over system processes. When the system starts, * this will typically only take over init, from which other * user space processes will inherit. */ if (trmp->mp_flags & IN_USE && !(trmp->mp_flags & PRIV_PROC)) { if (sched_start(SCHED_PROC_NR, trmp, (SEND_PRIORITY | SEND_TIME_SLICE))) { printf("PM: SCHED denied taking over scheduling of %s\n", trmp->mp_name); } } } }
int main(int argc, char *argv[]) { #define SCHEDULE_ENTRIES_COUNT 2 ScheduleEntry scheduleEntries[SCHEDULE_ENTRIES_COUNT]; ScheduleArray scheduleArray; ScheduleEntry *pEntry; pthread_t schedule_tid; time_t current_time; struct tm tm_base; int second; bool continue_flag = true; log_init(); g_log_context.log_level = LOG_DEBUG; pEntry = scheduleEntries; memset(scheduleEntries, 0, sizeof(scheduleEntries)); logInfo("start..."); current_time = time(NULL); localtime_r(¤t_time, &tm_base); second = (60 + (tm_base.tm_sec - 10)) % 60; INIT_SCHEDULE_ENTRY((*pEntry), sched_generate_next_id(), tm_base.tm_hour, tm_base.tm_min, second, 60, schedule_func, NULL); pEntry++; scheduleArray.entries = scheduleEntries; scheduleArray.count = pEntry - scheduleEntries; sched_start(&scheduleArray, &schedule_tid, 64 * 1024, (bool * volatile)&continue_flag); sleep(600); logInfo("done."); return 0; }
//----------------------------------------------------------------------------- void kmain(struct multiboot_info *info, unsigned long magic) { #define bprintf(fmt, ...) _kprintf(0xA, fmt, ## __VA_ARGS__) mb_info = info; // initialize console so we can print boot status console_clear(0); // check multiboot magic number if (magic != MULTIBOOT_BOOTLOADER_MAGIC) { kprintf("Invalid Multiboot magic number\n"); return; } bprintf("32 bit Telos " VERSION "\n"); bprintf("Initializing machine state...\n"); idt_install(); gdt_install(); pic_init(0x20, 0x28); // map IRQs after exceptions/reserved vectors pit_init(100); // 10ms timer clock_init(); bprintf("Initializing kernel subsystems...\n"); init_subsystems(); bprintf("\n----------- MEMORY -----------\n"); bprintf("Kernel: %p - %p\n", &_kstart, &_kend); bprintf("Userspace: %p - %p\n", &_ustart, &_uend); bprintf("Total: %lx bytes\n", MULTIBOOT_MEM_MAX(mb_info)); mount_root(); bprintf("Starting Telos...\n\n"); sched_start(); #undef bprintf }
void kernel_main(unsigned long magic, unsigned long addr) { multiboot_info_t *mbi; if (magic != MULTIBOOT_BOOTLOADER_MAGIC) return; mbi = (multiboot_info_t*)addr; /* kernel init */ serial_init(DEBUG_SERIAL_PORT, DEBUG_SERIAL_SPEED, UART_8BITS_WORD, UART_NO_PARITY, UART_1_STOP_BIT); cls(); cpu_cli(); printf("[x] interrupts disabled\n"); gdt_initialize(); printf("[x] gdt initialized\n"); idt_initialize(); printf("[x] idt initialized\n"); breakpoint_initialize(); #if defined(USE_APIC) apic_initialize(); serial_printl("[x] apic initialized\n"); #else pic_initialize(); serial_printl("[x] pic initialized\n"); #endif /* USE_APIC */ /* initialize the kernel */ { kernel_init(mbi); } /* memory initialization */ { phys_init(mbi); phys_debug(); /* vm_init(); */ /* unit_test_vm(); */ /* cpu_hlt(); */ } #if defined(USE_PCI) pci_initialize(); pci_list(); #endif cpu_sti(); #if defined(USE_TASK) { /* subsystems */ event_initialize(); sched_initialize(); task_initialize(); /* tasks */ idle_initialize(); muksh_initialize(); net_initialize(); /* task_test(); */ /* start scheduling */ sched_start(); } #endif /* endless loop */ serial_printl("[?] kernel loop\n"); while (1) { serial_printl("k"); cpu_hlt(); } }
void respcalc_add_value(short val , unsigned char break_byte, unsigned char lead) { #if 0 static FILE * ff = 0; if (!ff) ff = fopen("respdata_raw.txt", "wt"); if (ff) { fprintf(ff, "rpg=%d\n", (int) val); fflush(ff); } #endif #define RESP_DATA_ACC_SIZE 40 #if defined (RESPCALC_CUBIC_SPLINE) #undef RESP_DATA_ACC_SIZE #define RESP_DATA_ACC_SIZE 10 static int beeps_valid_counter = 0; static int pulse_beep_pos_ptr_prev = 0; beeps_valid_counter ++; if (pulse_beep_pos_ptr != pulse_beep_pos_ptr_prev) { pulse_beep_pos_ptr_prev = pulse_beep_pos_ptr; beeps_valid_counter = 0; } if (beeps_valid_counter > 3*FD_ECG) // no any beep during 3 sec { memset(pulse_beep_pos, 0xff, sizeof(pulse_beep_pos)); pulse_beep_pos_ptr = 0; beeps_valid_counter = 0; } #endif long sum_rpg; static int ptr = 0; static short resp_data_acc[RESP_DATA_ACC_SIZE]; resp_data_acc[ptr++] = val; if ((ptr % 10) == 0) { int i; for (i=0,sum_rpg=0;i<RESP_DATA_ACC_SIZE;i++) sum_rpg += resp_data_acc[i]; val = sum_rpg / RESP_DATA_ACC_SIZE; } else { return; } if (ptr >= RESP_DATA_ACC_SIZE) ptr = 0; #if !defined (RESPCALC_COLIBRI) // resp analysis is implemented in SBDP since v 1.2 return; #endif if ( ((break_byte & 0x5) != 0 && lead == 1) || // RF ((break_byte & 0x3) != 0 && lead == 0) // RL ) { // if (num_data_in_acc) num_data_in_acc --; num_data_in_acc = 0; alarm_clr(RESP_APNOE); } resp_acc_buf[wp++] = val; if (wp >= RESPCALC_PROC_INTERVAL) { wp = 0; } #if defined (RESPCALC_CUBIC_SPLINE) int i; for (i=0; i<CUBIC_SPLINE_MAX_NUM_ITEMS; i++) { if (pulse_beep_pos[i] == wp) pulse_beep_pos[i] = (short)0xffff; } #endif num_data_in_acc ++; if (num_data_in_acc > RESPCALC_PROC_INTERVAL) { num_data_in_acc = RESPCALC_PROC_INTERVAL; } if (num_data_in_acc >= RESPCALC_MINCALC_INTERVAL && ((num_data_in_acc % FD_RPG) == 0)) { // start process data in resp_proc_buf sched_start(SCHED_RESP, 0, respcalc_proc, SCHED_DO_ONCE); } }
void menu_lowbatshutdown_openproc(void) { sched_start(SCHED_ANY, 5*1000, hide_lowbatshutdown_popup, SCHED_DO_ONCE); }
void ecgm_process_packet(unsigned char *data, int len) { ecgm_packet_t ecgm_packet, *pecgm_packet; ecg_data_t ecg_data; resp_data_t resp_data; static unsigned char old_sync = 0; static unsigned char old_set = 0xFF; static unsigned char old_break = 0xFF; int ev[NUM_ECG]; int i, v; char s[128]; static int break_countdown = 100; static unsigned char pacemaker_valid[2] = {0, 0}; static int startup_delay_counter = 2*500; // 2 sec static int resp_hw_reset_counter = 0; unsigned char b; #if 0 static FILE * f = 0; //if (!f) f = fopen("60601-2-51-CAL20160-50HZ.bin", "wb"); if (!f) f = fopen("nsft-ecg.bin", "wb"); if (f) { fwrite(data,1,len,f); fflush(f); } #endif unit_get_data(ECG, &ecg_data); if ((unsigned long)data & 0x1) { pecgm_packet = &ecgm_packet; memcpy(pecgm_packet, data, sizeof(ecgm_packet_t)); } else pecgm_packet = (ecgm_packet_t*)data; if ((unsigned char)(pecgm_packet->sync - old_sync) != 1) { error("ECG sync error: %02X %02X\n", old_sync, pecgm_packet->sync); } old_sync = pecgm_packet->sync; if (ecg_data.num_leads == 3) pecgm_packet->break_bits.c = 0; if (ecg_data.num_leads == 1) pecgm_packet->break_bits.l = pecgm_packet->break_bits.c = 0; alarm_set_clr(ECG_RBREAK, pecgm_packet->break_bits.r); alarm_set_clr(ECG_LBREAK, pecgm_packet->break_bits.l); alarm_set_clr(ECG_FBREAK, pecgm_packet->break_bits.f); alarm_set_clr(ECG_CBREAK, pecgm_packet->break_bits.c); ev[ECG_I-ECG_1] = (pecgm_packet->break_bits.l || pecgm_packet->break_bits.r) ? 0 : *((short*)(pecgm_packet->data)+0); ev[ECG_II-ECG_1] = (pecgm_packet->break_bits.f || pecgm_packet->break_bits.r) ? 0 : *((short*)(pecgm_packet->data)+1); ev[ECG_III-ECG_1] = (pecgm_packet->break_bits.f || pecgm_packet->break_bits.l) ? 0 : ev[ECG_II-ECG_1] - ev[ECG_I-ECG_1]; ev[ECG_aVR-ECG_1] = (pecgm_packet->break_bits.f || pecgm_packet->break_bits.r || pecgm_packet->break_bits.l) ? 0 : (-ev[ECG_II-ECG_1]-ev[ECG_I-ECG_1]) / 2; ev[ECG_aVL-ECG_1] = (pecgm_packet->break_bits.f || pecgm_packet->break_bits.r || pecgm_packet->break_bits.l) ? 0 : (2*ev[ECG_I-ECG_1] - ev[ECG_II-ECG_1]) / 2; ev[ECG_aVF-ECG_1] = (pecgm_packet->break_bits.f || pecgm_packet->break_bits.r || pecgm_packet->break_bits.l) ? 0 : ev[ECG_I-ECG_1] / 2; ev[ECG_V-ECG_1] = (pecgm_packet->break_bits.c || pecgm_packet->break_bits.l || pecgm_packet->break_bits.r || pecgm_packet->break_bits.f) ? 0 : *((short*)(pecgm_packet->data)+2) - (ev[ECG_I-ECG_1] + ev[ECG_II-ECG_1]) / 3; if (old_break != pecgm_packet->break_byte) { ecg_data.break_byte = pecgm_packet->break_byte; unit_set_data(ECG, &ecg_data); old_break = pecgm_packet->break_byte; // reload asystolia detector if (pecgm_packet->break_byte == 0) sched_start(SCHED_QRS_WAIT, ecg_data.asys_sec*1000, ecg_on_no_qrs, SCHED_NORMAL); // if (pecgm_packet->break_byte != 0) // sched_stop(SCHED_QRS_WAIT); b = ((ecg_data.break_byte & 0x3) != 0 && ecg_data.set_bits.breath_ch == 0) || // RL ((ecg_data.break_byte & 0x5) != 0 && ecg_data.set_bits.breath_ch == 1); // RF alarm_set_clr(RESP_BREAK, b); if (b) { #if defined (RESPCALC_COLIBRI) respcalc_reset(); #endif unsigned char b = 0xFE; resp_process_packet(&b, 1); } } if (pecgm_packet->break_byte != 0) break_countdown = 100; else if (break_countdown) break_countdown --; if (pecgm_packet->break_bits.l) pecgm_packet->pacemaker_bits.l = 0; if (pecgm_packet->break_bits.f) pecgm_packet->pacemaker_bits.f = 0; if (pecgm_packet->break_bits.c) pecgm_packet->pacemaker_bits.c = 0; if (ecg_data.num_leads == 3) pecgm_packet->pacemaker_bits.c = 0; if (ecg_data.num_leads == 1) pecgm_packet->pacemaker_bits.l = pecgm_packet->pacemaker_bits.c = 0; // !!! this code makes delay 2*10 ms for the pacemaker mark, see pm drawing in cframe update !!! if (pacemaker_valid[1]) pacemaker_valid[1] ++; if (pecgm_packet->pacemaker != 0 && pecgm_packet->break_byte == 0) { pacemaker_valid[0] = pecgm_packet->pacemaker; pacemaker_valid[1] = 1; pecgm_packet->pacemaker = 0; } if (pecgm_packet->break_byte) pacemaker_valid[1] = 0; if (pacemaker_valid[1] == 10) { pacemaker_valid[1] = 0; pecgm_packet->pacemaker = pacemaker_valid[0]; pacemaker_valid[0] = 0; } #if 0 if (pecgm_packet->break_byte) { pecgm_packet->pacemaker = 0; if (sched_is_started(SCHED_PMBEAT)) { sched_stop(SCHED_PMBEAT); unit_hide_pm(); } } #endif if (break_countdown || startup_delay_counter) pecgm_packet->pacemaker = 0; if (startup_delay_counter) startup_delay_counter --; if (pecgm_packet->pacemaker) { debug("pm %X br %X\n", pecgm_packet->pacemaker, pecgm_packet->break_byte); } if ( pecgm_packet->pacemaker != 0) { #if 0 //defined (RESPCALC_COLIBRI) respcalc_reset(); // now we are not able to process breath with pacemaker // TODO: maybe need to perform this feature #endif unit_ioctl(ECG, SET_VALUE, UNIT_ECG_PM_IMG, IMAGE_PM); sched_start(SCHED_PMBEAT, 4000, unit_hide_pm, SCHED_NORMAL); // no answer for PM arrhythmia detection is implemented in SBDP /* if (!sched_is_started(SCHED_PM_NORESP)) { unit_get_data(ECG, &ecg_data); sched_start(SCHED_PM_NORESP, ecg_data.pmnr_ms, ecg_pm_no_answer); }*/ } for (i=0; i<NUM_ECG; i++) { ev[i] = MAKELONG((signed short)(ev[i]), pecgm_packet->pacemaker); } dview_chandata_add(ECG_I, ev[ECG_I-ECG_1]); dview_chandata_add(ECG_II, ev[ECG_II-ECG_1]); dview_chandata_add(ECG_III, ev[ECG_III-ECG_1]); dview_chandata_add(ECG_aVF, ev[ECG_aVF-ECG_1]); dview_chandata_add(ECG_aVR, ev[ECG_aVR-ECG_1]); dview_chandata_add(ECG_aVL, ev[ECG_aVL-ECG_1]); dview_chandata_add(ECG_V, ev[ECG_V-ECG_1]); #if 0 static int cnt = 0; static double f = 0.2; *((short*)(pecgm_packet->data)+3) += 10000*sin((double)2*3.1415926*f*cnt*0.002); cnt ++; #endif // filter RPG // *((short*)(pecgm_packet->data)+3) = resp_filt_stepit(filt_resp_id, (int) *((short*)(pecgm_packet->data)+3)); // dview_chandata_add(RPG, *((short*)(pecgm_packet->data)+3) * 0.05); static int timer_after_soft_reset = 5*FD_ECG; // 5 sec v = *((short*)(pecgm_packet->data)+3) * 2; if (timer_after_soft_reset > 0) timer_after_soft_reset --; if (v < -32000 || v > 32000) { if (timer_after_soft_reset == 0) { timer_after_soft_reset = 5*FD_ECG; // 5 sec resp_soft_hw_reset(); } } #if defined (RESPCALC_COLIBRI) // add new RPG value for processing respcalc_add_value(v, pecgm_packet->break_byte, (unsigned char)ecg_data.set_bits.breath_ch); #endif if (v < -32000) v = -32000; if (v > +32000) v = +32000; dview_chandata_add(RESP, (int)((float)v * 0.05)); if (pecgm_packet->set_bits.taubr300) { resp_hw_reset_counter ++; if (resp_hw_reset_counter >= 2*FD_ECG) // 1 sec { resp_hw_reset_counter -= 100; ecgm_command(ECGM_RESP_TAU_6800); #if defined (RESPCALC_COLIBRI) respcalc_reset(); #endif } } else { resp_hw_reset_counter = 0; } //printf("%d\n", *((short*)(pecgm_packet->data)+3)); if (old_set != (pecgm_packet->set & 0x7f)) { inpfoc_item_t * pifi; if (unit_get_data(ECG, &ecg_data) <= 0) { error("%s: error reading ecg data\n", __FUNCTION__); } if (unit_get_data(RESP, &resp_data) <= 0) { error("%s: error reading resp data\n", __FUNCTION__); } resp_data.lead = pecgm_packet->set_bits.breath_ch; resp_data.tau = pecgm_packet->set_bits.taubr300; switch (pecgm_packet->set_bits.tau) { case TAU_3200: // diagnostics mode // if (cframe_get_ecgfilt_mode() != MODE_DIAGNOSTICS) cframe_set_ecgfilt_mode((ecg_data.set_bits.diag_f) ? MODE_DIAGNOSTICS_F : MODE_DIAGNOSTICS); // cframe_command(CFRAME_FILT_MODE_SET, (void*)((unsigned int)MODE_DIAGNOSTICS)); // cur_mode = MODE_DIAGNOSTICS; break; case TAU_320: // monitoring mode // if (cframe_get_ecgfilt_mode() != MODE_MONITORING) cframe_set_ecgfilt_mode(MODE_MONITORING); // cframe_command(CFRAME_FILT_MODE_SET, (void*)((unsigned int)MODE_MONITORING)); // cur_mode = MODE_MONITORING; break; case TAU_160: // surgery mode // if (cframe_get_ecgfilt_mode() != MODE_SURGERY) cframe_set_ecgfilt_mode(MODE_SURGERY); // cframe_command(CFRAME_FILT_MODE_SET, (void*)((unsigned int)MODE_SURGERY)); // cur_mode = MODE_SURGERY; break; default: error("%s: unknown ecg mode (tau=%d)\n", __FILE__, pecgm_packet->set_bits.tau); break; } ecg_data.set &= ~0x7f; ecg_data.set |= pecgm_packet->set; ids2string((ecg_data.set_bits.dhf) ? IDS_ON : IDS_OFF, s); pifi = inpfoc_find(INPFOC_ECGSET, ECGSET_DHF); if (pifi) inpfoc_wnd_setcaption(pifi, s); pifi = inpfoc_find(INPFOC_RESPSET, RESPSET_CHANSEL); if (pifi) inpfoc_wnd_setcaption(pifi, (ecg_data.set_bits.breath_ch) ? "RF" : "RL"); if (unit_set_data(ECG, &ecg_data) <= 0) { error("%s: error writing ecg data\n", __FUNCTION__); } if (unit_set_data(RESP, &resp_data) <= 0) { error("%s: error writing resp data\n", __FUNCTION__); } //printf("ecg set %02X\n", ecg_data.set); } // new set // analyze Z base // if ( data[13] & 0xC0/*((data[13]<< 8) | data[12]) > 16000*/ ) // 16384 or higher if ( data[13] & 0x80 ) // 32768 or higher { // alarm_set((ecg_data.set_bits.breath_ch) ? RESP_BADCONTACT_RL : RESP_BADCONTACT_RF); alarm_set((data[14]&0x20) ? RESP_BADCONTACT_RF : RESP_BADCONTACT_RL); unsigned char b = 0xFE; resp_process_packet(&b, 1); } else { alarm_clr(RESP_BADCONTACT_RL); alarm_clr(RESP_BADCONTACT_RF); } #if defined (ECGM_CR_ZBASE_MONITORING) static int cnt_z = 0; static long sum_zpulse = 0; static unsigned long sum_zbase = 0; sum_zbase += (unsigned char)data[13] * 256 + (unsigned char)data[12]; sum_zpulse += *((short*)(pecgm_packet->data)+3); cnt_z ++; if (cnt_z == 500) { sum_zbase /= cnt_z; iframe_command(IFRAME_SET_CARDNO, (void*)((int)(sum_zbase))); sum_zpulse /= (cnt_z*10); if (sum_zpulse < 0) sum_zpulse = -sum_zpulse; iframe_command(IFRAME_SET_BEDNO, (void*)((int)(sum_zpulse))); cnt_z = 0; sum_zbase = 0; } #endif // printf("Z pulse = %d\n", *((short*)(pecgm_packet->data)+3)); // printf("Z base = %d\n", ((data[13]<< 8) | data[12])); old_set = pecgm_packet->set & 0x7f; csio_ecgdata_c_t csio_ecgdata_c; memset(&csio_ecgdata_c, 0, sizeof(csio_ecgdata_c_t)); csio_ecgdata_c.sync = pecgm_packet->sync; csio_ecgdata_c.mode = ecg_data.set; csio_ecgdata_c.break_byte = pecgm_packet->break_byte; memcpy(&csio_ecgdata_c.data[0], &pecgm_packet->data[0], 3*sizeof(short)); csio_ecgdata_c.pm = pecgm_packet->pacemaker; csio_send_msg(CSIO_ID_ECG_C, &csio_ecgdata_c, sizeof(csio_ecgdata_c_t)); csio_respdata_c_t csio_respdata_c; memset(&csio_respdata_c, 0, sizeof(csio_respdata_c_t)); csio_respdata_c.sync = pecgm_packet->sync; csio_respdata_c.lead = pecgm_packet->set; csio_respdata_c.rpg = *((short*)(pecgm_packet->data)+3); csio_send_msg(CSIO_ID_RESP_C, &csio_respdata_c, sizeof(csio_respdata_c_t)); }
void ecgm_command(unsigned char cmd) { int i, l; if (cmd == ECGM_DEMO_OFF) { ecgm_demo_mode = 0; return; } else if (cmd == ECGM_DEMO_ON) { ecgm_demo_mode = 1; return; } if (ecgm_demo_mode) { return; } #if defined (RESPCALC_COLIBRI) if (cmd == ECGM_RESP_CHAN_RL || cmd == ECGM_RESP_CHAN_RF || cmd == ECGM_RESP_TAU_320 || cmd == ECGM_RESP_TAU_6800 || cmd == ECGM_RESP_ON) { sched_start(SCHED_ANY, 5*1000, respcalc_reset, SCHED_DO_ONCE); } #endif if (ecgm_num_cmds_running >= ECGM_MAX_NUM_CMDS_IN_QUEUE) { error("ecgm cmds overflow\n"); for (i=0; i<ECGM_MAX_NUM_CMDS_IN_QUEUE; i++) { ecgm_cmd_ex[i].running = 0; } ecgm_num_cmds_running = 0; return; } for (i=0; i<ECGM_MAX_NUM_CMDS_IN_QUEUE; i++) { if (ecgm_cmd_ex[i].cmd == cmd) { ecgm_cmd_ex[i].running = 0; break; } } if (i == ECGM_MAX_NUM_CMDS_IN_QUEUE) { for (i=0; i<ECGM_MAX_NUM_CMDS_IN_QUEUE; i++) { if (ecgm_cmd_ex[i].running == 0) break; } } if (i >= ECGM_MAX_NUM_CMDS_IN_QUEUE) { return; } for (l=0; l<sizeof(ecgm_cmd_list)/sizeof(ecgm_cmd_list_t); l++) { if (ecgm_cmd_list[l].cmd == cmd) break; } if (l == sizeof(ecgm_cmd_list)/sizeof(ecgm_cmd_list_t)) { return; } ecgm_cmd_ex[i].cmd = ecgm_cmd_list[l].cmd; ecgm_cmd_ex[i].cbit = ecgm_cmd_list[l].cbit; ecgm_cmd_ex[i].sbit = ecgm_cmd_list[l].sbit; ecgm_cmd_ex[i].retry_count = 0; ecgm_cmd_ex[i].running = 1; dio_module_cmd(PD_ID_ECG, ecgm_cmd_ex[i].cmd); if (ecgm_num_cmds_running == 0) { sched_start(SCHED_ECGM, 100, ecgm_analyze_input, SCHED_NORMAL); } ecgm_num_cmds_running ++; }
int main(int argc, char *argv[]) { char *conf_filename; int result; int sock; int wait_count; pthread_t schedule_tid; struct sigaction act; ScheduleEntry scheduleEntries[SCHEDULE_ENTRIES_MAX_COUNT]; ScheduleArray scheduleArray; char pidFilename[MAX_PATH_SIZE]; bool stop; if (argc < 2) { usage(argv[0]); return 1; } g_current_time = time(NULL); g_up_time = g_current_time; log_init2(); trunk_shared_init(); conf_filename = argv[1]; if ((result=get_base_path_from_conf_file(conf_filename, g_fdfs_base_path, sizeof(g_fdfs_base_path))) != 0) { log_destroy(); return result; } snprintf(pidFilename, sizeof(pidFilename), "%s/data/fdfs_storaged.pid", g_fdfs_base_path); if ((result=process_action(pidFilename, argv[2], &stop)) != 0) { if (result == EINVAL) { usage(argv[0]); } log_destroy(); return result; } if (stop) { log_destroy(); return 0; } #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (getExeAbsoluteFilename(argv[0], g_exe_name, \ sizeof(g_exe_name)) == NULL) { logCrit("exit abnormally!\n"); log_destroy(); return errno != 0 ? errno : ENOENT; } #endif memset(g_bind_addr, 0, sizeof(g_bind_addr)); if ((result=storage_func_init(conf_filename, \ g_bind_addr, sizeof(g_bind_addr))) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } sock = socketServer(g_bind_addr, g_server_port, &result); if (sock < 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=tcpsetserveropt(sock, g_fdfs_network_timeout)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } daemon_init(false); umask(0); if ((result=write_to_pid_file(pidFilename)) != 0) { log_destroy(); return result; } if ((result=storage_sync_init()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "storage_sync_init fail, program exit!", __LINE__); g_continue_flag = false; return result; } if ((result=tracker_report_init()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_report_init fail, program exit!", __LINE__); g_continue_flag = false; return result; } if ((result=storage_service_init()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "storage_service_init fail, program exit!", __LINE__); g_continue_flag = false; return result; } if ((result=set_rand_seed()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "set_rand_seed fail, program exit!", __LINE__); g_continue_flag = false; return result; } memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigUsrHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigHupHandler; if(sigaction(SIGHUP, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = SIG_IGN; if(sigaction(SIGPIPE, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigQuitHandler; if(sigaction(SIGINT, &act, NULL) < 0 || \ sigaction(SIGTERM, &act, NULL) < 0 || \ sigaction(SIGQUIT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #if defined(DEBUG_FLAG) /* #if defined(OS_LINUX) memset(&act, 0, sizeof(act)); act.sa_sigaction = sigSegvHandler; act.sa_flags = SA_SIGINFO; if (sigaction(SIGSEGV, &act, NULL) < 0 || \ sigaction(SIGABRT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif */ memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigDumpHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif #ifdef WITH_HTTPD if (!g_http_params.disabled) { if ((result=storage_httpd_start(g_bind_addr)) != 0) { logCrit("file: "__FILE__", line: %d, " \ "storage_httpd_start fail, " \ "program exit!", __LINE__); return result; } } #endif if ((result=tracker_report_thread_start()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_report_thread_start fail, " \ "program exit!", __LINE__); g_continue_flag = false; storage_func_destroy(); log_destroy(); return result; } scheduleArray.entries = scheduleEntries; memset(scheduleEntries, 0, sizeof(scheduleEntries)); scheduleEntries[0].id = 1; scheduleEntries[0].time_base.hour = TIME_NONE; scheduleEntries[0].time_base.minute = TIME_NONE; scheduleEntries[0].interval = g_sync_log_buff_interval; scheduleEntries[0].task_func = log_sync_func; scheduleEntries[0].func_args = &g_log_context; scheduleEntries[1].id = 2; scheduleEntries[1].time_base.hour = TIME_NONE; scheduleEntries[1].time_base.minute = TIME_NONE; scheduleEntries[1].interval = g_sync_binlog_buff_interval; scheduleEntries[1].task_func = fdfs_binlog_sync_func; scheduleEntries[1].func_args = NULL; scheduleEntries[2].id = 3; scheduleEntries[2].time_base.hour = TIME_NONE; scheduleEntries[2].time_base.minute = TIME_NONE; scheduleEntries[2].interval = g_sync_stat_file_interval; scheduleEntries[2].task_func = fdfs_stat_file_sync_func; scheduleEntries[2].func_args = NULL; scheduleArray.count = 3; if (g_if_use_trunk_file) { scheduleEntries[scheduleArray.count].id = 4; scheduleEntries[scheduleArray.count].time_base.hour = TIME_NONE; scheduleEntries[scheduleArray.count].time_base.minute=TIME_NONE; scheduleEntries[scheduleArray.count].interval = 1; scheduleEntries[scheduleArray.count].task_func = \ trunk_binlog_sync_func; scheduleEntries[scheduleArray.count].func_args = NULL; scheduleArray.count++; } if (g_use_access_log) { scheduleEntries[scheduleArray.count].id = 5; scheduleEntries[scheduleArray.count].time_base.hour = TIME_NONE; scheduleEntries[scheduleArray.count].time_base.minute=TIME_NONE; scheduleEntries[scheduleArray.count].interval = \ g_sync_log_buff_interval; scheduleEntries[scheduleArray.count].task_func = log_sync_func; scheduleEntries[scheduleArray.count].func_args = \ &g_access_log_context; scheduleArray.count++; if (g_rotate_access_log) { scheduleEntries[scheduleArray.count].id = 6; scheduleEntries[scheduleArray.count].time_base = \ g_access_log_rotate_time; scheduleEntries[scheduleArray.count].interval = \ 24 * 3600; scheduleEntries[scheduleArray.count].task_func = \ log_notify_rotate; scheduleEntries[scheduleArray.count].func_args = \ &g_access_log_context; scheduleArray.count++; } } if (g_rotate_error_log) { scheduleEntries[scheduleArray.count].id = 7; scheduleEntries[scheduleArray.count].time_base = \ g_error_log_rotate_time; scheduleEntries[scheduleArray.count].interval = \ 24 * 3600; scheduleEntries[scheduleArray.count].task_func = \ log_notify_rotate; scheduleEntries[scheduleArray.count].func_args = \ &g_log_context; scheduleArray.count++; } if ((result=sched_start(&scheduleArray, &schedule_tid, \ g_thread_stack_size, (bool * volatile)&g_continue_flag)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=set_run_by(g_run_by_group, g_run_by_user)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=storage_dio_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } log_set_cache(true); bTerminateFlag = false; bAcceptEndFlag = false; storage_accept_loop(sock); bAcceptEndFlag = true; fdfs_binlog_sync_func(NULL); //binlog fsync if (g_schedule_flag) { pthread_kill(schedule_tid, SIGINT); } storage_terminate_threads(); storage_dio_terminate(); kill_tracker_report_threads(); kill_storage_sync_threads(); wait_count = 0; while (g_storage_thread_count != 0 || \ g_dio_thread_count != 0 || \ g_tracker_reporter_count > 0 || \ g_schedule_flag) { /* #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (bSegmentFault) { sleep(5); break; } #endif */ usleep(10000); if (++wait_count > 6000) { logWarning("waiting timeout, exit!"); break; } } tracker_report_destroy(); storage_service_destroy(); storage_sync_destroy(); storage_func_destroy(); if (g_if_use_trunk_file) { trunk_sync_destroy(); storage_trunk_destroy(); } logInfo("exit normally.\n"); log_destroy(); delete_pid_file(pidFilename); return 0; }
int main(int argc, char *argv[]) { char *conf_filename; int result; int wait_count; int sock; pthread_t schedule_tid; struct sigaction act; ScheduleEntry scheduleEntries[SCHEDULE_ENTRIES_COUNT]; ScheduleArray scheduleArray; char pidFilename[MAX_PATH_SIZE]; bool stop; if (argc < 2) { usage(argv[0]); return 1; } g_current_time = time(NULL); g_up_time = g_current_time; srand(g_up_time); log_init2(); //通过指定的conf文件,获取base path conf_filename = argv[1]; if ((result=get_base_path_from_conf_file(conf_filename, g_fdfs_base_path, sizeof(g_fdfs_base_path))) != 0) { log_destroy(); return result; } //启动程序,或者通过文件中的pid来kill掉之前的进程 snprintf(pidFilename, sizeof(pidFilename), "%s/data/fdfs_trackerd.pid", g_fdfs_base_path); if ((result=process_action(pidFilename, argv[2], &stop)) != 0) { if (result == EINVAL) { usage(argv[0]); } log_destroy(); return result; } if (stop) { log_destroy(); return 0; } #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (getExeAbsoluteFilename(argv[0], g_exe_name, \ sizeof(g_exe_name)) == NULL) { logCrit("exit abnormally!\n"); log_destroy(); return errno != 0 ? errno : ENOENT; } #endif memset(bind_addr, 0, sizeof(bind_addr)); if ((result=tracker_load_from_conf_file(conf_filename, \ bind_addr, sizeof(bind_addr))) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } //g_tracker_last_status只记录了uptime和last check time作用未知 if ((result=tracker_load_status_from_file(&g_tracker_last_status)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } base64_init_ex(&g_base64_context, 0, '-', '_', '.'); if ((result=set_rand_seed()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "set_rand_seed fail, program exit!", __LINE__); return result; } //内存分配及历史group和storage载入 if ((result=tracker_mem_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } sock = socketServer(bind_addr, g_server_port, &result); if (sock < 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=tcpsetserveropt(sock, g_fdfs_network_timeout)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } //后台运行 daemon_init(false); umask(0); //将pid记录到文件中 if ((result=write_to_pid_file(pidFilename)) != 0) { log_destroy(); return result; } //启动工作线程,这一块需要重点看 if ((result=tracker_service_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } //注册信号处理函数 memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigUsrHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigHupHandler; if(sigaction(SIGHUP, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = SIG_IGN; if(sigaction(SIGPIPE, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigQuitHandler; if(sigaction(SIGINT, &act, NULL) < 0 || \ sigaction(SIGTERM, &act, NULL) < 0 || \ sigaction(SIGQUIT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #if defined(DEBUG_FLAG) /* #if defined(OS_LINUX) memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_sigaction = sigSegvHandler; act.sa_flags = SA_SIGINFO; if (sigaction(SIGSEGV, &act, NULL) < 0 || \ sigaction(SIGABRT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif */ memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigDumpHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif #ifdef WITH_HTTPD if (!g_http_params.disabled) { if ((result=tracker_httpd_start(bind_addr)) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_httpd_start fail, program exit!", \ __LINE__); return result; } } if ((result=tracker_http_check_start()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_http_check_start fail, " \ "program exit!", __LINE__); return result; } #endif if ((result=set_run_by(g_run_by_group, g_run_by_user)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } //schedule 调度线程,主要作用待细看 scheduleArray.entries = scheduleEntries; scheduleArray.count = 0; memset(scheduleEntries, 0, sizeof(scheduleEntries)); //日志处理,日志是先存在cache中的,需要定时存储 INIT_SCHEDULE_ENTRY(scheduleEntries[scheduleArray.count], scheduleArray.count + 1, TIME_NONE, TIME_NONE, TIME_NONE, g_sync_log_buff_interval, log_sync_func, &g_log_context); scheduleArray.count++; //用户检测trunk server服务器是否可用(trunk server是选定的一个storage) INIT_SCHEDULE_ENTRY(scheduleEntries[scheduleArray.count], scheduleArray.count + 1, TIME_NONE, TIME_NONE, TIME_NONE, g_check_active_interval, tracker_mem_check_alive, NULL); scheduleArray.count++; //每5分钟刷新一下status INIT_SCHEDULE_ENTRY(scheduleEntries[scheduleArray.count], scheduleArray.count + 1, 0, 0, 0, TRACKER_SYNC_STATUS_FILE_INTERVAL, tracker_write_status_to_file, NULL); scheduleArray.count++; if (g_rotate_error_log) { INIT_SCHEDULE_ENTRY_EX(scheduleEntries[scheduleArray.count], scheduleArray.count + 1, g_error_log_rotate_time, 24 * 3600, log_notify_rotate, &g_log_context); scheduleArray.count++; if (g_log_file_keep_days > 0) { log_set_keep_days(&g_log_context, g_log_file_keep_days); INIT_SCHEDULE_ENTRY(scheduleEntries[scheduleArray.count], scheduleArray.count + 1, 1, 0, 0, 24 * 3600, log_delete_old_files, &g_log_context); scheduleArray.count++; } } if ((result=sched_start(&scheduleArray, &schedule_tid, \ g_thread_stack_size, (bool * volatile)&g_continue_flag)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } //选主机制,tracker默认不会把自己加入队列 if ((result=tracker_relationship_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } log_set_cache(true); bTerminateFlag = false; bAcceptEndFlag = false; //accept线程,工作线程和消息接收线程是分开的 tracker_accept_loop(sock); bAcceptEndFlag = true; if (g_schedule_flag) { pthread_kill(schedule_tid, SIGINT); } tracker_terminate_threads(); #ifdef WITH_HTTPD if (g_http_check_flag) { tracker_http_check_stop(); } while (g_http_check_flag) { usleep(50000); } #endif wait_count = 0; //线程数和调度flag还在,则继续运行程序 while ((g_tracker_thread_count != 0) || g_schedule_flag) { /* #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (bSegmentFault) { sleep(5); break; } #endif */ usleep(10000); if (++wait_count > 3000) { logWarning("waiting timeout, exit!"); break; } } tracker_mem_destroy(); tracker_service_destroy(); tracker_relationship_destroy(); logInfo("exit normally.\n"); log_destroy(); delete_pid_file(pidFilename); return 0; }
int main(int argc, char *argv[]) { char *conf_filename; int result; int sock; pthread_t schedule_tid; struct sigaction act; ScheduleEntry scheduleEntries[SCHEDULE_ENTRIES_COUNT]; ScheduleArray scheduleArray; if (argc < 2) { printf("Usage: %s <config_file>\n", argv[0]); return 1; } g_current_time = time(NULL); g_up_time = g_current_time; srand(g_up_time); log_init(); #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (getExeAbsoluteFilename(argv[0], g_exe_name, \ sizeof(g_exe_name)) == NULL) { logCrit("exit abnormally!\n"); log_destroy(); return errno != 0 ? errno : ENOENT; } #endif conf_filename = argv[1]; memset(bind_addr, 0, sizeof(bind_addr)); if ((result=tracker_load_from_conf_file(conf_filename, \ bind_addr, sizeof(bind_addr))) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=tracker_load_status_from_file(&g_tracker_last_status)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } base64_init_ex(&g_base64_context, 0, '-', '_', '.'); if ((result=set_rand_seed()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "set_rand_seed fail, program exit!", __LINE__); return result; } if ((result=tracker_mem_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } sock = socketServer(bind_addr, g_server_port, &result); if (sock < 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=tcpsetserveropt(sock, g_fdfs_network_timeout)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } daemon_init(true); umask(0); if (dup2(g_log_context.log_fd, STDOUT_FILENO) < 0 || \ dup2(g_log_context.log_fd, STDERR_FILENO) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call dup2 fail, errno: %d, error info: %s, " \ "program exit!", __LINE__, errno, STRERROR(errno)); g_continue_flag = false; return errno; } if ((result=tracker_service_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigUsrHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigHupHandler; if(sigaction(SIGHUP, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = SIG_IGN; if(sigaction(SIGPIPE, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } act.sa_handler = sigQuitHandler; if(sigaction(SIGINT, &act, NULL) < 0 || \ sigaction(SIGTERM, &act, NULL) < 0 || \ sigaction(SIGQUIT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #if defined(DEBUG_FLAG) /* #if defined(OS_LINUX) memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_sigaction = sigSegvHandler; act.sa_flags = SA_SIGINFO; if (sigaction(SIGSEGV, &act, NULL) < 0 || \ sigaction(SIGABRT, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif */ memset(&act, 0, sizeof(act)); sigemptyset(&act.sa_mask); act.sa_handler = sigDumpHandler; if(sigaction(SIGUSR1, &act, NULL) < 0 || \ sigaction(SIGUSR2, &act, NULL) < 0) { logCrit("file: "__FILE__", line: %d, " \ "call sigaction fail, errno: %d, error info: %s", \ __LINE__, errno, STRERROR(errno)); logCrit("exit abnormally!\n"); return errno; } #endif #ifdef WITH_HTTPD if (!g_http_params.disabled) { if ((result=tracker_httpd_start(bind_addr)) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_httpd_start fail, program exit!", \ __LINE__); return result; } } if ((result=tracker_http_check_start()) != 0) { logCrit("file: "__FILE__", line: %d, " \ "tracker_http_check_start fail, " \ "program exit!", __LINE__); return result; } #endif if ((result=set_run_by(g_run_by_group, g_run_by_user)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } scheduleArray.entries = scheduleEntries; memset(scheduleEntries, 0, sizeof(scheduleEntries)); scheduleEntries[0].id = 1; scheduleEntries[0].time_base.hour = TIME_NONE; scheduleEntries[0].time_base.minute = TIME_NONE; scheduleEntries[0].interval = g_sync_log_buff_interval; scheduleEntries[0].task_func = log_sync_func; scheduleEntries[0].func_args = &g_log_context; scheduleEntries[1].id = 2; scheduleEntries[1].time_base.hour = TIME_NONE; scheduleEntries[1].time_base.minute = TIME_NONE; scheduleEntries[1].interval = g_check_active_interval; scheduleEntries[1].task_func = tracker_mem_check_alive; scheduleEntries[1].func_args = NULL; scheduleEntries[2].id = 3; scheduleEntries[2].time_base.hour = 0; scheduleEntries[2].time_base.minute = 0; scheduleEntries[2].interval = TRACKER_SYNC_STATUS_FILE_INTERVAL; scheduleEntries[2].task_func = tracker_write_status_to_file; scheduleEntries[2].func_args = NULL; scheduleArray.count = 3; if (g_rotate_error_log) { scheduleEntries[scheduleArray.count].id = 4; scheduleEntries[scheduleArray.count].time_base = \ g_error_log_rotate_time; scheduleEntries[scheduleArray.count].interval = \ 24 * 3600; scheduleEntries[scheduleArray.count].task_func = \ log_notify_rotate; scheduleEntries[scheduleArray.count].func_args = \ &g_log_context; scheduleArray.count++; } if ((result=sched_start(&scheduleArray, &schedule_tid, \ g_thread_stack_size, (bool * volatile)&g_continue_flag)) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } if ((result=tracker_relationship_init()) != 0) { logCrit("exit abnormally!\n"); log_destroy(); return result; } log_set_cache(true); bTerminateFlag = false; bAcceptEndFlag = false; tracker_accept_loop(sock); bAcceptEndFlag = true; if (g_schedule_flag) { pthread_kill(schedule_tid, SIGINT); } tracker_terminate_threads(); #ifdef WITH_HTTPD if (g_http_check_flag) { tracker_http_check_stop(); } while (g_http_check_flag) { usleep(50000); } #endif while ((g_tracker_thread_count != 0) || g_schedule_flag) { /* #if defined(DEBUG_FLAG) && defined(OS_LINUX) if (bSegmentFault) { sleep(5); break; } #endif */ usleep(50000); } tracker_mem_destroy(); tracker_service_destroy(); tracker_relationship_destroy(); logInfo("exit normally.\n"); log_destroy(); return 0; }