// main program - initialize, then send to proper function int main (int argc, char **argv) { CubitStatus status = InitCGMA::initialize_cgma("OCC"); if (CUBIT_SUCCESS != status) return 1; //Do make point. status = make_Point(); if (status == CUBIT_FAILURE) PRINT_INFO("Operation Failed"); int ret_val = ( CubitMessage::instance()->error_count() ); if ( ret_val > 0 ) { PRINT_ERROR("Errors found during Mergechk session.\n"); } return ret_val; }
int s_arm_t::kick(int speed) { PRINT_INFO("KICK %d\n", speed); add_command(1, 0000, 50, 100); add_command(2, 0000, 90, 100); add_command(0, 1000, 45, 100); add_command(0, 3000, 45, speed); // add_command(2, 4100, 80, speed); add_command(1, 3100, 85, speed); add_command(2, 5000, 40, 100); add_command(2, 7000, 90, 100); add_command(1, 7000, 50, 100); add_command(0, 8000, 45, 100); return 0; }
static int put_mod(mod_record_t* mod_record) { int ret = 0; unsigned long flags; PRINT_INFO("put mod %s\n", mod_record->name); spin_lock_irqsave(&mod_lock, flags); if (mod_record->no_share) ret = _switch_gate(mod_record->type, 0); else { mod_record->ref--; if(mod_record->ref <= 0) { ret = _switch_gate(mod_record->type, 0); mod_record->ref = 0; mod_record->flag = 0; } } spin_unlock_irqrestore(&mod_lock, flags); return ret; }
long bmd_set_ctx_fileInMem( GenBuf_t *file_buf, char *pass, long passlen, bmd_crypt_ctx_t **ctx) { PRINT_INFO("LIBBMDPKIINF Setting ctx file from mem\n"); if( file_buf == NULL ) { BMD_FOK(BMD_ERR_PARAM1); } if( file_buf->buf == NULL ) { BMD_FOK(BMD_ERR_PARAM1); } if( ( passlen != 0 ) && ( pass == NULL ) ) { BMD_FOK(BMD_ERR_PARAM2); } if( (passlen == 0 ) && ( pass != NULL ) ) { BMD_FOK(BMD_ERR_PARAM3); } if( ctx == NULL ) { BMD_FOK(BMD_ERR_PARAM4); } if( (*ctx) != NULL ) { BMD_FOK(BMD_ERR_PARAM4); } BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_FILE,BMD_CTX_TYPE_ASYM)); BMD_FOK(bmd_parse_p12_fileInMem(file_buf,pass,passlen,&((*ctx)->file->publicKey),&((*ctx)->file->privateKey),&((*ctx)->file->cert))); return BMD_OK; }
/* ustawia kontekst z PKCS#11 - laduje biblioteke, inicjalizuje, pobiera wszystkie certyfikaty z kart jesli opcja auto_load jest ustawiona (BMD_PKCS11_AUTO_LOAD_CERT) */ long bmd_set_ctx_pkcs11 (bmd_crypt_ctx_t **ctx, char *pkcs11_library, long ctx_type, long auto_load, BmdCtxPkcs11Option_e ctx_option) { PRINT_INFO("LIBBMDPKIINF Setting ctx pkcs11\n"); if(ctx==NULL) { BMD_FOK(BMD_ERR_PARAM1); } if((*ctx)!=NULL) { BMD_FOK(BMD_ERR_PARAM1); } if(pkcs11_library==NULL){ BMD_FOK(BMD_ERR_PARAM2); } if( (auto_load!=BMD_PKCS11_AUTO_LOAD_CERT) && (auto_load!=0) ) { BMD_FOK(BMD_ERR_PARAM4); } BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_PKCS11,ctx_type)); BMD_FOK(bmd_pkcs11_init(pkcs11_library,(*ctx)->pkcs11)); if(auto_load==BMD_PKCS11_AUTO_LOAD_CERT) { BMD_FOK(bmd_pkcs11_get_all_certs((*ctx)->pkcs11,&((*ctx)->pkcs11->all_certs))); } // sprawdzenie poprawnosci podanej opji // BMD_CTX_PKCS11_OPTION_DEFAULT i BMD_CTX_PKCS11_OPTION_DEDBS wzajemnie sie wykluczaja if(ctx_option != BMD_CTX_PKCS11_OPTION_DEFAULT && ctx_option != BMD_CTX_PKCS11_OPTION_DEDBS) { BMD_FOK(BMD_ERR_PARAM5); } if(ctx_option & BMD_CTX_PKCS11_OPTION_DEFAULT) { (*ctx)->pkcs11->dontEstimateDecryptBufferSize = 0; } if(ctx_option & BMD_CTX_PKCS11_OPTION_DEDBS) { (*ctx)->pkcs11->dontEstimateDecryptBufferSize = 1; } return BMD_OK; }
double GetXPDF(const kf_code& kf, bool anti) { if (m_x>m_xmax) return 0.; if (!(m_x>=0.0 && m_x<=1.0)) { PRINT_INFO("PDF called with x="<<m_x); return 0.; } int cteqindex; switch (kf) { case kf_gluon: cteqindex=0; break; case kf_d: cteqindex=m_anti*(anti?-2:2); break; case kf_u: cteqindex=m_anti*(anti?-1:1); break; default: cteqindex=m_anti*(anti?-kf:kf); break; } if (!m_calculated[5-cteqindex]) { m_f[5-cteqindex]=ct10pdf_(cteqindex,m_x,m_Q)*m_x; m_calculated[5-cteqindex]=true; } return m_rescale*m_f[5-cteqindex]; }
double GetXPDF(const ATOOLS::Flavour& infl) { if (m_x>m_xmax || m_rescale<0.) return 0.; if (!(m_x>=0.0 && m_x<=1.0)) { PRINT_INFO("PDF called with x="<<m_x); return 0.; } int cteqindex; switch (infl.Kfcode()) { case kf_gluon: cteqindex=0; break; case kf_d: cteqindex=m_anti*int(infl)*2; break; case kf_u: cteqindex=m_anti*int(infl)/2; break; default: cteqindex=m_anti*int(infl); break; } if (!m_calculated[5-cteqindex]) { m_f[5-cteqindex]=ct10pdf_(cteqindex,m_x,m_Q)*m_x; m_calculated[5-cteqindex]=true; } return m_rescale*m_f[5-cteqindex]; }
static void modisk_set_block_shift(struct scst_cmd *cmd, int block_shift) { struct scst_device *dev = cmd->dev; int new_block_shift; /* * No need for locks here, since *_detach() can not be * called, when there are existing commands. */ new_block_shift = block_shift ? : MODISK_DEF_BLOCK_SHIFT; if (dev->block_shift != new_block_shift) { PRINT_INFO("%s: Changed block shift from %d into %d / %d", dev->virt_name, dev->block_shift, block_shift, new_block_shift); dev->block_shift = new_block_shift; dev->block_size = 1 << dev->block_shift; } return; }
/** * @brief sends certain Configuration Packet based on the input WIDs pstrWIDs * using driver config layer * * @details * @param[in] pstrWIDs WIDs to be sent in the configuration packet * @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet * @param[out] pu8RxResp The received Packet Response * @param[out] ps32RxRespLen Length of the received Packet Response * @return Error code indicating success/failure * @note * @author mabubakr * @date 1 Mar 2012 * @version 1.0 */ s32 send_config_pkt(u8 mode, struct wid *wids, u32 count, u32 drv) { s32 counter = 0, ret = 0; if (mode == GET_CFG) { for (counter = 0; counter < count; counter++) { PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter, (counter == count - 1)); if (!wilc_wlan_cfg_get(!counter, wids[counter].id, (counter == count - 1), drv)) { ret = -1; printk("[Sendconfigpkt]Get Timed out\n"); break; } } counter = 0; for (counter = 0; counter < count; counter++) { wids[counter].size = wilc_wlan_cfg_get_val( wids[counter].id, wids[counter].val, wids[counter].size); } } else if (mode == SET_CFG) { for (counter = 0; counter < count; counter++) { PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", wids[counter].id); if (!wilc_wlan_cfg_set(!counter, wids[counter].id, wids[counter].val, wids[counter].size, (counter == count - 1), drv)) { ret = -1; printk("[Sendconfigpkt]Set Timed out\n"); break; } } } return ret; }
// main program - initialize, then send to proper function int main (int argc, char **argv) { // Start up CGM CubitStatus status = InitCGMA::initialize_cgma("ACIS"); if (CUBIT_SUCCESS != status) return 1; //Do hollow operation to make thick body. status = hollow(); if (status == CUBIT_FAILURE) PRINT_INFO("Operation Failed"); int ret_val = ( CubitMessage::instance()->error_count() ); if ( ret_val > 0 ) { PRINT_ERROR("Errors found during Mergechk session.\n"); } return ret_val; }
/* * Resume execution after an external function call */ int XTIER_inject_resume_module_execution(struct kvm_vcpu *vcpu) { struct timespec begin; // Did the function return? if(kvm_rip_read(vcpu) == _XTIER_inject.external_function_return_rip) { // Take time // Since the execution is still running we do not use starttime! XTIER_inject_begin_time_measurement(&begin); PRINT_INFO("External function returned. Execution of the injected module will be resumed!\n"); PRINT_DEBUG("EIP: 0x%lx, RSP: 0x%lx, CR3: 0x%lx\n", kvm_rip_read(vcpu), kvm_register_read(vcpu, VCPU_REGS_RSP), kvm_read_cr3(vcpu)); // Make the module accessible again XTIER_memory_reallow_access(vcpu); // Restore RIP kvm_rip_write(vcpu, _XTIER_inject.external_function_return_rip); _XTIER_inject.external_function_return_rip = 0; // Set HALT Exiting XTIER_enable_hlt_exiting(); // Set Exception Exiting XTIER_enable_interrupt_exiting(vcpu); // Take time XTIER_inject_end_time_measurement(&begin, &_XTIER_performance.total_module_temp_resume_time); // Return but do not update RIP return 2; } else { PRINT_WARNING("External function tried to access the protected memory area @ 0x%lx!\n Malware?\n", kvm_rip_read(vcpu)); return 0; } return 0; }
static int get_mod(mod_record_t* mod_record) { int ret = 0; unsigned long flags; PRINT_INFO("get mod %s\n", mod_record->name); spin_lock_irqsave(&mod_lock, flags); if (mod_record->no_share) ret = _switch_gate(mod_record->type, 1); else { if(mod_record->ref > 0) mod_record->ref++; else { mod_record->ref = 1; mod_record->flag = 1; ret = _switch_gate(mod_record->type, 1); } } spin_unlock_irqrestore(&mod_lock, flags); return ret; }
static void backlight_power_ctrl(Bool_t status) { PRINT_INFO("%s(): bl_status=%s, data_status=%s, bl_level=%u\n", __FUNCTION__, (bl_status ? "ON" : "OFF"), (data_status ? "ON" : "OFF"), bl_level); if( status == ON ){ if ((data_status == OFF) || (bl_status == ON)) return; if (bl_level == 0) { bl_status = status; return; } _power_on_backlight(); } else{ if (bl_status == OFF) return; _power_off_backlight(); } bl_status = status; printk(KERN_INFO "%s() Power %s\n", __FUNCTION__, (status ? "ON" : "OFF")); }
void msw_exit(void) { unsigned long l_RetCode = C_AMSW_REJ; amu_go = FALSE; PRINT_INFO("msw_exit\n"); if (!GlobalRemove) { board_disable_intrs(); // disable interrupts before disabling the driver l_RetCode = AMSW_ANT_requestModemStateChange(C_AMSW_IDLE); PRINT_ERROR("Modem going to IDLE\n"); if (l_RetCode != C_AMSW_ACK) PRINT_ERROR("AMSW_ANT_requestModemStateChange(C_AMSW_IDLE) error!\n", l_RetCode); } else { g_ModemState = C_AMSW_IDLE; } AMSW_Modem_SW_Exit(); }
// main program - initialize, then send to proper function int main (int argc, char **argv) { CubitStatus s = InitCGMA::initialize_cgma( ENGINE ); if (CUBIT_SUCCESS != s) return 1; //Do tests. int rsl = CreateGeometry(); if (rsl == 1) PRINT_INFO("Operation Failed"); int ret_val = ( CubitMessage::instance()->error_count() ); if ( ret_val != 0 ) { PRINT_ERROR("Errors found during Mergechk session.\n"); } else ret_val = 0; return ret_val; }
static void sprd_kpled_set_brightness( unsigned long brightness) { unsigned long brightness_level; brightness_level = brightness; if(brightness_level > 255) brightness_level = 255; #ifdef CONFIG_ARCH_SCX35 /*brightness steps = 16*/ brightness_level = brightness_level/16; brightness_level = 0;//set brightness_level = 0 for reducing power consumption #else /*brightness steps = 8*/ brightness_level = brightness_level/32; #endif // Set Output Current sci_adi_write(KPLED_CTL, ((brightness_level << KPLED_V_SHIFT) & KPLED_V_MSK), KPLED_V_MSK); PRINT_INFO("reg:0x%08X set_val:0x%08X brightness:%ld brightness_level:%ld(0~15)\n", \ KPLED_CTL, kpled_read(KPLED_CTL), brightness, brightness_level); }
//============================================================================= bool CubitInstrumentation::check_token_log() { const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE"); if (token_file) { if (!tokenUsageStream) { //const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE"); //if(!token_file) // token_file = "usage_tokens.log"; tokenUsageStream = new std::ofstream(token_file, std::ofstream::out); if (!tokenUsageStream) { std::string file_name = getenv("_CUBIT_USAGE_TOKEN_DIR"); file_name += std::tmpnam(NULL); file_name += "log"; tokenUsageStream = new std::ofstream(file_name.c_str(), std::ofstream::out); if (!tokenUsageStream) { PRINT_ERROR("Failed to open token usage file!\n"); PRINT_INFO("\tNo usage token will be recorded.\n"); return false; } } } // write keywords if valid and write flags set if (validKeywords && writeKeywords) { write_all_words(); writeKeywords = false; } return true; } else { return false; } }
static int nmi_wlan_parse_info_frame(uint8_t *info, int size) { nmi_mac_cfg_t *pd = (nmi_mac_cfg_t *)&g_mac; uint32_t wid, len; int type = NMI_CFG_RSP_STATUS; wid = info[0] | (info[1] << 8); #if 0 #ifdef BIG_ENDIAN wid = BYTE_SWAP(wid); #endif #endif len = info[2]; PRINT_INFO(GENERIC_DBG,"Status Len = %d Id= %d\n",len,wid); if ((len == 1) && (wid == WID_STATUS)) { pd->mac_status = info[3]; type = NMI_CFG_RSP_STATUS; } return type; }
int s_app_t::run() { // int64 time_ms; while(!this->m_quit) { if( m_exit == 1) break; switch( m_run_state ) { } usleep(1000*50); } m_quit = 1; PRINT_INFO("s_app_t::run EXIT quit:%d\n", this->m_quit); if( m_exit == 1 ) { m_eye->stop(); stop(); m_exit = 2; } return 0; }
/** @function: static int srecorder_get_other_symbols(void) @brief: 给s_kernel_symbols_table表中的内核符号找到对应的地址 @param: none @return: 0 - 成功;<0-失败 @note: */ static int srecorder_get_other_symbols(void) { int i = 0; int symbols_table_size = sizeof(s_kernel_symbols_table) / sizeof(s_kernel_symbols_table[0]); for (i = 0; i < symbols_table_size; i++) { /*调用kallsyms_lookup_name查找符号对应的地址*/ if (unlikely(NULL == s_kernel_symbols_table[i].symbol_name || NULL == s_kernel_symbols_table[i].symbol_address)) { continue; } *(s_kernel_symbols_table[i].symbol_address) = s_kallsyms_lookup_name(s_kernel_symbols_table[i].symbol_name); if (INVALID_KSYM_ADDR == *(s_kernel_symbols_table[i].symbol_address)) { PRINT_INFO(("Get %s failed.\n", s_kernel_symbols_table[i].symbol_name), DEBUG_KERNEL_SYMBOLS); continue; /*return -EFAULT; */ /* 不要因为一个符号的失败影响到其他符号的读取 */ } } return 0; }
/* * 3480/3490 interrupt handler */ static int tape_34xx_irq(struct tape_device *device, struct tape_request *request, struct irb *irb) { if (request == NULL) return tape_34xx_unsolicited_irq(device, irb); if ((irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) && (irb->scsw.dstat & DEV_STAT_DEV_END) && (request->op == TO_WRI)) { /* Write at end of volume */ PRINT_INFO("End of volume\n"); /* XXX */ return tape_34xx_erp_failed(request, -ENOSPC); } if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) return tape_34xx_unit_check(device, request, irb); if (irb->scsw.dstat & DEV_STAT_DEV_END) { /* * A unit exception occurs on skipping over a tapemark block. */ if (irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) { if (request->op == TO_BSB || request->op == TO_FSB) request->rescnt++; else DBF_EVENT(5, "Unit Exception!\n"); } return tape_34xx_done(request); } DBF_EVENT(6, "xunknownirq\n"); PRINT_ERR("Unexpected interrupt.\n"); PRINT_ERR("Current op is: %s", tape_op_verbose[request->op]); tape_dump_sense(device, request, irb); return TAPE_IO_STOP; }
static void venc_set_lvds(Lcd_Config_t *pConf) { PRINT_INFO("%s.\n",__FUNCTION__); #if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6TV aml_write_reg32(P_VPU_VIU_VENC_MUX_CTRL, (0<<0) | // viu1 select encl (0<<2) ); // viu2 select encl #endif aml_write_reg32(P_ENCL_VIDEO_EN, 0); //int havon_begin = 80; aml_write_reg32(P_VPU_VIU_VENC_MUX_CTRL, (0<<0) | // viu1 select encl (0<<2) ); // viu2 select encl aml_write_reg32(P_ENCL_VIDEO_MODE, 0); // Enable Hsync and equalization pulse switch in center; bit[14] cfg_de_v = 1 aml_write_reg32(P_ENCL_VIDEO_MODE_ADV, 0x0418); // Sampling rate: 1 // bypass filter aml_write_reg32(P_ENCL_VIDEO_FILT_CTRL, 0x1000); aml_write_reg32(P_ENCL_VIDEO_MAX_PXCNT, pConf->lcd_basic.h_period - 1); if (pDev->lcd_info.mode == VMODE_1080P_50HZ) aml_write_reg32(P_ENCL_VIDEO_MAX_LNCNT, 1350 - 1); else aml_write_reg32(P_ENCL_VIDEO_MAX_LNCNT, pConf->lcd_basic.v_period - 1); aml_write_reg32(P_ENCL_VIDEO_HAVON_BEGIN, pConf->lcd_timing.video_on_pixel); aml_write_reg32(P_ENCL_VIDEO_HAVON_END, pConf->lcd_basic.h_active - 1 + pConf->lcd_timing.video_on_pixel); aml_write_reg32(P_ENCL_VIDEO_VAVON_BLINE, pConf->lcd_timing.video_on_line); aml_write_reg32(P_ENCL_VIDEO_VAVON_ELINE, pConf->lcd_basic.v_active - 1 + pConf->lcd_timing.video_on_line); aml_write_reg32(P_ENCL_VIDEO_HSO_BEGIN, pConf->lcd_timing.sth1_hs_addr);//10); aml_write_reg32(P_ENCL_VIDEO_HSO_END, pConf->lcd_timing.sth1_he_addr);//20); aml_write_reg32(P_ENCL_VIDEO_VSO_BEGIN, pConf->lcd_timing.stv1_hs_addr);//10); aml_write_reg32(P_ENCL_VIDEO_VSO_END, pConf->lcd_timing.stv1_he_addr);//20); aml_write_reg32(P_ENCL_VIDEO_VSO_BLINE, pConf->lcd_timing.stv1_vs_addr);//2); aml_write_reg32(P_ENCL_VIDEO_VSO_ELINE, pConf->lcd_timing.stv1_ve_addr);//4); aml_write_reg32(P_ENCL_VIDEO_RGBIN_CTRL, 0); // enable encl aml_write_reg32(P_ENCL_VIDEO_EN, 1); }
static void backlight_power_ctrl(Bool_t status) { mutex_lock(&bl_power_mutex); PRINT_INFO("%s(): bl_status=%s, data_status=%s, bl_level=%u\n", __FUNCTION__, (bl_status ? "ON" : "OFF"), (data_status ? "ON" : "OFF"), bl_level); if( status == ON ){ if ((bl_status == ON) || (data_status == OFF) || (bl_level == 0)) { mutex_unlock(&bl_power_mutex); return; } aml_set_reg32_bits(P_LED_PWM_REG0, 1, 12, 2); lcd_mdelay(20); #if (BL_CTL==BL_CTL_GPIO) //BL_EN -> GPIOD_1: 1 gpio_out(PAD_GPIOD_1, 1); #elif (BL_CTL==BL_CTL_PWM) aml_set_reg32_bits(P_PWM_MISC_REG_CD, PWM_PRE_DIV, 16, 7); aml_set_reg32_bits(P_PWM_MISC_REG_CD, 1, 23, 1); aml_set_reg32_bits(P_PWM_MISC_REG_CD, 1, 1, 1); //enable pwm_d aml_write_reg32(P_PERIPHS_PIN_MUX_2, aml_read_reg32(P_PERIPHS_PIN_MUX_2) | (1<<3)); //enable pwm pinmux #endif } else{ if (bl_status == OFF) { mutex_unlock(&bl_power_mutex); return; } #if (BL_CTL==BL_CTL_GPIO) gpio_out(PAD_GPIOD_1, 0); #elif (BL_CTL==BL_CTL_PWM) aml_set_reg32_bits(P_PWM_MISC_REG_CD, 0, 1, 1); //disable pwm_d #endif } bl_status = status; printk(KERN_INFO "%s() Power %s\n", __FUNCTION__, (status ? "ON" : "OFF")); mutex_unlock(&bl_power_mutex); }
int init_x86rom_cbfs_media(struct cbfs_media *media) { // On X86, we always keep a reference of pointer to CBFS header in // 0xfffffffc, and the pointer is still a memory-mapped address. // Since the CBFS core always use ROM offset, we need to figure out // header->romsize even before media is initialized. struct cbfs_header *header = (struct cbfs_header*) phys_to_virt( *(uint32_t*) phys_to_virt(0xfffffffc)); PRINT_DEBUG( "header %p contains 0x%x\n\n\n", (unsigned int *) header, header->magic ); if (CBFS_HEADER_MAGIC != ntohl(header->magic)) { #if defined(CONFIG_LP_ROM_SIZE) PRINT_ERROR("\nBIOS_ERR : Invalid CBFS master header at %p\n", header); media->context = (void*)CONFIG_LP_ROM_SIZE; #else return -1; #endif } else { uint32_t romsize = ntohl(header->romsize); media->context = phys_to_virt(0 - romsize); PRINT_DEBUG( "context set to %p\n", (char *) media->context ); #if defined(CONFIG_LP_ROM_SIZE) if (CONFIG_LP_ROM_SIZE != romsize) PRINT_INFO("BIOS_INFO: Warning: rom size unmatch (%d/%d)\n", CONFIG_LP_ROM_SIZE, romsize); #endif } media->open = x86_rom_open; media->close = x86_rom_close; media->map = x86_rom_map; media->unmap = x86_rom_unmap; media->read = x86_rom_read; return 0; }
long DeleteOtherData( void *hDB, char *CryptoObjectNr, char *location_id, char *tableName, server_request_data_t *req) { char *SQLQuery = NULL; void *database_result = NULL; PRINT_INFO("LIBBMDSQLINF Deleting file's aditional metadata\n"); /************************/ /* walidacja parametrow */ /************************/ if (hDB==NULL) { BMD_FOK(BMD_ERR_PARAM1); } if (CryptoObjectNr==NULL) { BMD_FOK(BMD_ERR_PARAM2); } asprintf(&SQLQuery, "DELETE FROM %s WHERE fk_crypto_objects=%s%s%s;", tableName, CryptoObjectNr, location_id==NULL?"":" AND location_id=", location_id==NULL?"":location_id); if (SQLQuery==NULL) { BMD_FOK(NO_MEMORY); } /****************************************/ /* wykonanie polecenia usuwania w bazie */ /****************************************/ BMD_FOK(bmd_db_execute_sql(hDB, SQLQuery,NULL,NULL, &database_result)); /************/ /* porzadki */ /************/ bmd_db_result_free(&database_result); free0(SQLQuery); return BMD_OK; }
/* * Callback function for SSL/TLS NPN. Since this program only supports * SPDY protocol, if server does not offer SPDY protocol the Spdylay * library supports, we terminate program. */ static int spdy_cb_ssl_select_next_proto(SSL* ssl, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg) { (void)ssl; int rv; uint16_t *spdy_proto_version; /* spdylay_select_next_protocol() selects SPDY protocol version the Spdylay library supports. */ rv = spdylay_select_next_protocol(out, outlen, in, inlen); if(rv <= 0) { PRINT_INFO("Server did not advertise spdy/2 or spdy/3 protocol."); return rv; } spdy_proto_version = (uint16_t*)arg; *spdy_proto_version = rv; return SSL_TLSEXT_ERR_OK; }
int invoke_stpg(const uint8_t *device_name, const struct scst_event_stpg_descr *descr, pid_t *out_pid) { char *args[7], *env[7]; int res = 0, ret, i; pid_t c_pid; args[0] = stpg_path; args[1] = (char *)device_name; args[2] = (char *)descr->prev_state; args[3] = (char *)descr->new_state; args[4] = (char *)descr->dg_name; args[5] = (char *)descr->tg_name; args[6] = NULL; env[0] = "PATH=/bin:/usr/bin:/sbin:/usr/sbin"; ret = asprintf(&env[1], "SCST_DEVICE_NAME=%s", device_name); if (ret < 0) { res = -errno; PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); goto out; } ret = asprintf(&env[2], "SCST_PREV_ALUA_STATE=%s", descr->prev_state); if (ret < 0) { res = -errno; PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); goto out; } ret = asprintf(&env[3], "SCST_ALUA_STATE=%s", descr->new_state); if (ret < 0) { res = -errno; PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); goto out; } ret = asprintf(&env[4], "SCST_DEVICE_GROUP=%s", descr->dg_name); if (ret < 0) { res = -errno; PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); goto out; } ret = asprintf(&env[5], "SCST_TARGET_GROUP=%s", descr->tg_name); if (ret < 0) { res = -errno; PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); goto out; } env[6] = NULL; PRINT_INFO("Invoking script %s with parameters: %s %s %s %s %s and environment: " "%s %s %s %s %s", stpg_path, args[1], args[2], args[3], args[4], args[5], env[1], env[2], env[3], env[4], env[5]); c_pid = fork(); if (c_pid == 0) { ret = setpgid(getpid(), getpid()); if (ret < 0) { res = -errno; PRINT_ERROR("setgid failed %d (%s)", ret, strerror(-ret)); } TRACE_DBG("pgid %d (pid %d)", getpgid(getpid()), getpid()); ret = execve(stpg_path, args, env); if (ret < 0) { res = -errno; PRINT_ERROR("EXEC failed %d (%s)", ret, strerror(-ret)); } exit(0); } else if (c_pid < 0) { res = -errno; PRINT_ERROR("fork() failed: %d (%s)", res, strerror(-res)); } *out_pid = c_pid; for (i = 1; i < (signed)ARRAY_SIZE(env); i++) free(env[i]); out: return res; }
static int stpg_event_loop(void) { int res = 0, status; int event_fd; uint8_t event_user_buf[1024*1024]; pid_t c_pid = 0; struct pollfd pl; struct scst_event_user *event_user = (struct scst_event_user *)event_user_buf; struct scst_event e1; bool first_error = true; event_fd = open(SCST_EVENT_DEV, O_RDWR); if (event_fd < 0) { res = -errno; PRINT_ERROR("Unable to open SCST event device %s (%s)", SCST_EVENT_DEV, strerror(-res)); goto out; } close(stpg_init_report_pipe[0]); if (log_daemon) res = write(stpg_init_report_pipe[1], &res, sizeof(res)); close(stpg_init_report_pipe[1]); memset(&pl, 0, sizeof(pl)); pl.fd = event_fd; pl.events = POLLIN; memset(&e1, 0, sizeof(e1)); e1.event_code = SCST_EVENT_STPG_USER_INVOKE; strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER, sizeof(e1.issuer_name)); e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0'; PRINT_INFO("Setting allowed event code %d, issuer_name %s", e1.event_code, e1.issuer_name); res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1); if (res != 0) { res = -errno; PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)", res, strerror(-res)); goto out; } e1.event_code = SCST_EVENT_TM_FN_RECEIVED; strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER, sizeof(e1.issuer_name)); e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0'; PRINT_INFO("Setting allowed event code %d, issuer_name %s", e1.event_code, e1.issuer_name); res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1); if (res != 0) { res = -errno; PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)", res, strerror(-res)); goto out; } while (1) { memset(event_user_buf, 0, sizeof(event_user_buf)); event_user->max_event_size = sizeof(event_user_buf); res = ioctl(event_fd, SCST_EVENT_GET_NEXT_EVENT, event_user); if (res != 0) { res = -errno; switch (-res) { case ESRCH: case EBUSY: TRACE_MGMT_DBG("SCST_EVENT_GET_NEXT_EVENT " "returned %d (%s)", res, strerror(res)); /* go through */ case EINTR: continue; case EAGAIN: TRACE_DBG("SCST_EVENT_GET_NEXT_EVENT, " "returned EAGAIN (%d)", -res); continue; default: PRINT_ERROR("SCST_EVENT_GET_NEXT_EVENT " "failed: %d (%s)", res, strerror(-res)); if (!first_error) goto out; first_error = false; continue; } first_error = true; again_poll: res = poll(&pl, 1, c_pid > 0 ? 1 : 0); if (res > 0) continue; else if (res == 0) goto again_poll; else { res = -errno; switch (res) { case ESRCH: case EBUSY: case EAGAIN: TRACE_MGMT_DBG("poll() returned %d " "(%s)", res, strerror(-res)); case EINTR: goto again_poll; default: PRINT_ERROR("poll() failed: %d (%s)", res, strerror(-res)); goto again_poll; } } } first_error = true; #ifdef DEBUG PRINT_INFO("event_code %d, issuer_name %s", event_user->out_event.event_code, event_user->out_event.issuer_name); #endif if (event_user->out_event.payload_len != 0) TRACE_BUFFER("payload", event_user->out_event.payload, event_user->out_event.payload_len); if (event_user->out_event.event_code == SCST_EVENT_STPG_USER_INVOKE) { c_pid = fork(); if (c_pid == -1) PRINT_ERROR("Failed to fork: %d", c_pid); else if (c_pid == 0) { struct scst_event_notify_done d; signal(SIGCHLD, SIG_DFL); status = handle_stpg_received(event_user); memset(&d, 0, sizeof(d)); d.event_id = event_user->out_event.event_id; d.status = status; res = ioctl(event_fd, SCST_EVENT_NOTIFY_DONE, &d); if (res != 0) { res = -errno; PRINT_ERROR("SCST_EVENT_NOTIFY_DONE " "failed: %s (res %d)", strerror(-res), res); } else PRINT_INFO("STPG event completed with status %d", status); exit(res); } } else if (event_user->out_event.event_code == SCST_EVENT_TM_FN_RECEIVED) stpg_handle_tm_received(event_user); else PRINT_ERROR("Unknown event %d received", event_user->out_event.event_code); } out: return res; }
int main(int argc, char **argv) { int res = 0, ch, longindex; pid_t pid; struct sigaction sa; setlinebuf(stdout); openlog(argv[0], LOG_PID, LOG_USER); res = pipe(stpg_init_report_pipe); if (res == -1) { res = -errno; PRINT_ERROR("Pipe failed: %d (%s)", res, strerror(-res)); goto out; } sa.sa_handler = &sig_chld; sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART | SA_NOCLDSTOP; if (sigaction(SIGCHLD, &sa, 0) == -1) { PRINT_ERROR("sigaction() failed: %d/%s", errno, strerror(errno)); exit(1); } /* * Otherwise we could die in some later write() during the event_loop() * instead of getting EPIPE! */ signal(SIGPIPE, SIG_IGN); res = debug_init(); if (res != 0) goto out; app_name = argv[0]; while ((ch = getopt_long(argc, argv, "+d:fp:t:hv", long_options, &longindex)) >= 0) { switch (ch) { case 'p': stpg_path = optarg; break; #if defined(DEBUG) || defined(TRACING) case 'd': trace_flag = strtol(optarg, (char **)NULL, 0); break; #endif case 'v': printf("%s version %s\n", app_name, VERSION_STR); goto out_done; case 'f': log_daemon = false; break; case 't': transition_timeout = strtol(optarg, (char **)NULL, 0); if (transition_timeout < 0) { printf("Invalid timeout %d\n", transition_timeout); res = -EINVAL; goto out_done; } break; case 'h': usage(0); goto out_done; default: goto out_usage; } } if (!stpg_path) stpg_path = "/usr/local/bin/scst/scst_on_stpg"; if (access(stpg_path, X_OK) == -1) { PRINT_ERROR("Script file \" %s \"does not exist or not " "executable", stpg_path); res = -1; goto out_done; } #ifdef DEBUG PRINT_INFO("trace_flag %lx", trace_flag); #endif if (log_daemon) { trace_flag &= ~TRACE_TIME; trace_flag &= ~TRACE_PID; pid = fork(); if (pid < 0) { PRINT_ERROR("starting daemon failed(%d)", pid); res = pid; goto out_done; } else if (pid) { int res1 = -1; close(stpg_init_report_pipe[1]); if ((unsigned)read(stpg_init_report_pipe[0], &res1, sizeof(res1)) < sizeof(res1)) { res = -1; goto out_done; } else { res = res1; goto out_done; } } close(0); open("/dev/null", O_RDWR); dup2(0, 1); dup2(0, 2); setsid(); } res = stpg_event_loop(); out_done: debug_done(); out: closelog(); return res; out_usage: usage(1); goto out_done; }
static int _switch_gate(mod_type_t type, int flag) { int ret = 0; switch(type) { case MOD_VDEC: PRINT_INFO("turn %s vdec module\n", flag?"on":"off"); if (flag) { GATE_ON(DOS); } else { GATE_OFF(DOS); } break; case MOD_AUDIO: PRINT_INFO("turn %s audio module\n", flag?"on":"off"); if (flag) { GATE_ON(AIU_AMCLK_MEASURE); GATE_ON(AIU_AIFIFO2); GATE_ON(AIU_AUD_MIXER); GATE_ON(AIU_MIXER_REG); GATE_ON(AIU_IEC958); GATE_ON(AIU_AI_TOP_GLUE); GATE_ON(AUD_BUF); GATE_ON(AIU_I2S_OUT); GATE_ON(AIU_AMCLK); //this gate should not be turned off GATE_ON(AIU_ICE958_AMCLK); GATE_ON(AIU_AOCLK); //GATE_ON(AUD_IN); GATE_ON(AIU_ADC); GATE_ON(AIU_AUDIN_SCLK); } else { GATE_OFF(AIU_AMCLK_MEASURE); GATE_OFF(AIU_AIFIFO2); GATE_OFF(AIU_AUD_MIXER); GATE_OFF(AIU_MIXER_REG); GATE_OFF(AIU_IEC958); GATE_OFF(AIU_AI_TOP_GLUE); GATE_OFF(AUD_BUF); GATE_OFF(AIU_I2S_OUT); GATE_OFF(AIU_AMCLK); //this gate should not be turned off GATE_OFF(AIU_ICE958_AMCLK); GATE_OFF(AIU_AOCLK); //GATE_OFF(AUD_IN); GATE_OFF(AIU_ADC); GATE_OFF(AIU_AUDIN_SCLK); } break; case MOD_HDMI: PRINT_INFO("turn %s hdmi module\n", flag?"on":"off"); if (flag) { GATE_ON(HDMI_INTR_SYNC); GATE_ON(HDMI_PCLK); GATE_ON(VCLK1_HDMI); } else { GATE_OFF(HDMI_INTR_SYNC); GATE_OFF(HDMI_PCLK); GATE_OFF(VCLK1_HDMI); } break; case MOD_VENC: PRINT_INFO("turn %s venc module\n", flag?"on":"off"); if (flag) { GATE_ON(VCLK2_VENCI); GATE_ON(VCLK2_VENCI1); GATE_ON(VCLK2_VENCP); GATE_ON(VCLK2_VENCP1); GATE_ON(VENC_P_TOP); GATE_ON(VENC_I_TOP); GATE_ON(VENCI_INT); GATE_ON(VENCP_INT); GATE_ON(VCLK2_ENCI); GATE_ON(VCLK2_ENCP); GATE_ON(VCLK2_VENCT); GATE_ON(VCLK2_VENCT1); GATE_ON(VCLK2_OTHER); GATE_ON(VCLK2_OTHER1); GATE_ON(ENC480P); GATE_ON(VENC_DAC); GATE_ON(DAC_CLK); } else { GATE_OFF(VCLK2_VENCI); GATE_OFF(VCLK2_VENCI1); GATE_OFF(VCLK2_VENCP); GATE_OFF(VCLK2_VENCP1); GATE_OFF(VENC_P_TOP); GATE_OFF(VENC_I_TOP); GATE_OFF(VENCI_INT); GATE_OFF(VENCP_INT); GATE_OFF(VCLK2_ENCI); GATE_OFF(VCLK2_ENCP); GATE_OFF(VCLK2_VENCT); GATE_OFF(VCLK2_VENCT1); GATE_OFF(VCLK2_OTHER); GATE_OFF(VCLK2_OTHER1); GATE_OFF(ENC480P); GATE_OFF(VENC_DAC); GATE_OFF(DAC_CLK); } break; case MOD_TCON: PRINT_INFO("turn %s tcon module\n", flag?"on":"off"); if (flag) { GATE_ON(VENC_T_TOP); GATE_ON(VENCT_INT); GATE_ON(VCLK2_ENCT); } else { GATE_OFF(VENC_T_TOP); GATE_OFF(VENCT_INT); GATE_OFF(VCLK2_ENCT); } break; case MOD_LVDS: PRINT_INFO("turn %s lvds module\n", flag?"on":"off"); if (flag) { GATE_ON(VENC_L_TOP); GATE_ON(VENCL_INT); GATE_ON(VCLK2_ENCL); } else { GATE_OFF(VENC_L_TOP); GATE_OFF(VENCL_INT); GATE_OFF(VCLK2_ENCL); } break; case MOD_MIPI: PRINT_INFO("turn %s mipi module\n", flag?"on":"off"); if (flag) { GATE_ON(MIPI_APB_CLK); GATE_ON(MIPI_SYS_CLK); GATE_ON(MIPI_PHY); } else { GATE_OFF(MIPI_APB_CLK); GATE_OFF(MIPI_SYS_CLK); GATE_OFF(MIPI_PHY); } break; case MOD_BT656: PRINT_INFO("turn %s bt656 module\n", flag?"on":"off"); if (flag) { GATE_ON(BT656_IN); } else { GATE_OFF(BT656_IN); } break; case MOD_SPI: PRINT_INFO("turn %s spi module\n", flag?"on":"off"); if (flag) { GATE_ON(SPICC); GATE_ON(SPI1); GATE_ON(SPI2); } else { GATE_OFF(SPICC); GATE_OFF(SPI1); GATE_OFF(SPI2); } break; case MOD_UART0: PRINT_INFO("turn %s uart0 module\n", flag?"on":"off"); if (flag) { GATE_ON(UART0); } else { GATE_OFF(UART0); } break; case MOD_UART1: PRINT_INFO("turn %s uart1 module\n", flag?"on":"off"); if (flag) { GATE_ON(UART1); } else { GATE_OFF(UART1); } break; case MOD_UART2: PRINT_INFO("turn %s uart2 module\n", flag?"on":"off"); if (flag) { GATE_ON(UART2); } else { GATE_OFF(UART2); } break; case MOD_UART3: PRINT_INFO("turn %s uart3 module\n", flag?"on":"off"); if (flag) { GATE_ON(UART3); } else { GATE_OFF(UART3); } break; case MOD_ROM: PRINT_INFO("turn %s rom module\n", flag?"on":"off"); if (flag) { GATE_ON(ROM_CLK); } else { GATE_OFF(ROM_CLK); } break; case MOD_EFUSE: PRINT_INFO("turn %s efuse module\n", flag?"on":"off"); if (flag) { GATE_ON(EFUSE); } else { GATE_OFF(EFUSE); } break; case MOD_RANDOM_NUM_GEN: PRINT_INFO("turn %s random_num_gen module\n", flag?"on":"off"); if (flag) { GATE_ON(RANDOM_NUM_GEN); } else { GATE_OFF(RANDOM_NUM_GEN); } break; case MOD_ETHERNET: PRINT_INFO("turn %s ethernet module\n", flag?"on":"off"); if (flag) { GATE_ON(ETHERNET); } else { GATE_OFF(ETHERNET); } break; case MOD_MEDIA_CPU: PRINT_INFO("trun %s Audio DSP\n", flag? " on" : "off"); if(flag){ GATE_ON(MEDIA_CPU); }else{ GATE_OFF(MEDIA_CPU); } break; case MOD_GE2D: PRINT_INFO("trun %s GE2D\n", flag? " on" : "off"); if(flag){ GATE_ON(GE2D); }else{ GATE_OFF(GE2D); } break; case MOD_VIDEO_IN: PRINT_INFO("trun %s video_in\n", flag? " on" : "off"); if(flag){ GATE_ON(VIDEO_IN); }else{ GATE_OFF(VIDEO_IN); } break; case MOD_VIU2: PRINT_INFO("trun %s viu2\n", flag? " on" : "off"); if(flag){ GATE_ON(VIU2); }else{ GATE_OFF(VIU2); } break; case MOD_AUD_IN: PRINT_INFO("trun %s audio_in\n", flag? " on" : "off"); #if 0 if(flag){ GATE_ON(AIU_ADC); GATE_ON(AIU_AUDIN_SCLK); }else{ GATE_OFF(AIU_ADC); GATE_OFF(AIU_AUDIN_SCLK); } #endif break; case MOD_AUD_OUT: PRINT_INFO("trun %s audio_out\n", flag? " on" : "off"); if(flag){ }else{ } break; case MOD_AHB: PRINT_INFO("trun %s ahb\n", flag? " on" : "off"); if(flag){ GATE_ON(AHB_ARB0); GATE_ON(AHB_BRIDGE); GATE_ON(AHB_DATA_BUS); GATE_ON(AHB_CONTROL_BUS); }else{ GATE_OFF(AHB_ARB0); GATE_OFF(AHB_BRIDGE); GATE_OFF(AHB_DATA_BUS); GATE_OFF(AHB_CONTROL_BUS); } break; case MOD_DEMUX: PRINT_INFO("trun %s demux\n", flag? " on" : "off"); if(flag){ GATE_ON(DEMUX); }else{ GATE_OFF(DEMUX); } break; case MOD_SMART_CARD: PRINT_INFO("trun %s smart card\n", flag? " on" : "off"); if(flag){ GATE_ON(SMART_CARD_MPEG_DOMAIN); }else{ GATE_OFF(SMART_CARD_MPEG_DOMAIN); } break; case MOD_SDHC: PRINT_INFO("trun %s sdhc\n", flag? " on" : "off"); if(flag){ GATE_ON(SDHC); }else{ GATE_OFF(SDHC); } break; case MOD_STREAM: PRINT_INFO("trun %s stream\n", flag? " on" : "off"); if(flag){ GATE_ON(STREAM); }else{ GATE_OFF(STREAM); } break; case MOD_BLK_MOV: PRINT_INFO("trun %s blk_mov\n", flag? " on" : "off"); if(flag){ GATE_ON(BLK_MOV); }else{ GATE_OFF(BLK_MOV); } break; case MOD_MISC_DVIN: PRINT_INFO("trun %s dvin\n", flag? " on" : "off"); if(flag){ GATE_ON(MISC_DVIN); }else{ GATE_OFF(MISC_DVIN); } break; case MOD_MISC_RDMA: PRINT_INFO("trun %s rdma\n", flag? " on" : "off"); if(flag){ GATE_ON(MISC_RDMA); }else{ GATE_OFF(MISC_RDMA); } break; case MOD_USB0: PRINT_INFO("trun %s rdma\n", flag? " on" : "off"); if(flag){ GATE_ON(USB0); GATE_ON(MISC_USB0_TO_DDR); }else{ GATE_OFF(USB0); GATE_ON(MISC_USB0_TO_DDR); } break; case MOD_USB1: PRINT_INFO("trun %s rdma\n", flag? " on" : "off"); if(flag){ GATE_ON(USB1); GATE_ON(MISC_USB1_TO_DDR); }else{ GATE_OFF(USB1); GATE_ON(MISC_USB1_TO_DDR); } break; case MOD_SDIO: PRINT_INFO("trun %s rdma\n", flag? " on" : "off"); if(flag){ GATE_ON(SDIO); }else{ GATE_OFF(SDIO); } break; case MOD_VI_CORE: PRINT_INFO("trun %s vi core\n", flag? " on" : "off"); if(flag){ GATE_ON(VI_CORE); }else{ GATE_OFF(VI_CORE); } break; case MOD_LED_PWM: PRINT_INFO("trun %s led pwm\n", flag? " on" : "off"); if(flag){ GATE_ON(LED_PWM); }else{ GATE_OFF(LED_PWM); } break; default: PRINT_INFO("mod type not support\n"); ret = -1; break; } return ret; }