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;
}
