static GdkPixbufAnimation* pgpug_animated_icon_compose_real (PgpugPixEnum icon_id, gint size, va_list var_args) { GdkPixbufAnimation *base_anim = pgpug_animated_icon (icon_id, size); g_return_val_if_fail (base_anim != NULL, NULL); GPtrArray *anim_array = g_ptr_array_new (); animation_param_entry* p_entry = g_malloc0 (sizeof (animation_param_entry)); p_entry->anim = pgpug_animated_icon (icon_id, size); g_ptr_array_add (anim_array, p_entry); gint size_v, pos_v, icon_id_v, param_num; icon_id_v = va_arg (var_args, gint); param_num = 0; while (icon_id_v >=0) { size_v = va_arg (var_args, gint); pos_v = va_arg (var_args, gint); if (size_v <= 0 ){ //incorrect icon size WARN_MSG ("pgpug_animated_icon_compose: var_arg parameter %d expected param correct icon size, got %d value", param_num + 1, size_v); break; } if (pos_v < 0){ WARN_MSG ("pgpug_animated_icon_compose: var_arg parameter %d expected param from PgpugPixComposePosEnum, got %d value", param_num + 2, pos_v); //incorrect icon size break; } param_num+=3; p_entry = g_malloc0 (sizeof (animation_param_entry)); p_entry->anim = pgpug_animated_icon (icon_id_v, size_v); p_entry->pos = pos_v; g_ptr_array_add (anim_array, p_entry); icon_id_v = va_arg (var_args, gint); } GdkPixbufAnimation *result; result = compose_animation_from_array ((animation_param_entry**)anim_array->pdata, anim_array->len, size); guint i; for (i=0;i<anim_array->len;i++) g_object_unref ( ((animation_param_entry*)anim_array->pdata[i])->anim); g_ptr_array_foreach (anim_array, (GFunc)g_free, NULL); g_ptr_array_free (anim_array, TRUE); return result; }
BOOL OpenContext::SetAltSetting(LPUKWD_SET_ALTSETTING_INFO lpSetAltSettingInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpSetAltSettingInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Interface can't be used if device has closed if (dev->Closed()) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } if (!dev->InterfaceClaimed(lpSetAltSettingInfo->dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::SetAltSetting() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), lpSetAltSettingInfo->dwInterface, lpSetAltSettingInfo->lpDevice)); if (!dev->ClaimInterface(lpSetAltSettingInfo->dwInterface, this)) { return FALSE; } } return dev->SetAltSetting(lpSetAltSettingInfo->dwInterface, lpSetAltSettingInfo->dwAlternateSetting); }
void ctrl_exception_done(void* desc, void* cpu, integer_t val) { int proc_no = SIM_get_proc_no((conf_object_t*) cpu); conf_object_t* cpu_obj = (conf_object_t*) cpu; uinteger_t trap_level = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tl")); uinteger_t pc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "pc")); uinteger_t npc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "npc")); uinteger_t tpc = 0; uinteger_t tnpc = 0; //get the return PC,NPC pair based on the trap level ASSERT(1 <= trap_level && trap_level <= 5); if(trap_level == 1){ tpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tpc1")); tnpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tnpc1")); } if(trap_level == 2){ tpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tpc2")); tnpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tnpc2")); } if(trap_level == 3){ tpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tpc3")); tnpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tnpc3")); } if(trap_level == 4){ tpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tpc4")); tnpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tnpc4")); } if(trap_level == 5){ tpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tpc5")); tnpc = SIM_read_register(cpu_obj, SIM_get_register_number(cpu_obj, "tnpc5")); } if (!XACT_MEMORY) return; TransactionInterfaceManager *xact_mgr = XACT_MGR; int smt_thread_num = proc_no % RubyConfig::numberofSMTThreads(); // The simulated processor number int sim_proc_no = proc_no / RubyConfig::numberofSMTThreads(); if (proc_no != SIMICS_current_processor_number()){ WARN_EXPR(proc_no); WARN_EXPR(SIMICS_current_processor_number()); WARN_MSG("Callback for a different processor"); } g_system_ptr->getProfiler()->profileExceptionDone(xact_mgr->getTransactionLevel(smt_thread_num) > 0, sim_proc_no, smt_thread_num, val, trap_level, pc, npc, tpc, tnpc); if((val >= 0x80 && val <= 0x9f) || (val >= 0xc0 && val <= 0xdf)){ //xact_mgr->clearLoggedException(smt_thread_num); } if ((val == 0x122) && xact_mgr->shouldTrap(smt_thread_num)){ // use software handler if (xact_mgr->shouldUseHardwareAbort(smt_thread_num)){ xact_mgr->hardwareAbort(smt_thread_num); } else { xact_mgr->trapToHandler(smt_thread_num); } } }
BOOL OpenContext::IsPipeHalted(LPUKWD_ENDPOINT_INFO lpEndpointInfo, LPBOOL halted) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpEndpointInfo->lpDevice); if (!Validate(dev) || halted == NULL) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Find the interface for this device DWORD dwInterface = -1; if (lpEndpointInfo->Endpoint != 0) { if (!dev->FindInterface(lpEndpointInfo->Endpoint, dwInterface)) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::IsPipeHalted() - ") TEXT("failed to find interface for endpoint %d on device 0x%08x\r\n"), lpEndpointInfo->Endpoint, lpEndpointInfo->lpDevice)); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // See if it's already been claimed if (!dev->InterfaceClaimed(dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::IsPipeHalted() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), dwInterface, lpEndpointInfo->lpDevice)); if (!dev->ClaimInterface(dwInterface, this)) { return FALSE; } } } return dev->IsEndpointHalted(dwInterface, lpEndpointInfo->Endpoint, *halted); }
extern "C" BOOL UsbDeviceNotifyRoutine( LPVOID lpvNotifyParameter, DWORD dwCode, LPDWORD* dwInfo1, LPDWORD* dwInfo2, LPDWORD* dwInfo3, LPDWORD* dwInfo4 ) { UsbDevice* dev = static_cast<UsbDevice*>(lpvNotifyParameter); switch (dwCode) { #if _WIN32_WCE >= 0x700 case USB_RESUMED_DEVICE: case USB_SUSPENDED_DEVICE: return FALSE; #endif case USB_CLOSE_DEVICE: { dev->Close(); UsbDeviceList* list = UsbDeviceList::Get(); if (list && dev) { list->PutDevice(dev); } return TRUE; } default: WARN_MSG((TEXT("USBKWrapperDrv!UsbDeviceNotifyRoutine") TEXT(" received unknown code %d for dev 0x%08x\r\n"), dwCode, dev)); return FALSE; } return FALSE; }
BOOL OpenContext::StartBulkTransfer(LPUKWD_BULK_TRANSFER_INFO lpTransferInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpTransferInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Interface can't be used if device has closed if (dev->Closed()) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Find the interface for this transfer DWORD dwInterface; if (!dev->FindInterface(lpTransferInfo->Endpoint, dwInterface)) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - ") TEXT("failed to find interface for endpoint %d on device 0x%08x\r\n"), lpTransferInfo->Endpoint, lpTransferInfo->lpDevice)); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // See if it's already been claimed if (!dev->InterfaceClaimed(dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), dwInterface, lpTransferInfo->lpDevice)); if (!dev->ClaimInterface(dwInterface, this)) { return FALSE; } } TRANSFERLIFETIME_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() on ep %x, flag 0x%08x and size %d\r\n"), lpTransferInfo->Endpoint, lpTransferInfo->dwFlags, lpTransferInfo->dwDataBufferSize)); // Construct and start the bulk transfer BulkTransfer* bt = new (std::nothrow) BulkTransfer( this, dev, dwInterface, lpTransferInfo); if (!bt) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - failed to create bulk transfer, aborting\r\n"))); SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } BOOL ret = bt->Start(); mTransferList->PutTransfer(bt); bt = NULL; if (!ret) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::StartBulkTransfer() - failed to start bulk transfer %d\r\n"), GetLastError())); return FALSE; } // Ownership of ct has passed to the transfer callback return TRUE; }
bool valid( dcp_info_t * info ) { unsigned char hash[MD5_DIGEST_LENGTH]; bool success = true; int idx; for( idx=0; idx<info->nbuffer; ++idx ){ MD5( info->buffer[idx], info->size[idx], hash ); if ( memcmp( hash, info->hash[idx], MD5_DIGEST_LENGTH ) != 0 ) { WARN_MSG("hashes for buffer id %d differ", idx); success = false; } } }
/* resolve addr/cnt/sequence fields in the individual CF's */ static int shader_resolve(struct ir2_shader *shader, struct ir2_shader_info *info) { uint32_t addr; unsigned i; int j; addr = shader->cfs_count / 2; for (i = 0; i < shader->cfs_count; i++) { struct ir2_cf *cf = shader->cfs[i]; if ((cf->cf_type == EXEC) || (cf->cf_type == EXEC_END)) { uint32_t sequence = 0; if (cf->exec.addr && (cf->exec.addr != addr)) WARN_MSG("invalid addr '%d' at CF %d", cf->exec.addr, i); if (cf->exec.cnt && (cf->exec.cnt != cf->exec.instrs_count)) WARN_MSG("invalid cnt '%d' at CF %d", cf->exec.cnt, i); for (j = cf->exec.instrs_count - 1; j >= 0; j--) { struct ir2_instruction *instr = cf->exec.instrs[j]; sequence <<= 2; if (instr->instr_type == IR2_FETCH) sequence |= 0x1; if (instr->sync) sequence |= 0x2; } cf->exec.addr = addr; cf->exec.cnt = cf->exec.instrs_count; cf->exec.sequence = sequence; addr += cf->exec.instrs_count; } } info->sizedwords = 3 * addr; return 0; }
// Checks that device is valid and is open // by this context. BOOL OpenContext::Validate(DevicePtr& device) { if (!device.Valid()) return FALSE; PtrArray<UsbDevice>::iterator it = mOpenDevices.find(device.Get()); if (it == mOpenDevices.end()) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::Validate") TEXT(" - failed to find device in this context for identifier 0x%08x\r\n"), device->GetIdentifier())); return FALSE; } return TRUE; }
UsbDevice* UsbDeviceList::GetDevice(UKWD_USB_DEVICE identifier) { MutexLocker lock(mMutex); PtrArray<UsbDevice>::iterator it = mDevices.find(static_cast<UsbDevice*>(identifier)); if (it == mDevices.end()) { WARN_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::GetDevice") TEXT(" - failed to find device for identifier 0x%08x\r\n"), identifier)); return NULL; } else { (*it)->IncRef(); } return *it; }
GdkPixbufAnimation* pgpug_animated_icon_compose_from_anim_list (GdkPixbufAnimation * anim, ...) { g_return_val_if_fail (anim != NULL, NULL); g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (anim), NULL); int width, height; width = gdk_pixbuf_animation_get_width (anim); height = gdk_pixbuf_animation_get_height (anim); g_return_val_if_fail (height == width, NULL); va_list anim_p; va_start (anim_p, anim); //get all animation into an array GPtrArray *anim_array = g_ptr_array_new (); animation_param_entry* p_entry = g_malloc0 (sizeof (animation_param_entry)); p_entry->anim = anim; g_ptr_array_add (anim_array, p_entry); gint anim_pos, param_num = 0; anim_pos = va_arg (anim_p, gint); while (anim_pos >= 0){ gpointer ptr = va_arg (anim_p, gpointer); p_entry = g_malloc (sizeof (animation_param_entry)); param_num += 2; if (!GDK_IS_PIXBUF_ANIMATION (ptr)) { WARN_MSG ("pgpug_animated_icon_compose_from_anim_list: var_arg parameter %d expected GdkPixbufAnimation*", param_num); break; } p_entry->anim = GDK_PIXBUF_ANIMATION (ptr); p_entry->pos = anim_pos; g_ptr_array_add (anim_array, p_entry); anim_pos = va_arg (anim_p, gint); } va_end (anim_p); GdkPixbufAnimation *result; result = compose_animation_from_array ((animation_param_entry**)anim_array->pdata, anim_array->len, width); g_ptr_array_foreach (anim_array, (GFunc)g_free, NULL); g_ptr_array_free (anim_array, TRUE); return result; }
/* * disable segmentation offload on interface * this prevents L3 send errors (payload too large) */ void disable_interface_offload(void) { int param_length= 0; char *command; char **param = NULL; char *p; int ret_val, i = 0; SAFE_CALLOC(command, 100, sizeof(char)); BUG_IF(command==NULL); memset(command, '\0', 100); snprintf(command, 99, "ethtool -K %s tso off gso off gro off lro off", EC_GBL_OPTIONS->iface); DEBUG_MSG("disable_interface_offload: Disabling offload on %s", EC_GBL_OPTIONS->iface); for(p = strsep(&command, " "); p != NULL; p = strsep(&command, " ")) { SAFE_REALLOC(param, (i+1) * sizeof(char *)); param[i++] = strdup(p); } SAFE_REALLOC(param, (i+1) * sizeof(char *)); param[i] = NULL; param_length= i + 1; //because there is a SAFE_REALLOC after the for. switch(fork()) { case 0: #ifndef DEBUG /* don't print on console if the ethtool cannot disable some offloads unless you are in debug mode */ close(2); #endif execvp(param[0], param); WARN_MSG("cannot disable offload on %s, do you have ethtool installed?", EC_GBL_OPTIONS->iface); safe_free_mem(param, ¶m_length, command); _exit(-E_INVALID); case -1: safe_free_mem(param, ¶m_length, command); break; default: safe_free_mem(param, ¶m_length, command); wait(&ret_val); } }
OpenContext::~OpenContext() { if (mMutex) CloseHandle(mMutex); delete mTransferList; // Release any leaked devices DWORD count = 0; PtrArray<UsbDevice>::iterator it = mOpenDevices.begin(); while(it != mOpenDevices.end()) { (*it)->ReleaseAllInterfaces(this); mDevice->GetDeviceList()->PutDevice(*it); ++count; ++it; } if (count > 0) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::~OpenContext() - detected %d leaked devices\r\n"), count)); } }
gint pgpug_window_deinstall_pane (PgpugWindow *self, PgpugPane *tab, PgpugPaneLocation location) { g_return_if_fail (PGPUG_IS_WINDOW (self)); g_return_if_fail (PGPUG_IS_PANE (tab)); GtkWidget *view = pgpug_pane_get_view (tab); GtkWidget *parent = gtk_widget_get_parent (view); PgpugPane *pgpug_pane = g_hash_table_lookup (self->priv->view_pane_map, view); if (parent != NULL) { gtk_container_remove (GTK_CONTAINER (parent), view); }else { WARN_MSG ("PgpugWindow: deinstall pane: pane is not installed"); } g_hash_table_remove (self->priv->view_pane_map, view); }
gint pgpug_window_install_pane (PgpugWindow *self, PgpugPane *tab, PgpugPaneLocation location) { g_return_if_fail (PGPUG_IS_WINDOW (self)); g_return_if_fail (PGPUG_IS_PANE (tab)); GtkWidget *view = pgpug_pane_get_view (tab); const gchar* label_text = pgpug_pane_get_label_text (tab); g_hash_table_insert (self->priv->view_pane_map, view, tab); gint reslt = -1; switch (location) { case PGPUG_PANE_BROWSER: reslt = folding_tab_pane_append_page (FOLDING_TAB_PANE (self->priv->browser_pane), view, gtk_label_new (label_text)); break; case PGPUG_PANE_CONTENT: reslt = pgpug_content_pane_append_page (self->priv->content_pane, tab, 0); break; case PGPUG_PANE_DETAIL: reslt = folding_tab_pane_append_page (FOLDING_TAB_PANE (self->priv->detail_pane), view, gtk_label_new (label_text)); break; default: WARN_MSG("PgpugWindow: install pane: invalid location specified."); } if (reslt >= 0) { pgpug_window_install_pane_data (self, tab, location); }else { g_hash_table_remove (self->priv->view_pane_map, view); } return reslt; }
BOOL OpenContext::ClearHaltDevice(LPUKWD_ENDPOINT_INFO lpEndpointInfo) { MutexLocker lock(mMutex); DevicePtr dev (mDevice->GetDeviceList(), lpEndpointInfo->lpDevice); if (!Validate(dev)) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Interface can't be used if device has closed if (dev->Closed()) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Find the interface for this device DWORD dwInterface; if (!dev->FindInterface(lpEndpointInfo->Endpoint, dwInterface)) { ERROR_MSG((TEXT("USBKWrapperDrv!OpenContext::ClearHalt() - ") TEXT("failed to find interface for endpoint %d on device 0x%08x\r\n"), lpEndpointInfo->Endpoint, lpEndpointInfo->lpDevice)); SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // See if it's already been claimed if (!dev->InterfaceClaimed(dwInterface, this)) { WARN_MSG((TEXT("USBKWrapperDrv!OpenContext::ClearHalt() - ") TEXT("using interface %d on device 0x%08x without claiming\r\n"), dwInterface, lpEndpointInfo->lpDevice)); if (!dev->ClaimInterface(dwInterface, this)) { return FALSE; } } return dev->ClearHaltDevice(dwInterface, lpEndpointInfo->Endpoint); }
void pgpug_window_set_pane_permanent (PgpugWindow *self, PgpugPane *tab) { g_return_if_fail (PGPUG_IS_WINDOW (self)); g_return_if_fail (PGPUG_IS_PANE (tab)); /* check if the pane already set as permanent */ gint elem_index = g_list_index (self->priv->permanent_panes, tab); if (elem_index>=0){ WARN_MSG ("PgpugWindow: pane %s is already set as permanent", pgpug_pane_get_menu_text (tab)); return; } /* Increase references count to preserve pane from destroying when removed from container*/ g_object_ref (tab); self->priv->permanent_panes = g_list_append (self->priv->permanent_panes, tab); /* rebuild the View menu */ pgpug_window_rebuild_view_menu (self); }
void init( dcp_info_t * info, unsigned long alloc_size ) { int wsize; MPI_Comm_size(MPI_COMM_WORLD, &wsize); MPI_Comm_rank(MPI_COMM_WORLD, &grank); dictionary* ini; if (access("config.fti", R_OK) == 0) { ini = iniparser_load("config.fti"); if (ini == NULL) { WARN_MSG("failed to parse FTI config file!"); exit(EXIT_FAILURE); } } else { EXIT_STD_ERR("cannot access FTI config file!"); } finalTag = (int)iniparser_getint(ini, "Advanced:final_tag", 3107); numHeads = (int)iniparser_getint(ini, "Basic:head", 0); int nodeSize = (int)iniparser_getint(ini, "Basic:node_size", -1); headRank = grank - grank%nodeSize; char* env = getenv( "TEST_MODE" ); if( env ) { if( strcmp( env, "ICP" ) == 0 ) { info->test_mode = TEST_ICP; INFO_MSG("TEST MODE -> ICP"); } else if ( strcmp( env, "NOICP") == 0 ) { info->test_mode = TEST_NOICP; INFO_MSG("TEST MODE -> NOICP"); } else { info->test_mode = TEST_NOICP; INFO_MSG("TEST MODE -> NOICP"); } } else { info->test_mode = TEST_NOICP; INFO_MSG("TEST MODE -> NOICP"); } //DBG_MSG("alloc_size: %lu",0,alloc_size); init_share(); // init pattern pat = (uint32_t) rand(); // protect pattern and xor_info FTI_InitType( &FTI_UI, UI_UNIT ); FTI_Protect( PAT_ID, &pat, 1, FTI_UI ); FTI_InitType( &FTI_XOR_INFO, sizeof(xor_info_t) ); FTI_Protect( XOR_INFO_ID, info->xor_info, NUM_DCKPT, FTI_XOR_INFO ); FTI_Protect( NBUFFER_ID, &info->nbuffer, 1, FTI_INTG ); // check if alloc_size is sufficiant large if ( alloc_size < 101 ) EXIT_CFG_ERR("insufficiant allocation size"); // determine number of buffers usleep(5000*grank); srand(get_seed()); if ( FTI_Status() == 0 ) { info->nbuffer = rand()%10+1; } else { FTI_RecoverVar( NBUFFER_ID ); } // initialize structure info->buffer = (void**) malloc(info->nbuffer*sizeof(void*)); info->size = (unsigned long*) malloc(info->nbuffer*sizeof(unsigned long)); info->oldsize = (unsigned long*) malloc(info->nbuffer*sizeof(unsigned long)); info->hash = (unsigned char**) malloc(info->nbuffer*sizeof(unsigned char*)); int idx; for ( idx=0; idx<info->nbuffer; ++idx ) { info->buffer[idx] = NULL; info->hash[idx] = (unsigned char*) malloc(MD5_DIGEST_LENGTH); } allocate_buffers( info, alloc_size ); generate_data( info ); init_srand(); }
GdkPixbufAnimation* pgpug_animated_icon (PgpugPixEnum icon_id, gint size) { g_return_val_if_fail (icon_id < PIX_NUMBER, NULL); GdkPixbufSimpleAnim *result = NULL; PgpugPixEntry entry = icon_entries_array [icon_id]; /* assert that ids are in order */ g_return_val_if_fail (entry.id == icon_id, NULL); GPtrArray *frames_array = g_ptr_array_new (); GtkIconTheme* theme; GdkPixbuf *pixbuf; GError *error = NULL, *error_anim = NULL; theme = gtk_icon_theme_get_default (); pixbuf = gtk_icon_theme_load_icon (theme, entry.name, size, GTK_ICON_LOOKUP_FORCE_SIZE, &error); if (error == NULL && pixbuf != NULL) { DEBG_MSG ("Loaded icon with name %s", entry.name); //it's a static image g_ptr_array_add (frames_array, (gpointer)pixbuf); }else{ //else try to get frame sequence gchar *name_template = g_strconcat (entry.name, "%02d", NULL); int i = 1; do { gchar *name = g_strdup_printf (name_template, i++); pixbuf = gtk_icon_theme_load_icon (theme, name, size, GTK_ICON_LOOKUP_FORCE_SIZE, &error_anim); if (pixbuf != NULL){ DEBG_MSG ("Loaded animation frame with name %s, address %p", name, pixbuf); g_ptr_array_add (frames_array, (gpointer)pixbuf); } g_free (name); } while (error_anim == NULL && i < 100); g_free (name_template); } if (frames_array->len != 0){ //construct animation result = gdk_pixbuf_simple_anim_new (size, size, frames_array->len); guint i; for (i = 0;i < frames_array->len; i++) gdk_pixbuf_simple_anim_add_frame (result, frames_array->pdata[i]); } else{ //we didn't find any images gchar **search_paths; gint index; gchar *search_path_str; gtk_icon_theme_get_search_path (theme, &search_paths, &index); search_path_str = g_strjoinv ("\n", search_paths); WARN_MSG ("Icon with name \"%s\" can not be loaded.\n" "Icon search paths are: \n%s\n" "Error message: %s", entry.name, search_path_str, error->message); g_strfreev (search_paths); g_free (search_path_str); } g_ptr_array_foreach (frames_array, (GFunc)g_object_unref, NULL); g_ptr_array_free (frames_array, TRUE); if (error != NULL) g_error_free (error); if (error_anim != NULL) g_error_free (error_anim); return GDK_PIXBUF_ANIMATION (result); }
static void config_file_walk(config_fn_walk_cb_t fn_cb, config_fn_walk_junk_cb_t fn_junk_cb, void *data) { FILE *data_file; char buf[BUFSIZ], e_conf[BUFSIZ]; char *key, *value; data_file = fopen(path_conf, "r"); EXIT_IF(data_file == NULL, _("failed to open configuration file")); pthread_mutex_lock(&nbar.mutex); for (;;) { if (fgets(buf, sizeof buf, data_file) == NULL) break; io_extract_data(e_conf, buf, sizeof buf); if (*e_conf == '\0' || *e_conf == '#') { if (fn_junk_cb) fn_junk_cb(buf, data); continue; } key = e_conf; value = strchr(e_conf, '='); if (value) { *value = '\0'; value++; } else { EXIT(_("invalid configuration directive: \"%s\""), e_conf); } if (strcmp(key, "auto_save") == 0 || strcmp(key, "auto_gc") == 0 || strcmp(key, "periodic_save") == 0 || strcmp(key, "confirm_quit") == 0 || strcmp(key, "confirm_delete") == 0 || strcmp(key, "skip_system_dialogs") == 0 || strcmp(key, "skip_progress_bar") == 0 || strcmp(key, "calendar_default_view") == 0 || strcmp(key, "week_begins_on_monday") == 0 || strcmp(key, "color-theme") == 0 || strcmp(key, "layout") == 0 || strcmp(key, "side-bar_width") == 0 || strcmp(key, "notify-bar_show") == 0 || strcmp(key, "notify-bar_date") == 0 || strcmp(key, "notify-bar_clock") == 0 || strcmp(key, "notify-bar_warning") == 0 || strcmp(key, "notify-bar_command") == 0 || strcmp(key, "notify-all") == 0 || strcmp(key, "output_datefmt") == 0 || strcmp(key, "input_datefmt") == 0 || strcmp(key, "notify-daemon_enable") == 0 || strcmp(key, "notify-daemon_log") == 0) { WARN_MSG(_("Pre-3.0.0 configuration file format detected, " "please upgrade running `calcurse-upgrade`.")); } if (value && (*value == '\0' || *value == '\n')) { /* Backward compatibility mode. */ if (fgets(buf, sizeof buf, data_file) == NULL) break; io_extract_data(e_conf, buf, sizeof buf); if (*e_conf == '#') *e_conf = '\0'; value = e_conf; } fn_cb(key, value, data); } file_close(data_file, __FILE_POS__); pthread_mutex_unlock(&nbar.mutex); }
int main(int argc, char * argv[]) { Util::Config conf(argv[0]); mistIn conv(&conf); if (conf.parseArgs(argc, argv)) { std::string streamName = conf.getString("streamname"); conv.argumentsParsed(); IPC::semaphore playerLock; if (conv.needsLock()) { if (streamName.size()) { char semName[NAME_BUFFER_SIZE]; snprintf(semName, NAME_BUFFER_SIZE, SEM_INPUT, streamName.c_str()); playerLock.open(semName, O_CREAT | O_RDWR, ACCESSPERMS, 1); if (!playerLock.tryWait()) { DEBUG_MSG(DLVL_DEVEL, "A player for stream %s is already running", streamName.c_str()); return 1; } } } conf.activate(); uint64_t reTimer = 0; while (conf.is_active) { pid_t pid = fork(); if (pid == 0) { if (conv.needsLock()) { playerLock.close(); } return conv.run(); } if (pid == -1) { DEBUG_MSG(DLVL_FAIL, "Unable to spawn player process"); if (conv.needsLock()) { playerLock.post(); } return 2; } //wait for the process to exit int status; while (waitpid(pid, &status, 0) != pid && errno == EINTR) { if (!conf.is_active) { DEBUG_MSG(DLVL_DEVEL, "Shutting down input for stream %s because of signal interrupt...", streamName.c_str()); Util::Procs::Stop(pid); } continue; } //if the exit was clean, don't restart it if (WIFEXITED(status) && (WEXITSTATUS(status) == 0)) { DEBUG_MSG(DLVL_MEDIUM, "Input for stream %s shut down cleanly", streamName.c_str()); break; } #if DEBUG >= DLVL_DEVEL WARN_MSG("Aborting autoclean; this is a development build."); #else conv.onCrash(); #endif if (DEBUG >= DLVL_DEVEL) { DEBUG_MSG(DLVL_DEVEL, "Input for stream %s uncleanly shut down! Aborting restart; this is a development build.", streamName.c_str()); break; } else { DEBUG_MSG(DLVL_DEVEL, "Input for stream %s uncleanly shut down! Restarting...", streamName.c_str()); Util::wait(reTimer); reTimer += 1000; } } if (conv.needsLock()) { playerLock.post(); playerLock.unlink(); playerLock.close(); } } return 0; }
void LinkBackupThread::run() { if (!::getCopyLinkUtil().setHashType(m_backupSet.getHashMethod())) { ERROR_MSG(QString(tr("Failed to setup hash generator.")), 0); return; } ::getCopyLinkUtil().resetStats(); setOldEntries(nullptr); setCurrentEntries(new DBFileEntries()); m_cancelRequested = false; m_previousDirRoot = newestBackDirectory(m_backupSet.getToPath()); if (m_previousDirRoot.length() > 0) { INFO_MSG(QString(tr("Found previous backup in %1")).arg(m_previousDirRoot), 1); QString previousDBFileEntries = findHashFileCaseInsensitive(m_previousDirRoot, m_backupSet.getHashMethod()); if (previousDBFileEntries.isEmpty()) { WARN_MSG(QString(tr("Although a previous backup was found in %1, file entries were not found for hash method %2.")).arg(m_previousDirRoot, m_backupSet.getHashMethod()), 1); } else { setOldEntries(DBFileEntries::read(previousDBFileEntries)); INFO_MSG(QString(tr("Found %1 entries in previous backup.")).arg(numOldEntries()), 1); } } else { WARN_MSG(QString(tr("No previous backup found.")), 1); } if (m_oldEntries == nullptr) { m_oldEntries = new DBFileEntries(); } m_toDirRoot = createBackDirectory(m_backupSet.getToPath()); QDir topFromDir(m_backupSet.getFromPath()); // Name of the directory that is backed up without the path. QString topFromDirName = topFromDir.dirName(); if (!topFromDir.exists() || topFromDirName.length() == 0) { WARN_MSG(QString(tr("Diretcory does not exist, or no directory name in %1, aborting backup.")).arg(m_backupSet.getFromPath()), 1); return; } QString canonicalPath = topFromDir.canonicalPath(); m_fromDirWithoutTopDirName = canonicalPath.left(canonicalPath.length() - topFromDirName.length()); QDir toDirLocation(m_toDirRoot); toDirLocation.mkdir(topFromDirName); toDirLocation.cd(topFromDirName); DEBUG_MSG(QString(tr("toDirRoot:%1 topFromDirName:%2 m_fromDir:%3")).arg(m_toDirRoot, topFromDirName, canonicalPath), 1); INFO_MSG(QString(tr("toDirRoot:%1 topFromDirName:%2 m_fromDir:%3")).arg(m_toDirRoot, topFromDirName, canonicalPath), 0); processDir(topFromDir, toDirLocation); TRACE_MSG(QString("Ready to write final hash summary %1").arg(m_toDirRoot + "/" + m_backupSet.getHashMethod() + ".txt"), 1); m_currentEntries->write(m_toDirRoot + "/" + m_backupSet.getHashMethod() + ".txt"); INFO_MSG(QString(tr("Backup finished.")), 0); INFO_MSG(::getCopyLinkUtil().getStats(), 0); }
/* * parse the packet and send the fake reply */ static void remote_browser(struct packet_object *po) { char *tmp, *p, *q; char *url, *host; char *command; char **param = NULL; int i = 0, k = 0; /* the client is making a request */ if (po->DATA.disp_len != 0 && strstr((const char*)po->DATA.disp_data, "GET")) { /* I'm the sender, opening a browser with a request coming by me will trigger a loop in this function! */ if(ip_addr_is_ours(&po->L3.src) == E_FOUND || ip_addr_is_ours(&po->L3.src) == E_BRIDGE) return; /* I'm not the sender, I can safely open the browser, the GET triggered by it shouldn't cause bad effects */ tmp = strdup((const char*)po->DATA.disp_data); /* get the Host: directive */ host = strstr(tmp, "Host: "); if (host != NULL) { host = host + 6; // 6 is like strlen("Host: "); if ((p = strstr(host, "\r\n")) != NULL) *p = 0; } else goto bad; /* null terminate the request before the HTTP/x.x */ p = strstr(tmp, " HTTP"); if (p != NULL) *p = 0; else goto bad; /* get the requested url */ url = tmp + 4; // 4 is like strlen("GET "); /* parse only pages, not images or other amenities */ if (!good_page(url)) goto bad; /* fill the command */ command = strdup(GBL_CONF->remote_browser); str_replace(&command, "%host", host); str_replace(&command, "%url", url); USER_MSG("REMOTE COMMAND: %s\n", command); /* split the string in the parameter array */ for (p = ec_strtok(command, " ", &q); p != NULL; p = ec_strtok(NULL, " ", &q)) { /* allocate the array */ SAFE_REALLOC(param, (i + 1) * sizeof(char *)); /* copy the tokens in the array */ param[i++] = strdup(p); } /* NULL terminate the array */ SAFE_REALLOC(param, (i + 1) * sizeof(char *)); param[i] = NULL; /* execute the script */ if (fork() == 0) { /* chrome won't start as root, changing UID in order to prevent this and for more security in the browser context */ /* the following line has been commented since some Penetration Testing distros can run only as root */ /*setuid(1000);*/ u_int uid, gid; DEBUG_MSG("drop_privs: getuid(%d) \n", getuid()); /* are we root ? */ if (getuid() == 0) { gid = uid = 1000; DEBUG_MSG("drop_privs: setuid(%d) setgid(%d)\n", uid, gid); /* drop to a good uid/gid ;) */ if ( setgid(gid) < 0 ) DEBUG_MSG("setgid() FAILED\n"); if ( setuid(uid) < 0 ) DEBUG_MSG("setuid() FAILED\n"); DEBUG_MSG("privs: UID: %d %d GID: %d %d\n", (int)getuid(), (int)geteuid(), (int)getgid(), (int)getegid() ); DEBUG_MSG("Privileges dropped to UID %d GID %d...\n\n", (int)getuid(), (int)getgid() ); /* "nobody" cannot open a browser */ } else if(getuid() == 65535) WARN_MSG("your ec_gid and ec_uid in etter.conf file are set to nobody (65535), you probably cannot open a new browser\n"); execvp(param[0], param); WARN_MSG("Cannot launch the default browser (command: %s), please edit your etter.conf file and put a valid value in remote_browser field\n", GBL_CONF->remote_browser); _exit(-E_INVALID); } //to free the char **param for(k= 0; k < i; ++k) SAFE_FREE(param[k]); SAFE_FREE(param); SAFE_FREE(command); bad: SAFE_FREE(tmp); } }
BOOL UsbDeviceList::AttachDevice( USB_HANDLE hDevice, LPCUSB_FUNCS lpUsbFuncs, LPCUSB_INTERFACE lpInterface, LPCWSTR szUniqueDriverId, LPBOOL fAcceptControl, LPCUSB_DRIVER_SETTINGS lpDriverSettings, DWORD dwUnused) { unsigned char bus = 0, address = 0; unsigned long session_id = 0; MutexLocker lock(mMutex); (void) szUniqueDriverId; // In future allowing some filtering based on lpDriverSettings // here could be useful. (void) lpDriverSettings; (void) dwUnused; // Default to accepting control of device, until we find a reason not to. *fAcceptControl = TRUE; LPCUSB_DEVICE device = lpUsbFuncs->lpGetDeviceInfo(hDevice); // Retrieve interface filter list from registry if not already done so FetchInterfaceFilters(lpUsbFuncs, szUniqueDriverId); // If we're attaching for an interface only, then refuse if the interface is // in our filter list. Else, if we're attaching for a device only then refuse if // we are already attached (we may be trying to find other drivers). if (lpInterface) { DWORD index; if (FindFilterForInterface(device, lpInterface, &index)) { IFACEFILTER_MSG((TEXT("USBKWrapperDrv: Interface %i matches filter %s, not attaching\r\n"), lpInterface->Descriptor.bInterfaceNumber, mInterfaceFilters[index].name)); (*fAcceptControl) = FALSE; return FALSE; } } else { for (PtrArray<UsbDevice>::iterator it = mDevices.begin(); it != mDevices.end(); ++it) { if ((*it)->IsSameDevice(hDevice)) { WARN_MSG((TEXT("USBKWrapperDrv: Already attached to device, not attaching again\r\n"))); (*fAcceptControl) = FALSE; return FALSE; } } } // If we're attaching for the entire device, locate any interface filters // matching the interfaces of this device. // // If any matching filter specifies NO_ATTACH, we refuse to accept control // of the device. We only match one filter to an interface. If multiple // filters match, only the first shall be used. BOOL filterMatches = FALSE; ArrayAutoPtr<DWORD> filters; if (!lpInterface && mNumInterfaceFilters > 0) { filters = new (std::nothrow) DWORD[device->lpActiveConfig->dwNumInterfaces]; if (!filters.Get()) { ERROR_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::AttachDevice") TEXT(" - out of memory allocating filter match list"))); *fAcceptControl = FALSE; return FALSE; } for (DWORD i = 0; i < device->lpActiveConfig->dwNumInterfaces && *fAcceptControl; i++) { DWORD index; if (FindFilterForInterface(device, &device->lpActiveConfig->lpInterfaces[i], &index)) { filters.Set(i, index); filterMatches = TRUE; if (mInterfaceFilters[index].noAttach) { IFACEFILTER_MSG((TEXT("USBKWrapperDrv: Interface %u matches filter %s") TEXT(", not accepting device control\r\n"), device->lpActiveConfig->lpInterfaces[i].Descriptor.bInterfaceNumber, mInterfaceFilters[index].name)); *fAcceptControl = FALSE; } } else { filters.Set(i, mNumInterfaceFilters); } } } // If we're not accepting control, finish now if (!*fAcceptControl) { return FALSE; } // Allocate a fake bus and address for this device // as WinCE doesn't expose the bus and address to // USB Function Drivers. if (!mBusAllocator.Alloc(bus, address, session_id)) { ERROR_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::AttachDevice") TEXT(" - failed to allocate fake USB bus and adress for handle 0x%08x\r\n"), hDevice)); *fAcceptControl = FALSE; return FALSE; } std::auto_ptr<UsbDevice> ptr ( new (std::nothrow) UsbDevice(bus, address, session_id)); if (!ptr.get()) { mBusAllocator.Free(bus, address, session_id); ERROR_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::AttachDevice") TEXT(" - failed to allocate new USB device for handle 0x%08x\r\n"), hDevice)); *fAcceptControl = FALSE; return FALSE; } if (!ptr.get()->Init(hDevice, lpUsbFuncs, lpInterface)) { ERROR_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::AttachDevice") TEXT(" - failed to initialise new USB device for handle 0x%08x\r\n"), hDevice)); *fAcceptControl = FALSE; return FALSE; } if (!mDevices.insert(ptr.get())) { ERROR_MSG((TEXT("USBKWrapperDrv!UsbDeviceList::AttachDevice") TEXT(" - failed to store new USB device for handle 0x%08x\r\n"), hDevice)); *fAcceptControl = FALSE; return FALSE; } // Release any interfaces matching filters if (filterMatches) { // Try to release any interfaces that match our filters (if we have any) BOOL failedToAttach = FALSE; BOOL attachSuccesful = FALSE; for (DWORD i = 0; i < device->lpActiveConfig->dwNumInterfaces && !failedToAttach; i++) { if (filters.Get(i) < mNumInterfaceFilters) { UCHAR bInterfaceNumber = device->lpActiveConfig->lpInterfaces[i].Descriptor.bInterfaceNumber; IFACEFILTER_MSG((TEXT("USBKWrapperDrv: Interface %u matches filter %s") TEXT(", attaching kernel driver\r\n"), bInterfaceNumber, mInterfaceFilters[filters.Get(i)].name)); if (ptr.get()->AttachKernelDriverForInterface(bInterfaceNumber)) { attachSuccesful = TRUE; } else if (!attachSuccesful) { // Only resort to finding a driver for the entire device, if we have // not already attached drivers to other interfaces. failedToAttach = TRUE; } } } if (failedToAttach) { // Try to find a driver for the entire device. We will release all of our interfaces, // but still reserve the right to send arbitrary control transfers. IFACEFILTER_MSG((TEXT("USBKWrapperDrv: Attaching kernel driver for entire device\r\n"))); if (!ptr.get()->AttachKernelDriverForDevice()) { // There really is no other driver willing to control this device! IFACEFILTER_MSG((TEXT("USBKWrapperDrv: Unable to attach kernel driver for entire ") TEXT("device (error %u), retaining control\r\n"), GetLastError())); } } } ptr.release(); return TRUE; }
static int btp_xfer( bt_unit_t *unit_p, bt_dev_t type, bt_accessflag_t dir, void * usr_data_p, unsigned long dest_addr, size_t length, size_t *xferred_bytes_p ) { FUNCTION("btp_xfer"); LOG_UNIT(unit_p->unit_number); void *data_p; int dma_flag; int data_width; size_t length_remaining = length; unsigned int start, need; bt_data32_t mreg_value; bt_error_t retval = BT_SUCCESS; unsigned int inx; unsigned long pci_addr; bt_data32_t ldma_addr; struct page **pages; int ret, i, write; bt_data32_t usr_curr_offset; caddr_t kbuf_p; unsigned int nr_pages; FENTRY; /* ** Haven't transferred any data yet */ *xferred_bytes_p = 0; /* ** Adjust for the extended remote ram window. */ if (type == BT_AXSRE) { dest_addr |= RE_ADJUST; } /* ** Normally you would have the while loop in the read and write routines. ** ** Since both would require the same loop, I've decided to just put it ** in this routine instead. */ while ((length_remaining > 0) && (BT_SUCCESS == retval)) { int xferred_length = 0; int requested_length = length_remaining; /* ** Setup direction and current offset */ if (dir == BT_WR) { write = 1; } else { write = 0; } usr_curr_offset = (bt_data32_t) ((bt_devaddr_t) usr_data_p & (PAGE_SIZE -1)); /* ** Malloc a scatter/gather list */ nr_pages = (usr_curr_offset + requested_length + ~PAGE_MASK) >> PAGE_SHIFT; pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL); if (!pages) { WARN_STR("Failed to kmalloc scatter/gather list.\n"); retval = BT_EIO; goto btp_xfer_end; } /* ** Translate the user pages to physical addresses ** store in scatter/gather list */ down_read(¤t->mm->mmap_sem); ret = get_user_pages(current, current->mm, (unsigned long) usr_data_p, nr_pages, write, 1, pages, NULL); up_read(¤t->mm->mmap_sem); if (ret < nr_pages) { WARN_STR("Failed to create scatter/gather list for user buffer.\n"); for (i = 0; i < ret; i++) { page_cache_release(pages[i]); } kfree(pages); retval = BT_EIO; goto btp_xfer_end; } /* ** Determine whether we do DMA or PIO */ btk_dma_pio(unit_p, type, (bt_devaddr_t) usr_data_p, dest_addr, &requested_length, &dma_flag, &data_width, &start, &need); #define BTP_FREE_MREG if (dma_flag) { \ btk_mutex_enter(&unit_p->mreg_mutex); \ (void) btk_bit_free(unit_p->sdma_aval_p, start, need); \ btk_mutex_exit(&unit_p->mreg_mutex); \ btk_mutex_exit(&unit_p->dma_mutex); \ } \ for (i = 0; i < nr_pages; i++) { \ if (BT_RD == dir) { \ set_page_dirty_lock(pages[i]); \ } \ page_cache_release(pages[i]); \ } \ kfree(pages); /* ** Can't let PIO go past one page */ if (!dma_flag) { if ((usr_curr_offset + requested_length) > PAGE_SIZE) { requested_length = PAGE_SIZE - usr_curr_offset; } need = 1; } TRC_MSG(BT_TRC_RD_WR, (LOG_FMT "Transferring %d bytes data to 0x%lx using %s.\n", LOG_ARG, requested_length, dest_addr, ((dma_flag) ? "DMA" : "PIO"))); if (dma_flag) { /* ** Setup vme address, address modifier, and function code */ mreg_value = 0; btk_setup_mreg(unit_p, type, &mreg_value, BT_OP_DMA); /* ** Program up mapping RAM */ for (inx = start, i = 0; inx < (start + need); inx++, i++) { pci_addr = (unsigned long) page_to_phys(pages[i]); if (0 == pci_addr) { WARN_STR("Kernel to PCI address translation failed.\n"); retval = BT_EIO; goto end_xfer_loop; } mreg_value &= ~BT_MREG_ADDR_MASK; mreg_value |= (pci_addr & BT_MREG_ADDR_MASK); btk_put_mreg(unit_p, inx, BT_LMREG_DMA_2_PCI, mreg_value); if ( (btk_get_mreg(unit_p, inx, BT_LMREG_DMA_2_PCI)) != mreg_value ) { WARN_MSG((LOG_FMT "Verify Write BT_LMREG_DMA_2_PCI mapping register mr_idx = 0x%.1X failed.\n", LOG_ARG, inx)); retval = BT_EIO; goto end_xfer_loop; } } /* ** Now we need to get the DMA semaphore ** Note this routines does nothing in a single driver situtation */ retval = btk_take_drv_sema(unit_p); if (retval != BT_SUCCESS) { goto end_xfer_loop; } /* ** If old Nanobus card, we must stop PIO from occuring */ if (IS_CLR(unit_p->bt_status, BT_NEXT_GEN)) { btk_rwlock_wr_enter(&unit_p->hw_rwlock); } /* ** Do the DMA */ ldma_addr = (bt_data32_t) ((start * BT_PAGE_SIZE) + usr_curr_offset); xferred_length = requested_length; retval = btk_dma_xfer(unit_p, type, ldma_addr, (bt_data32_t) dest_addr, &xferred_length, (dir == BT_RD) ? BT_READ : BT_WRITE, data_width); if (IS_CLR(unit_p->bt_status, BT_NEXT_GEN)) { btk_rwlock_wr_exit(&unit_p->hw_rwlock); } btk_give_drv_sema(unit_p); /* ** Do a PIO */ } else { /* ** Perform the proper direction PIO data transfer */ kbuf_p = kmap(pages[0]); if (kbuf_p == NULL) { INFO_STR("Failed to get kernel pointer to PIO user buffer"); retval = BT_EIO; } else { data_p = (void *) (kbuf_p + usr_curr_offset); xferred_length = requested_length; retval = btk_pio_xfer(unit_p, type, data_p, (unsigned long) dest_addr, &xferred_length, (dir == BT_RD) ? BT_READ : BT_WRITE); kunmap(pages[0]); } } end_xfer_loop: BTP_FREE_MREG; TRC_MSG(BT_TRC_RD_WR, (LOG_FMT "%s transfer done 0x%x bytes transferred, retval %d\n", LOG_ARG, ((dma_flag) ? "DMA" : "PIO"), xferred_length, retval)); usr_data_p = (caddr_t) usr_data_p + xferred_length; dest_addr += xferred_length; length_remaining -= xferred_length; } btp_xfer_end: *xferred_bytes_p = length - length_remaining; FEXIT(retval); return retval; }