int s_zlog_init(const char *conf) { int rc; rc = zlog_init(conf); if (rc) { printf("BNC_LOG: init config failed!\n"); printf("BNC_LOG: Now init to default!\n"); rc= zlog_init(NULL); if(rc){ printf("BNC_LOG: init to default faild!\n"); return -1; } } zc = zlog_get_category("bnc_cat"); if (!zc) { printf("BNC_LOG: get cat fail\n"); printf("BNC_LOG: bnc_log system will not work!"); zlog_fini(); return -2; }; return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_by_roy.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category(MY_CATEGORY); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "hello, zlog"); sleep(1); zlog_info(zc, "hello, zlog2"); sleep(2); zlog_info(zc, "hello, zlog3"); zlog_info(zc, "hello, zlog4"); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_level.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_trace(zc, "hello, zlog - trace"); zlog_debug(zc, "hello, zlog - debug"); zlog_info(zc, "hello, zlog - info"); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_syslog.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "hello, zlog -- info"); zlog_error(zc, "hello, zlog -- error"); zlog_fini(); return 0; }
int zlog_test() { int rc; zlog_category_t *c; rc = zlog_init("d:\\tmp\\zlog.conf"); if (rc) { printf("init failed\n"); return -1; } c = zlog_get_category("my_cat"); if (!c) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(c, "hello, zlog"); zlog_debug(c, "hello, zlog"); zlog_error(c, "hello, zlog"); zlog_fini(); printf("exit.\n"); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_conf.conf"); if (rc) { printf("init failed, try zlog-chk-conf test_conf.conf for more detail\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "hello, zlog"); zlog_fini(); printf("log end\n"); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_tmp.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_debug(zc, "%s%d"); zlog_info(zc, "hello, zlog 2"); sleep(1); zlog_info(zc, "hello, zlog 3"); zlog_debug(zc, "hello, zlog 4"); // zlog_profile(); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc = 0; int j = 100; rc = zlog_init("change_rule.conf"); if (rc){ printf("init failed\n"); return 2; } zlog_category_t *zc; zc = zlog_get_category("yang"); pthread_t tid; pthread_create(&tid, NULL, work, (void*)("yang")); while(j-- > 0) { zlog_debug(zc, "debuglog"); zlog_info(zc, "infolog"); zlog_error(zc, "errorlog"); sleep(1); } pthread_join(tid, NULL); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc = 0; zlog_category_t *zc = NULL; // 初始化库, 给出配置文件路径 rc = zlog_init("test_hello.conf"); if (rc) { printf("init failed\n"); return -1; } // 获取分类名, 表示要打印哪些日志 zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "hello, zlog"); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_mdc.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "1.hello, zlog"); zlog_put_mdc("myname", "Zhang"); zlog_info(zc, "2.hello, zlog"); zlog_put_mdc("myname", "Li"); zlog_info(zc, "3.hello, zlog"); zlog_fini(); return 0; }
int main(int argc, char** argv) { unsigned char aa[32]; int i, j; i = 1; j = 2; zlog_init("AA"); // i = atoi(argv[1]); // j = atoi(argv[2]); printf("Hello.\n"); zlog_test(); // // memset(aa, 0x00, sizeof(aa)); // // aa[i/8] |= ~(0xFF << (8 - i % 8)); // memset(aa + i/8 + 1, 0xFF, sizeof(aa) - i/8 - 1); // hdzlog_info(aa, sizeof(aa)); // // dzlog_info("%0x", aa[j/8]); // dzlog_info("%0x", aa[j/8] >> 6); // // dzlog_info("%0x", ~((aa[j/8] >> (7 - j % 8)) & 0x01) ); // // zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc; if (argc != 4) { fprintf(stderr, "test nprocess nthreads nloop\n"); exit(1); } rc = zlog_init("test_press_zlog.conf"); if (rc) { printf("init failed\n"); return 2; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat failed\n"); zlog_fini(); return 3; } loop_count = atol(argv[3]); test(atol(argv[1]), atol(argv[2])); zlog_fini(); return 0; }
int main(int argc, char **argv) { struct net_handle* file_ctx = NULL; struct timeval start,end; char rcv_buf[MAX_BUFSIZE]; if (argc < 3) { printf("usage:need argument ip_address port_num\n"); exit(-1); } int rvl=0; int port_num= strtoul(argv[2],NULL,0); zlog_init("./zlog.conf"); rvl = net_module_init(NULL); assert(!rvl); file_ctx = net_open(argv[1],port_num,4,16,SPK_DIR_WRITE,net_intf_tcp); if (!file_ctx) { printf("failed to open net\n"); rvl = SPKERR_BADRES; goto out; } rvl= net_intf_is_connected(file_ctx); if(!rvl) { printf("net is not connected!\n"); goto out; } uint64_t xfer=0; gettimeofday(&start, NULL); uint64_t total_count=0; while (1) { xfer = net_write(file_ctx, rcv_buf, MAX_BUFSIZE); if(xfer != MAX_BUFSIZE) { printf("send data error=>xfer:%ld\n",xfer); } else { // printf("write OK!\n"); } total_count++; gettimeofday(&end, NULL); float diff=(end.tv_sec-start.tv_sec)+(end.tv_usec - start.tv_usec)/1000000.0; if(diff > 5) { float speed=(total_count*MAX_BUFSIZE)/1024/diff; printf("time:%-15f s speed:%-15f KB/s\n",diff,speed); gettimeofday(&start, NULL); total_count=0; } } out: if (file_ctx) { net_close(file_ctx); file_ctx = NULL; } return rvl; }
int main(int argc, char *argv[]) { int rc = 0; int op; int quiet = 0; static const char *help = "useage: zlog-chk-conf [conf files]...\n" "\t-q,\tsuppress non-error message\n" "\t-h,\tshow help message\n" "zlog version: " ZLOG_VERSION "\n"; #ifndef _MSC_VER while((op = getopt(argc, argv, "qhv")) > 0) { if (op == 'h') { fputs(help, stdout); return 0; } else if (op == 'q') { quiet = 1; } } argc -= optind; argv += optind; #endif if (argc == 0) { fputs(help, stdout); return -1; } #ifdef _MSC_VER #define setenv(a,b,c) _putenv_s(a,b) #endif setenv("ZLOG_PROFILE_ERROR", "/dev/stderr", 1); setenv("ZLOG_CHECK_FORMAT_RULE", "1", 1); while (argc > 0) { rc = zlog_init(*argv); if (rc) { printf("\n---[%s] syntax error, see error message above\n", *argv); exit(2); } else { zlog_fini(); if (!quiet) { printf("--[%s] syntax right\n", *argv); } } argc--; argv++; } exit(0); }
void zlogInit(std::string path) { rc =zlog_init(path.c_str()); if (rc) { printf("init failed\n"); zlog_fini(); return; } zc = zlog_get_category("my_cat"); }
int log_init() { if(log) return 0; int flag=zlog_init("/data/zlog.conf"); if(flag!=0) return -1; log= zlog_get_category("my_cat"); if(!log) { zlog_fini(); return -2; } }
int logger_init(Logger *logger, int mode, const char *log_conf_path, const char *log_file_dir) { int rc; zlog_category_t *zc; logger->log_i = my_zlog_info; logger->log_d = my_zlog_debug; logger->log_e = my_zlog_error; int ret = make_config(log_conf_path, log_file_dir); if (ret < 0) { goto ERROR; } rc = zlog_init(log_conf_path); if (rc) { fprintf(stderr, "logger_init: zlog_init error\n"); goto ERROR; } if (mode == LOG_STDOUT) { zc = zlog_get_category("stdout"); } else if (mode == LOG_FILE) { zc = zlog_get_category("file"); } if (!zc) { fprintf(stderr, "logger_init: zlog_get_category error\n"); goto ERROR; } logger->zc = zc; logger->log_mode = mode; logger->log_on = 1; s_init_zlog_success = 1; return 0; ERROR: logger_destroy(logger); return -1; }
int main () { int state = zlog_init("../zlog.conf"); category = zlog_get_category("default"); zlog_info (category, "Server starts!"); init_server (&server); server.run (&server); while (1) { char c = getchar (); if (c == 'q') break; } destroy_server (&server); zlog_fini (); }
int main(int argc, char** argv) { int rc; int k; int i; if (argc != 2) { printf("test_leak ntime\n"); return -1; } rc = zlog_init("test_leak.conf"); k = atoi(argv[1]); while (k-- > 0) { i = rand(); switch (i % 4) { case 0: rc = dzlog_init("test_leak.conf", "xxx"); dzlog_info("init"); break; case 1: rc = zlog_reload(NULL); dzlog_info("reload null"); break; case 2: rc = zlog_reload("test_leak.2.conf"); dzlog_info("reload 2"); break; case 3: zlog_fini(); printf("fini\n"); // printf("zlog_finish\tj=[%d], rc=[%d]\n", j, rc); break; } } zlog_fini(); return 0; }
/* Architecture note: For the time being (as of early 2014, at least), * we're using libuv to handle asynchronous I/O stuff. It would be * lovely if we could "embed" libuv's event loop in the yield logic. * Unfortunately, libuv embedding is not totally solidified yet. So * we're going to have a separate thread for running the I/O event * loop. Eventually we should be able to get rid of that. * * ... On the other hand, having a separate thread for the event loop * means that we can do the heartbeat timer there and not have to worry * about signal handling junk. Seems like that might be a nicer way to * go for many systems. In the long term, probably should support * both. */ int main( int argc, char **argv, char **env ) { /* Okay to stack-allocate these here because the I/O thread should * always be the last thing running in a Charcoal process. * TODO: Document why we need these for the I/O thread */ int rc; if( ( rc = zlog_init( zlog_config_full_filename ) ) ) { return -1; } if( !( crcl(c) = zlog_get_category( "main_cat" ) ) ) { zlog_error( crcl(c), "Failure: Missing logging category\n" ); zlog_fini(); return -2; } __argc = argc; __argv = argv; __env = env; if( ( rc = crcl(init_io_loop)( start_application_main ) ) ) { zlog_error( crcl(c), "Failure: Initialization of the I/O loop: %d\n", rc ); return rc; } if( ( rc = uv_run( crcl(evt_loop), UV_RUN_DEFAULT ) ) ) { zlog_error( crcl(c), "Failure: Running the I/O loop: %d", rc ); return rc; } zlog_info( crcl(c), "switch cnt: %ld", crcl(switch_cnt) ); zlog_info( crcl(c), "Charcoal application finished. Exit code: %d", crcl(process_exit_code) ); zlog_fini(); return crcl(process_exit_code); }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_init.conf"); if (rc) { printf("init fail"); return -2; } zc = zlog_get_category("my_cat"); if (!zc) { printf("zlog_get_category fail\n"); zlog_fini(); return -1; } ZLOG_INFO(zc, "before update"); sleep(3); rc = zlog_reload("test_init.2.conf"); if (rc) { printf("update fail\n"); } ZLOG_INFO(zc, "after update"); zlog_profile(); zlog_fini(); return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; rc = zlog_init("test_hello.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } ZLOG_INFO(zc, "hello, zlog"); zlog_fini(); return 0; }
int log_init(const char * conf_path) { int rc; if (!conf_path) { printf("conf_path is null\n"); return -1; } rc = zlog_init(conf_path); if (rc) { printf("init failed[%s]\n", conf_path); return -1; } g_logger = zlog_get_category("my_cat"); if (!g_logger) { printf("get cat fail\n"); zlog_fini(); return -2; } return 0; }
int main(int argc, char **argv) { int rvl = 0; int i; zlog_init("./zlog.conf"); rvl = ips_module_init(NULL); assert(!rvl); rvl = idt_module_init(NULL); assert(!rvl); // channel 0 link_desc_tbl[0].mst_id = IPS_MAKE_EPID(IPS_EPMODE_MASTER, 0, 0x0); link_desc_tbl[0].slv_id = IPS_MAKE_EPID(IPS_EPMODE_SLAVE, 0, 0x0); link_desc_tbl[0].mst_port = 6; link_desc_tbl[0].slv_port = 1; link_desc_tbl[0].is_master = 0; if (PIPE_NUM == 2) { link_desc_tbl[1].mst_id = IPS_MAKE_EPID(IPS_EPMODE_MASTER, 0, 0x1); link_desc_tbl[1].slv_id = IPS_MAKE_EPID(IPS_EPMODE_SLAVE, 0, 0x1); link_desc_tbl[1].mst_port = 3; link_desc_tbl[1].slv_port = 4; link_desc_tbl[0].is_master = 0; } pthread_barrier_init(&barrier, NULL, PIPE_NUM); sync_cnt = 0; pthread_mutex_init(&sync_cnt_lock, NULL); int idt_fd = idt_dev_open(2, 0x67); assert(idt_fd > 0); for(i=0; i<PIPE_NUM; i++){ ips_linkdesc_t* desc = &link_desc_tbl[i]; if (desc->is_master) { assert(0); } else { // reset link partner idt_port_recovery(idt_fd, desc->mst_port); // set routetbl entries idt_routetbl_set(idt_fd, desc->mst_port, desc->slv_id, desc->slv_port); idt_routetbl_set(idt_fd, desc->slv_port, desc->mst_id, desc->mst_port); } } idt_dev_close(idt_fd); //init ips mode parse_ips_mode_ini(); ips_init_mode(test_ips_mode); for(int pipe=0; pipe<PIPE_NUM; pipe++) { ips_epdesc_t epdesc; memset(&epdesc, 0, sizeof(ips_epdesc_t)); epdesc.capacity = 0; epdesc.pc_num = 1; for (i = 0; i < epdesc.pc_num; i++) { ips_pcdesc_t* pcdesc = &epdesc.pcdesc_tbl[i]; pcdesc->dest_id = link_desc_tbl[pipe].mst_id; pcdesc->capacity = epdesc.capacity; } rvl = ips_ep_init(link_desc_tbl[pipe].slv_id, &epdesc); assert(rvl == 0); for (i = 0; i < epdesc.pc_num; i++) { thread_args_t* args = malloc(sizeof(thread_args_t)); args->epid = link_desc_tbl[pipe].slv_id; args->pc_id = i; args->wkr_id = pipe; rvl = pthread_create(&wkr[pipe], NULL, __worker_slave, args); assert(!rvl); } } while(1) { for(int pipe=0; pipe<PIPE_NUM; pipe++) { pthread_join(wkr[pipe], NULL); } }; return 0; }
int main(int argc, char** argv) { int rc; zlog_category_t *zc; int i = 0; struct stat stat_0, stat_1; /* Create the logging directory if not yet ceated */ mkdir("./test_multithread-logs", 0777); if (stat(CONFIG, &stat_0)) { printf("Configuration file not found\n"); return -1; } rc = zlog_init(CONFIG); if (rc) { printf("main init failed\n"); return -2; } zc = zlog_get_category("main"); if (!zc) { printf("main get cat fail\n"); zlog_fini(); return -3; } /* Interrupt (ANSI). <Ctrl-C> */ if (signal(SIGINT, intercept) == SIG_IGN ) { zlog_fatal(zc, "Can't caught the signal SIGINT, Interrupt (ANSI)"); signal(SIGINT, SIG_IGN ); return -4; } // start threads tinfo = calloc(NB_THREADS, sizeof(struct thread_info)); for (i=0; i<NB_THREADS; i++) { tinfo[i].thread_num = i + 1; tinfo[i].loop = 0; if(pthread_create(&tinfo[i].thread_id, NULL, myThread, &tinfo[i]) != 0) { zlog_fatal(zc, "Unable to start thread %d", i); zlog_fini(); return(-5); } } /* Wait and log thread informations */ sleep(1); for (i=0; i<NB_THREADS; i++) { zlog_info(zc, "Thread [%d], zlog_category:@%p", tinfo[i].thread_num, tinfo[i].zc); } /* Log main loop status */ i=0; while(1) { int reload; sleep(1); i++; zlog_info(zc, "Running time: %02d:%02d:%02d", i/3600, (i/60)%60, i%60); /* Check configuration file update */ stat(CONFIG, &stat_1); /* Is configuration file modified */ reload = (stat_0.st_mtime != stat_1.st_mtime); /* Or do we want to reload periodicaly the configuration file */ if ( ! reload) if ( RELOAD_DELAY > 0) reload = (i % RELOAD_DELAY == 0); if (reload) { zlog_info(zc, "Will reload configuration..."); rc = zlog_reload(CONFIG); if (rc) { printf("main init failed\n"); return -6; } zlog_info(zc, "Configuration reloaded :)"); stat(CONFIG, &stat_0); } } exit(EXIT_SUCCESS); }
int main(int argc, char** argv) { int rc; pid_t pid; //注册信号 (void)signal(TFTP_SIGNAL, Tftp_Sig); //初始化缓存队列 queue_init(&coapMsgQ, free); //初始化信号量,初始值为0 rc = sem_init(&msgQSem, 0, 0); if(rc == -1) { printf("init msgQSem error!\r\n"); exit(-1); } //初始化互斥量 rc = pthread_mutex_init(&msgQ_mutex, NULL); if(rc != 0) { printf("msgQ_mutex init error!\r\n"); exit(-1); } //打开数据库 Open_db("CoapMsg.db", &db); rc = zlog_init("log.conf"); if (rc) { printf("init failed\n"); return -1; } zc = zlog_get_category("my_cat"); if (!zc) { printf("get cat fail\n"); zlog_fini(); return -2; } zlog_info(zc, "Start!"); zlog_info(zc, "Uart_Init!"); //初始化串口 Uart_Init(115200); //创建串口读取数据线程 rc = pthread_create(&uartRd_Thread, NULL, Uart_ReadThread, NULL); if(0!=rc) { zlog_error(zc, "uartRd_Thread create error!"); exit(-1); } else { zlog_debug(zc, "uartRd_Thread create success!"); } //创建分发数据线程 rc = pthread_create(&transMsg_Thread, NULL, TransMsgThread, NULL); if(0!=rc) { zlog_error(zc, "TransMsgThread create error!"); exit(-1); } else { zlog_debug(zc, "TransMsgThread create success!"); } //初始化链表 list_init( &iplist, free); zlog_debug(zc, "list_init success!"); //创建tftp Server进程 pid = fork(); if(pid == 0) { printf("enter tftp server,pid = %d\r\n", getpid()); zlog_debug(zc, "enter tftp server,pid = %d", getpid()); tftpd_init(NULL); } else if(pid<0) { printf("create tftp server process error!\r\n"); zlog_error(zc, "create tftp server process error!"); } else if(pid > 0) { //记录tftp子进程的pid tftp_pid = pid; } //创建coapclient任务 CreatCoapclient(&iplist); //创建coap Server进程 pid = fork(); if(pid == 0) { printf("enter coap server,pid = %d\r\n", getpid()); zlog_debug(zc, "enter coap server,pid = %d", getpid()); CoapServ(NULL); } else if(pid<0) { printf("create coap server process error!\r\n"); zlog_error(zc, "create coap server process error!"); } else if(pid > 0) { //记录coap server子进程的pid coap_serv_pid = pid; } while(1) { sleep(1); } return 0; }
int main(int argc, char **argv) { int ret; int i; char msg_ibuf[CMI_MAX_MSGSIZE]; umask(022); // build assert assert(DFV_MAX_SLOTS == CMI_MAX_SLOTS); assert(IPS_MAX_FCNUM == CMI_MAX_FCNUM); assert(!(SYS_CACHE_SIZE % CMI_MAX_FRAGSIZE)); printf("\n"); printf("SSSSSSSSSS\n"); printf("SSSSSSSSSS\n"); printf("SSS SSS PPPPP AA RRRRR KK KK\n"); printf("SS SS SS PP PP AAAA RR RR KK KK\n"); printf("SS SSSSSS PP PP AA AA RR RR KK KK\n"); printf("SSS SSSSS PP PP AA AA RR RR KK KK\n"); printf("SSSS SSSS PPPPP AA AA RRRRR KKKK\n"); printf("SSSSS SSS PP AAAAAA RR RR KK KK\n"); printf("SSSSSS SS PP AA AA RR RR KK KK\n"); printf("SS SS SS PP AA AA RR RR KK KK\n"); printf("SSS SSS PP AA AA RR RR KK KK\n"); printf("SSSSSSSSSS \n"); printf("SSSSSSSSSS ==SYS: LK ==VER: %s\n", SYS_VERSION); printf("\n"); // initialize log system zlog_init("./zlog.conf"); sys_zc = zlog_get_category("SYS"); assert(sys_zc); zlog_notice(sys_zc, "------------------------------------------"); zlog_notice(sys_zc, "==> system starting ..."); zlog_notice(sys_zc, "==> dump system versions ..."); zlog_notice(sys_zc, " SYS: %s", SYS_VERSION); zlog_notice(sys_zc, " IPS: %s", IPS_MOD_VER); zlog_notice(sys_zc, " DFV: %s", DFV_MOD_VER); zlog_notice(sys_zc, " IDT: %s", IDT_MOD_VER); zlog_notice(sys_zc, " CMI: %s", CMI_MOD_VER); // initialize env // TBD: should be read from .conf zlog_notice(sys_zc, "> loading conf ..."); memset(&sys_env, 0, sizeof(sys_env)); sys_env.features = SYSFEA_USE_LOCALSTATS; sys_env.intf_type = cmi_intf_tcp; sys_env.endian = cmi_endian_auto; sys_env.ipaddr = NULL; sys_env.port = 1235; sys_env.dfv_desc_tbl[0].mnt_path = "sdb"; sys_env.dfv_desc_tbl[0].dev_path = "sdb"; sys_env.dfv_desc_tbl[0].flag = 0; sys_env.dfv_desc_tbl[1].mnt_path = "sdf"; sys_env.dfv_desc_tbl[1].dev_path = "sdf"; sys_env.dfv_desc_tbl[1].flag = 0; sys_env.ips_linkdesc_tbl[0].mst_id = IPS_MAKE_EPID(IPS_EPMODE_MASTER, 0, 0); sys_env.ips_linkdesc_tbl[0].slv_id = IPS_MAKE_EPID(IPS_EPMODE_SLAVE, 0, 0); sys_env.ips_linkdesc_tbl[0].mst_port = 1; sys_env.ips_linkdesc_tbl[0].slv_port = 6; sys_env.ips_linkdesc_tbl[0].is_master = 1; sys_env.ips_linkdesc_tbl[1].mst_id = IPS_MAKE_EPID(IPS_EPMODE_MASTER, 0, 1); sys_env.ips_linkdesc_tbl[1].slv_id = IPS_MAKE_EPID(IPS_EPMODE_SLAVE, 0, 1); sys_env.ips_linkdesc_tbl[1].mst_port = 4; sys_env.ips_linkdesc_tbl[1].slv_port = 3; sys_env.ips_linkdesc_tbl[1].is_master = 1; assert(sys_env.ips_linkdesc_tbl[0].is_master); // I am master assert(sys_env.ips_linkdesc_tbl[1].is_master); // I am master sys_env.ips_desc_tbl[0].capacity = 0; sys_env.ips_desc_tbl[0].pc_num = 1; for (i = 0; i < 1; i++) { ips_pcdesc_t* pcdesc = &sys_env.ips_desc_tbl[0].pcdesc_tbl[i]; pcdesc->src_id = sys_env.ips_linkdesc_tbl[0].mst_id; pcdesc->dest_id = sys_env.ips_linkdesc_tbl[0].slv_id; pcdesc->sector_sz = IPS_CLS_SECTOR_SIZE; pcdesc->sector_num = IPS_CLS_SECTOR_NUM; } sys_env.ips_desc_tbl[1].capacity = 0; sys_env.ips_desc_tbl[1].pc_num = 1; for (i = 0; i < 1; i++) { ips_pcdesc_t* pcdesc = &sys_env.ips_desc_tbl[1].pcdesc_tbl[i]; pcdesc->src_id = sys_env.ips_linkdesc_tbl[1].mst_id; pcdesc->dest_id = sys_env.ips_linkdesc_tbl[1].slv_id; pcdesc->sector_sz = IPS_CLS_SECTOR_SIZE; pcdesc->sector_num = IPS_CLS_SECTOR_NUM; } // initialize each module zlog_notice(sys_zc, "==> initializing modules ..."); #ifdef ARCH_ppc64 ret = ips_module_init(NULL); assert(!ret); ret = idt_module_init(NULL); assert(!ret); #endif ret = dfv_module_init(NULL); assert(!ret); ret = cmi_module_init(NULL); assert(!ret); //init ips mode syslk_parse_ips_mode("./syslk_ips.conf"); ips_init_mode(syslk_ips_mode); zlog_notice(sys_zc,"dma_use_nlwr:%d dma_use_chain:%d tx_wmd:%d tx_rmd:%d rx_wmd:%d rx_rmd:%d", syslk_ips_mode.dma_use_nlwr, syslk_ips_mode.dma_use_chain, syslk_ips_mode.tx.use_wptr, syslk_ips_mode.tx.use_rptr, syslk_ips_mode.rx.use_wptr, syslk_ips_mode.rx.use_rptr); // initialize ctxs memset(&sys_ctx, 0, sizeof(sys_ctx)); zlog_notice(sys_zc, "==> initializing storage ..."); const char* repo_mnt_tbl[DFV_MAX_REPOS] = {NULL}; const char* repo_dev_tbl[DFV_MAX_REPOS] = {NULL}; for (i=0; i<SYS_MAX_PIPES; i++) { repo_mnt_tbl[i] = sys_env.dfv_desc_tbl[i].mnt_path; repo_dev_tbl[i] = sys_env.dfv_desc_tbl[i].dev_path; } sys_ctx.vault = dfv_vault_open(SYS_MAX_PIPES, DFV_SLICE_NUM, repo_mnt_tbl, repo_dev_tbl, 0); if (!sys_ctx.vault) { zlog_fatal(sys_zc, "failed to initializing storage, quit"); exit(-1); } sys_ctx.diskcap = dfv_vault_get_diskcap(sys_ctx.vault); // check freeslot int slot_id = dfv_vault_get_freeslot(sys_ctx.vault); if (slot_id < 0) { zlog_fatal(sys_zc, "no spece left on vault, quit"); exit(-1); } #ifdef ARCH_ppc64 zlog_notice(sys_zc, "==> initializing switch route table ..."); int idt_fd = idt_dev_open(2, 0x67); assert(idt_fd > 0); for (i=0; i<SYS_MAX_PIPES; i++) { ips_linkdesc_t* linkdesc = &sys_env.ips_linkdesc_tbl[i]; // reset link parnter // idt_port_recovery(idt_fd, linkdesc->slv_port); // reset routetbl entries idt_routetbl_set(idt_fd, linkdesc->mst_port, linkdesc->slv_id, linkdesc->slv_port); idt_routetbl_set(idt_fd, linkdesc->slv_port, linkdesc->mst_id, linkdesc->mst_port); } idt_dev_close(idt_fd); zlog_notice(sys_zc, "==> initializing srio ..."); for (i=0; i<SYS_MAX_PIPES; i++) { // init repo zlog_notice(sys_zc, " initializing ips_srio: pipe=%d, id=0x%x", i, sys_env.ips_linkdesc_tbl[i].mst_id); ret = ips_ep_init(sys_env.ips_linkdesc_tbl[i].mst_id, &sys_env.ips_desc_tbl[i]); assert(!ret); } #endif sys_ctx.file_cache = malloc(sizeof(sys_cache_t)); assert(sys_ctx.file_cache); memset(sys_ctx.file_cache, 0, sizeof(sys_cache_t)); sys_ctx.file_cache->slot_id = -1; sys_ctx.file_cache->data = malloc(SYS_CACHE_SIZE); assert(sys_ctx.file_cache->data); zlog_notice(sys_zc, "==> initializing job workers ..."); for (i=0; i<SYS_MAX_PIPES; i++) { sys_wkr_ctx_t* wkr_ctx = malloc(sizeof(sys_wkr_ctx_t)); assert(wkr_ctx); memset(wkr_ctx, 0, sizeof(sys_wkr_ctx_t)); wkr_ctx->wkr_state = sys_state_idle; wkr_ctx->wkr_id = i; pthread_mutex_init(&wkr_ctx->buf_snap_lock, NULL); sys_jobq_init(&wkr_ctx->job_in); sys_jobq_init(&wkr_ctx->job_out); wkr_ctx->wkr_thread = malloc(sizeof(pthread_t)); assert(wkr_ctx->wkr_thread); sys_ctx.wkr_ctx_tbl[i] = wkr_ctx; pthread_create(wkr_ctx->wkr_thread, NULL, __sys_wkr_job, (void*)wkr_ctx); } sys_ctx.auto_rec = 0; if (sys_ctx.auto_rec) { pthread_t thread_autorec; pthread_create(&thread_autorec, NULL, __sys_wkr_autorec, NULL); } RECONN: zlog_notice(sys_zc, "==> ---------- SERVER START ----------"); // stop all workers for (i=0; i<SYS_MAX_PIPES; i++) { sys_wkr_ctx_t* wkr_ctx = sys_ctx.wkr_ctx_tbl[i]; if (wkr_ctx->wkr_state != sys_state_idle) { zlog_notice(sys_zc, "==> stopping job worker#%d ...", i); wkr_ctx->reset_req = 1; while(wkr_ctx->wkr_state != sys_state_idle) { usleep(100); } } } sys_cmd_exec_stopul(NULL); if (sys_ctx.cmi_intf) { zlog_notice(sys_zc, "==> closing client cmi ..."); cmi_intf_close(sys_ctx.cmi_intf); sys_ctx.cmi_intf = NULL; } if (sys_ctx.sysdown_req) { goto out; } // open cmi zlog_notice(sys_zc, "==> opening client cmi ..."); sys_ctx.cmi_intf = cmi_intf_open(cmi_type_server, sys_env.intf_type, sys_env.endian); if (!sys_ctx.cmi_intf) { assert(0); exit(-1); } zlog_notice(sys_zc, "==> connecting client cmi ..."); ret = cmi_intf_connect(sys_ctx.cmi_intf, sys_env.ipaddr, sys_env.port); if (ret != SPK_SUCCESS) { assert(0); exit(-1); } while(1) { // main loop // update sys_state if (!sys_ctx.auto_rec) { // some jobs are done by job workers // we do not known when they finished // so we inquiry workers state in some states switch(sys_ctx.sys_state) { case sys_state_rec: case sys_state_play: case sys_state_dl: case sys_state_format: { int all_idle = 1; for (int i=0; i<SYS_MAX_PIPES; i++) { sys_wkr_ctx_t* wkr_ctx = sys_ctx.wkr_ctx_tbl[i]; if (wkr_ctx && wkr_ctx->wkr_state != sys_state_idle) { all_idle = 0; } } if (all_idle) { sys_change_state(sys_state_idle); } } break; } } // get message from cmi ssize_t msg_size = cmi_intf_read_msg(sys_ctx.cmi_intf, msg_ibuf, CMI_MAX_MSGSIZE); if (msg_size < 0) { zlog_warn(sys_zc, "failed to read from socket: ret=%ld", msg_size); goto RECONN; } if (msg_size == 0) { usleep(100); continue; } // msg arrived // cmi_msg_dump(ZLOG_LEVEL_NOTICE, msg_ibuf, msg_size); // zlog_notice(sys_zc, "> read msg: code=0x%x, size=%ld", MSG_CODE(msg_ibuf), msg_size); // notify auto_rec_thread() to quit sys_ctx.auto_rec = 0; ret = SPK_SUCCESS; // parse msg switch(MSG_CODE(msg_ibuf)) { case msg_code_cmd: ret = sys_cmd_exec((cmi_cmd_t*)msg_ibuf, msg_size); break; case msg_code_data: ret = sys_msg_parse_data((cmi_data_t*)msg_ibuf, msg_size); break; case msg_code_cmdresp: case msg_code_status: default: // impossible assert(0); break; } if (ret == SPKERR_RESETSYS) { zlog_warn(sys_zc, "socket error, restart"); goto RECONN; } if (sys_ctx.sysdown_req) { zlog_notice(sys_zc, "################# SYSTEM SHUTDOWN"); spk_os_exec("poweroff"); goto RECONN; } // TODO: other ret code } out: for (i=0; i<SYS_MAX_PIPES; i++) { sys_wkr_ctx_t* wkr_ctx = sys_ctx.wkr_ctx_tbl[i]; if (wkr_ctx) { wkr_ctx->quit_req = 1; pthread_join(*wkr_ctx->wkr_thread, NULL); SAFE_RELEASE(wkr_ctx->wkr_thread); SAFE_RELEASE(wkr_ctx); } } return 0; }
int log_init() { return (zlog_init(LOG_CONFIG_FILE)); }
void logger_init(const char * filename, const char * category) { if (strlen(filename) && strlen(category)) { massert(!zlog_init(filename), "Can not initialize logger"); sensey_logger = zlog_get_category(category); } }
int main(void) { int l_init = 0; l_init = zlog_init("/etc/zlog.conf"); if (l_init) { printf("logging init failed"); return -1; } c = zlog_get_category("hngui"); if (!c) { printf("Logging init (category) fail\n"); return -1; } zlog_info(c, "Program starting... "); DIR *d; struct dirent *dir; d = opendir("/var/tmp"); if (d) { while ((dir = readdir(d)) != NULL) { zlog_info(c, "%s", dir->d_name); } closedir(d); } zlog_info(c, "Created Tree From Sample Text.."); SetExpansionState(tree, TRUE); LogPrintTree(c, tree, PRINT_ONLY_EXPANDED_NODES); zlog_info(c, "Tree Size: %d\n", TotalSize(tree)); initscr(); mousemask(ALL_MOUSE_EVENTS, NULL); cbreak(); noecho(); nonl(); curs_set(0); keypad(stdscr, TRUE); start_color(); curs_set(0); init_pair(1, COLOR_YELLOW, COLOR_BLACK); init_pair(2, COLOR_RED, COLOR_BLACK); init_pair(3, COLOR_YELLOW, COLOR_BLUE); init_pair(4, COLOR_RED, COLOR_BLUE); int startx, starty, width, height; height = LINES - 2; width = COLS - 2; starty = (LINES - height) / 4; /* Calculating for a center placement */ startx = (COLS - width) / 2; /* of */ refresh(); win = create_newwin(height, width, starty, startx); if (win == NULL) { zlog_info(c, "Window Was null...\n"); endwin(); printf("Window was null??\n"); return -1; } zlog_info(c, "Rendering Tree into window %p \n", win); RenderTreeIntoWindow(tree); refresh(); wrefresh(win); int ch; while ((ch = getch()) != KEY_F(4)) { zlog_info(c, "Trapped Keypress %d", ch ); MEVENT event; switch (ch) { case KEY_RESIZE: zlog_info(c, "Resize()"); RenderTreeIntoWindow(tree); refresh(); wrefresh(win); break; case KEY_F(3): zlog_info(c, "F3=> Refresh"); RefreshData(); break; case KEY_LEFT: zlog_info(c, "Left key"); toggleExpand(win, false); break; case KEY_RIGHT: zlog_info(c, "Right key"); toggleExpand(win, true); break; case KEY_UP: zlog_info(c, "Up Key"); moveUp(win); break; case KEY_DOWN: zlog_info(c, "Down Key"); moveDown(win); break; } if (getmouse(&event) == OK) { zlog_info(c, "Mouse => %d, %d", event.x, event.y); } //LogPrintTree(c, tree, PRINT_ALL_TREE); } endwin(); return 0; }