static int tierfs_fsync(struct file *file, loff_t start, loff_t end, int datasync) { int rc; TRACE_ENTRY(); rc = filemap_write_and_wait(file->f_mapping); if (rc) return rc; TRACE_EXIT(); return vfs_fsync(tierfs_file_to_lower(file), datasync); }
/*Creating and Destroying Functions*/ Bool CreateSurface(GALINFOPTR galInfo, PixmapPtr pPixmap, Viv2DPixmapPtr pPix) { GenericSurfacePtr surf = gcvNULL; VIVGPUPtr gpuctx = (VIVGPUPtr) galInfo->mGpu; gctUINT alignedWidth, alignedHeight; gctUINT bytesPerPixel; alignedWidth = gcmALIGN(pPixmap->drawable.width, WIDTH_ALIGNMENT); alignedHeight = gcmALIGN(pPixmap->drawable.height, HEIGHT_ALIGNMENT); bytesPerPixel = BITSTOBYTES(pPixmap->drawable.bitsPerPixel); /*QUICK FIX*/ if (bytesPerPixel < 2) { bytesPerPixel = 2; } if (!VIV2DGPUSurfaceAlloc(gpuctx, alignedWidth, alignedHeight, bytesPerPixel, &surf)) { TRACE_ERROR("Surface Creation Error\n"); TRACE_EXIT(FALSE); } pPix->mVidMemInfo = surf; TRACE_EXIT(TRUE); }
COM::COM() { TRACE_ENTER(); HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); if(!SUCCEEDED(hr)) { TRACE_PRINT1("CoInitializeEx: error, errCode = 0x%08x.", hr); } TRACE_EXIT(); }
int getIntDevID(TCHAR strDevID[]) //DevID is in form like: "ROOT\\NET\\0008" { TRACE_ENTER(); int iDevID = -1; int iMatched = _stscanf_s(strDevID, _T("ROOT\\NET\\%04d"), &iDevID); TRACE_PRINT2("_stscanf_s: iMatched = %d, iDevID = %d.", iMatched, iDevID); if (iMatched != 1) iDevID = -1; TRACE_EXIT(); return iDevID; }
struct isert_cmnd *isert_tx_pdu_alloc(struct isert_connection *isert_conn, size_t size) { struct isert_cmnd *pdu = NULL; int err; TRACE_ENTRY(); pdu = isert_pdu_alloc(); if (unlikely(!pdu)) { pr_err("Failed to alloc pdu\n"); goto out; } err = isert_alloc_for_rdma(pdu, 4, isert_conn); if (unlikely(err)) { pr_err("Failed to alloc sge and wr for tx pdu\n"); goto out; } err = isert_buf_alloc_data_buf(isert_conn->isert_dev->ib_dev, &pdu->buf, size, DMA_TO_DEVICE); if (unlikely(err)) { pr_err("Failed to alloc tx pdu buf sz:%zd\n", size); goto buf_alloc_failed; } err = isert_pdu_tx_buf_init(pdu, isert_conn); if (unlikely(err < 0)) { pr_err("Failed to init tx pdu wr:%p size:%zd err:%d\n", &pdu->wr, size, err); goto buf_init_failed; } isert_tx_pdu_init(pdu, isert_conn); isert_pdu_set_hdr_plain(pdu); list_add_tail(&pdu->pool_node, &isert_conn->tx_free_list); goto out; buf_init_failed: isert_buf_release(&pdu->buf); buf_alloc_failed: isert_pdu_kfree(pdu); pdu = NULL; out: TRACE_EXIT(); return pdu; }
void FileManager_impl::move (const char* sourceFileName, const char* destinationFileName) throw (CORBA::SystemException, CF::InvalidFileName, CF::FileException) { TRACE_ENTER(FileManager_impl); // Validate absolute file names if (sourceFileName[0] != '/' || !ossie::isValidFileName(sourceFileName)) { throw CF::InvalidFileName(CF::CF_EINVAL, "Invalid source file name"); } else if (destinationFileName[0] != '/' || !ossie::isValidFileName(destinationFileName)) { throw CF::InvalidFileName(CF::CF_EINVAL, "Invalid destination file name"); } else if (strcmp(sourceFileName, destinationFileName) == 0) { throw CF::InvalidFileName(CF::CF_EINVAL, "Destination file name is identical to source file name"); } LOG_TRACE(FileManager_impl, "Move " << sourceFileName << " to " << destinationFileName); // Lock the mount table shared to allow others to access the file system, // but prevent changes to the mount table itself. boost::shared_lock<boost::shared_mutex> lock(mountsLock); MountList::iterator sourceMount = getMountForPath(sourceFileName); MountList::iterator destMount = getMountForPath(destinationFileName); if (sourceMount == destMount) { // Source and destination are on the same file system... if (sourceMount == mountedFileSystems.end()) { // ...which is also the local file system. LOG_TRACE(FileManager_impl, "Moving locally"); FileSystem_impl::move(sourceFileName, destinationFileName); } else { // ...which is a remote file system. LOG_TRACE(FileManager_impl, "Moving locally on remote file system"); const std::string srcPath = sourceMount->getRelativePath(sourceFileName); const std::string dstPath = destMount->getRelativePath(destinationFileName); sourceMount->fs->move(srcPath.c_str(), dstPath.c_str()); } return; } LOG_TRACE(FileManager_impl, "Moving between filesystems"); // Perform a copy followed by a remove, which is the only way we can move // across file systems. This operation is not atomic, and making it atomic // across a distributed file system is difficult. If necessary, we can // acquire an exclusive lock which at least prevents anyone going through // the domain's FileManager from interfering with this operation. this->copy(sourceFileName, destinationFileName); this->remove(sourceFileName); TRACE_EXIT(FileManager_impl); }
void _test_suite::unregister_all_tests(void) { TRACE_ENTRY(); SERIALIZE_CALL_RECURSIVE(m_test_suite_lock); while(!m_test_map.empty()) { unregister_test(m_test_map.begin()->first); } m_test_map.clear(); TRACE_EXIT(); }
BOOL EraseLoopbackRecord() { TRACE_ENTER(); BOOL rv = TRUE; #ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE HKEY hKey; DWORD type; char buffer[BUFSIZE]; DWORD size = sizeof(buffer); DWORD dwWinPcapMode = 0; if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), 0, KEY_READ, &hKey) == ERROR_SUCCESS) { if (RegQueryValueExA(hKey, "WinPcapCompatible", 0, &type, (LPBYTE)buffer, &size) == ERROR_SUCCESS && type == REG_DWORD) { dwWinPcapMode = *((DWORD *) buffer); } else { TRACE_PRINT1("RegQueryValueExA(WinPcapCompatible) failed or not REG_DWORD: %#x\n", GetLastError()); dwWinPcapMode = 0; } RegCloseKey(hKey); } else { TRACE_PRINT2("%s\\Parameters) failed: %#x\n", NPCAP_SERVICE_REG_KEY_NAME, GetLastError()); dwWinPcapMode = 0; } if (dwWinPcapMode != 0 && !DeleteValueFromRegistry(_T("SYSTEM\\CurrentControlSet\\Services\\npf\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME)) { rv = FALSE; } #endif /* ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE */ if (!DeleteValueFromRegistry(NPCAP_REG_KEY_NAME, NPCAP_REG_LOOPBACK_VALUE_NAME)) { rv = FALSE; } if (!DeleteValueFromRegistry(NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME)) { rv = FALSE; } TRACE_EXIT(); return rv; }
_lexer_base::_lexer_base( __in const _lexer_base &other ) : m_character_column(other.m_character_column), m_character_column_length(other.m_character_column_length), m_character_position(other.m_character_position), m_character_row(other.m_character_row), m_character_type(other.m_character_type), m_raw_input(other.m_raw_input), m_source_path(other.m_source_path) { TRACE_ENTRY(); TRACE_EXIT(); }
void _lexer_base::reset(void) { TRACE_ENTRY(); SERIALIZE_CALL_RECURSIVE(m_lexer_base_lock); m_character_column = 0; m_character_column_length.clear(); m_character_position = 0; m_character_row = 0; m_character_type = lexer_base::determine_character_type(get_character()); TRACE_EXIT(); }
static long tierfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct file *lower_file = NULL; long rc = -ENOIOCTLCMD; TRACE_ENTRY(); if (tierfs_file_to_private(file)) lower_file = tierfs_file_to_lower(file); if (lower_file && lower_file->f_op && lower_file->f_op->compat_ioctl) rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg); TRACE_EXIT(); return rc; }
void _interpreter::run(void) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); parser::clear(); while(parser::has_next_statement()) { step(); } TRACE_EXIT("Return Value: 0x%x", NULL); }
/* 8x8 Mono Pattern Fills */ static void Permedia3SetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patternx, int patterny, int fg, int bg, int rop, unsigned int planemask) { GLINTPtr pGlint = GLINTPTR(pScrn); TRACE_ENTER("Permedia3SetupForMono8x8PatternFill"); REPLICATE(fg); pGlint->PM3_Render2D = PM3Render2D_AreaStippleEnable | PM3Render2D_SpanOperation | PM3Render2D_XPositive | PM3Render2D_YPositive | PM3Render2D_Operation_Normal; pGlint->PM3_Config2D = PM3Config2D_UseConstantSource | PM3Config2D_ForegroundROPEnable | PM3Config2D_ForegroundROP(rop) | PM3Config2D_FBWriteEnable; if ((rop!=GXclear)&&(rop!=GXset)&&(rop!=GXcopy)&&(rop!=GXcopyInverted)) pGlint->PM3_Config2D |= PM3Config2D_FBDestReadEnable; pGlint->PM3_AreaStippleMode = 1; /* Mirror stipple pattern horizontally */ #if X_BYTE_ORDER == X_BIG_ENDIAN pGlint->PM3_AreaStippleMode |= (1<<18); #endif pGlint->PM3_AreaStippleMode |= (2<<1); pGlint->PM3_AreaStippleMode |= (2<<4); if (bg != -1) { REPLICATE(bg); pGlint->PM3_Config2D |= PM3Config2D_OpaqueSpan; pGlint->PM3_AreaStippleMode |= 1<<20; GLINT_WAIT(12); GLINT_WRITE_REG(bg, BackgroundColor); } else GLINT_WAIT(11); GLINT_WRITE_REG((patternx & 0xFF), AreaStipplePattern0); GLINT_WRITE_REG((patternx & 0xFF00) >> 8, AreaStipplePattern1); GLINT_WRITE_REG((patternx & 0xFF0000) >> 16, AreaStipplePattern2); GLINT_WRITE_REG((patternx & 0xFF000000) >> 24, AreaStipplePattern3); GLINT_WRITE_REG((patterny & 0xFF), AreaStipplePattern4); GLINT_WRITE_REG((patterny & 0xFF00) >> 8, AreaStipplePattern5); GLINT_WRITE_REG((patterny & 0xFF0000) >> 16, AreaStipplePattern6); GLINT_WRITE_REG((patterny & 0xFF000000) >> 24, AreaStipplePattern7); GLINT_WRITE_REG(fg, PM3ForegroundColor); PM3_PLANEMASK(planemask); GLINT_WRITE_REG(pGlint->PM3_Config2D, PM3Config2D); TRACE_EXIT("Permedia3SetupForMono8x8PatternFill"); }
CDeskBand::~CDeskBand() { TRACE_ENTER("CDeskBand::~CDeskBand"); //this should have been freed in a call to SetSite(NULL), but just to be safe if (m_pSite) { m_pSite->Release(); m_pSite = NULL; } g_DllRefCount--; TRACE_MSG(g_DllRefCount); TRACE_EXIT(); }
_json_token::_json_token( __in const _json_token &other ) : json_uuid_class(other), m_line(other.m_line), m_source(other.m_source), m_subtype(other.m_subtype), m_text(other.m_text), m_type(other.m_type), m_value(other.m_value) { TRACE_ENTRY(); TRACE_EXIT("Return Value: 0x%x", 0); }
static void __exit exit_scst_modisk_driver(void) { TRACE_ENTRY(); #ifdef CONFIG_SCST_PROC scst_dev_handler_destroy_std_proc(&modisk_devtype_perf); scst_dev_handler_destroy_std_proc(&modisk_devtype); #endif scst_unregister_dev_driver(&modisk_devtype_perf); scst_unregister_dev_driver(&modisk_devtype); TRACE_EXIT(); return; }
void _json_token::set_metadata( __in const std::string &source, __in_opt size_t line ) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); m_source = source; m_line = line; TRACE_EXIT("Return Value: 0x%x", 0); }
void _json_token::set_type( __in type_t type, __in_opt type_t subtype ) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); m_type = type; m_subtype = subtype; TRACE_EXIT("Return Value: 0x%x", 0); }
uuid _interpreter::push_scope(void) { uuid result; TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); result = get_scope_factory()->generate().get_id(); m_scope_stack.push(result); TRACE_EXIT("Return Value: 0x%x", NULL); return result; }
void _interpreter::set( __in const std::string &input, __in_opt bool is_file ) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); parser::set(input, is_file); interpreter::clear(); TRACE_EXIT("Return Value: 0x%x", NULL); }
void _json_token_factory::clear(void) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); if(!m_initialized) { THROW_JSON_TOKEN_EXCEPTION(JSON_TOKEN_EXCEPTION_UNINITIALIZED); } m_token_map.clear(); TRACE_EXIT("Return Value: 0x%x", 0); }
CosEventChannelAdmin::EventChannel_ptr createEventChannel (const std::string& name) { TRACE_ENTER(EventChannelSupport); CosLifeCycle::GenericFactory_var factory = getEventChannelFactory(); if (CORBA::is_nil(factory)) { LOG_WARN(EventChannelSupport, "Event channel " << name << " not created"); TRACE_EXIT(EventChannelSupport); return CosEventChannelAdmin::EventChannel::_nil(); } CosLifeCycle::Key key; key.length(1); key[0].id = "EventChannel"; key[0].kind = "object interface"; std::string insName = name; CosLifeCycle::Criteria criteria; criteria.length(1); criteria[0].name = "InsName"; criteria[0].value <<= insName.c_str(); CosEventChannelAdmin::EventChannel_var eventChannel; LOG_TRACE(EventChannelSupport, "Creating event channel " << name); try { CORBA::Object_var obj = factory->create_object(key, criteria); eventChannel = CosEventChannelAdmin::EventChannel::_narrow(obj); } catch (const CosLifeCycle::InvalidCriteria&) { LOG_WARN(EventChannelSupport, "Invalid Criteria for creating event channel " << name); } catch (const CORBA::Exception& ex) { LOG_WARN(EventChannelSupport, "CORBA " << ex._name() << " exception creating event channel " << name); } TRACE_EXIT(EventChannelSupport); return eventChannel._retn(); }
vector<tstring> getWlanAdapterGuids() { TRACE_ENTER(); HANDLE hClient = NULL; WLAN_INTERFACE_INFO sInfo[64]; RPC_TSTR strGuid = NULL; vector<tstring> nstrWlanAdapterGuids; if (!initWlanFunctions()) { TRACE_PRINT("initWlanFunctions: error."); TRACE_EXIT(); return nstrWlanAdapterGuids; } if (OpenHandleAndCheckVersion(&hClient) != ERROR_SUCCESS) { TRACE_PRINT("OpenHandleAndCheckVersion: error."); TRACE_EXIT(); return nstrWlanAdapterGuids; } UINT nCount = EnumInterface(hClient, sInfo); for (UINT i = 0; i < nCount; ++i) { if (UuidToString(&sInfo[i].InterfaceGuid, &strGuid) == RPC_S_OK) { TRACE_PRINT1("EnumInterface: executing, strGuid = %s.", (TCHAR*) strGuid); nstrWlanAdapterGuids.push_back((TCHAR*) strGuid); RpcStringFree(&strGuid); } } TRACE_EXIT(); return nstrWlanAdapterGuids; }
static void dldwd_cs_detach(dev_link_t * link) { dev_link_t **linkp; dldwd_priv_t *priv = link->priv; TRACE_ENTER("dldwd"); /* Locate device structure */ for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) if (*linkp == link) break; if (*linkp == NULL) goto out; /* If the device is currently configured and active, we won't actually delete it yet. Instead, it is marked so that when the release() function is called, that will trigger a proper detach(). */ if (link->state & DEV_CONFIG) { #ifdef PCMCIA_DEBUG printk(KERN_DEBUG "orinoco_cs: detach postponed, '%s' " "still locked\n", link->dev->dev_name); #endif link->state |= DEV_STALE_LINK; goto out; } /* Break the link with Card Services */ if (link->handle) CardServices(DeregisterClient, link->handle); /* Unlink device structure, and free it */ *linkp = link->next; DEBUG(0, "orinoco_cs: detach: link=%p link->dev=%p\n", link, link->dev); if (link->dev) { DEBUG(0, "orinoco_cs: About to unregister net device %p\n", &priv->ndev); unregister_netdev(&priv->ndev); } kfree(priv->card); num_instances--; /* FIXME: Racy? */ out: TRACE_EXIT("dldwd"); } /* dldwd_cs_detach */
LRESULT CDeskBand::OnTimer(WPARAM wParam, LPARAM lParam) { TRACE_ENTER_MSG("CDeskBand::OnTimer", wParam << " " << lParam); if (m_TimerBox != NULL) { if (m_LastCopyData == 0 || difftime(time(NULL), m_LastCopyData) > 2) { m_TimerBox->set_enabled(false); m_TimerBox->update(false); } } TRACE_EXIT(); return 0; }
json_token & _json_token_factory::at( __in const json_uuid &id ) { TRACE_ENTRY(); SERIALIZE_CALL_RECUR(m_lock); if(!m_initialized) { THROW_JSON_TOKEN_EXCEPTION(JSON_TOKEN_EXCEPTION_UNINITIALIZED); } TRACE_EXIT("Return Value: 0x%x", 0); return find(id)->second; }
_json_token_factory::_json_token_factory( __in_opt json_sgl_cb dest ) : m_initialized(false) { TRACE_ENTRY(); if(dest) { std::atexit(dest); } else { std::atexit(json_token_factory_destroy); } TRACE_EXIT("Return Value: 0x%x", 0); }
static void isert_conn_timer_fn(unsigned long arg) { struct isert_conn_dev *conn_dev = (struct isert_conn_dev *)arg; struct iscsi_conn *conn = conn_dev->conn; TRACE_ENTRY(); conn_dev->timer_active = 0; PRINT_ERROR("Timeout on connection %p\n", conn_dev->conn); schedule_work(&conn->close_work); TRACE_EXIT(); }
DWORD InstallDriver(BOOL bWifiOrNormal) { DWORD nResult; TRACE_ENTER("InstallDriver"); // Get Path to Service INF File // ---------------------------- // The INF file is assumed to be in the same folder as this application... TCHAR szFileFullPath[_MAX_PATH]; nResult = GetServiceInfFilePath(szFileFullPath, MAX_PATH, bWifiOrNormal); if (nResult == 0) { TRACE_PRINT("Unable to get INF file path"); return 0; } //_tprintf( _T("INF Path: %s\n"), szFileFullPath ); HRESULT hr = S_OK; //_tprintf( _T("PnpID: %s\n"), NDISPROT_SERVICE_PNP_DEVICE_ID ); hr = InstallSpecifiedComponent(szFileFullPath, NDISLWF_SERVICE_PNP_DEVICE_ID, &GUID_DEVCLASS_NETSERVICE); if (hr != S_OK) { ErrMsg(hr, L"InstallSpecifiedComponent\n"); TRACE_EXIT("InstallDriver"); return 0; } TRACE_EXIT("InstallDriver"); return 1; }
Bool VIV2DGPUCtxDeInit(GALINFOPTR galInfo) { TRACE_ENTER(); gctBOOL ret = gcvTRUE; VIVGPUPtr gpuctx = gcvNULL; if (galInfo->mGpu == NULL) { TRACE_ERROR("GPU CTX IS NULL\n"); TRACE_EXIT(TRUE); } VDestroySurf(); gpuctx = (VIVGPUPtr) (galInfo->mGpu); ret = DestroyDevice(gpuctx->mDevice); if (ret != gcvTRUE) { TRACE_ERROR("ERROR WHILE DESTROYING DEVICE \n"); TRACE_EXIT(FALSE); } ret = DestroyDriver(gpuctx->mDriver); if (ret != gcvTRUE) { TRACE_ERROR("ERROR WHILE DESTROYING DRIVER\n"); TRACE_EXIT(FALSE); } TRACE_EXIT(TRUE); }