void cache_control::drain() { while (true) { std::shared_ptr<file_ma> target; while (true) { lock_guard<std::mutex> _lock(task_lock); if (terminal) return; if (priority_queue.empty()) { if (total_cache_size < max_cache_size) start_drain.wait(task_lock); else { auto res = std::max_element(cache_set.begin(), cache_set.end(), [](const std::shared_ptr<file_ma> &a, const std::shared_ptr<file_ma> &b) { return a->getcachesize() < b->getcachesize(); }); if (res != cache_set.end()) { target = *res; break; } } } else { auto x = priority_queue.begin(); target = std::move(*x); priority_queue.erase(x); break; } } assert(target); _DEBUG_OUT("task[%p] start drain,%u had cached\n", target->parent->get_guid(), total_cache_size.load()); target->do_write_back(); _DEBUG_OUT("%u left\n", total_cache_size.load()); } }
qi::Future<void> RemoteObject::metaDisconnect(SignalLink linkId) { unsigned int event = linkId >> 32; //disconnect locally qi::Future<void> fut = DynamicObject::metaDisconnect(linkId); if (fut.hasError()) { std::stringstream ss; ss << "Disconnection failure for " << linkId << ", error:" << fut.error(); qiLogWarning() << ss.str(); return qi::makeFutureError<void>(ss.str()); } boost::recursive_mutex::scoped_lock _lock(_localToRemoteSignalLinkMutex); LocalToRemoteSignalLinkMap::iterator it; it = _localToRemoteSignalLink.find(event); if (it == _localToRemoteSignalLink.end()) { qiLogWarning() << "Cant find " << event << " in the localtoremote signal map"; return fut; } qi::SignalLink toDisco = qi::SignalBase::invalidSignalLink; { RemoteSignalLinks &rsl = it->second; std::vector<SignalLink>::iterator vslit; vslit = std::find(rsl.localSignalLink.begin(), rsl.localSignalLink.end(), linkId); if (vslit != rsl.localSignalLink.end()) { rsl.localSignalLink.erase(vslit); } else { qiLogWarning() << "Cant find " << linkId << " in the remote signal vector (event:" << event << ")"; } //only drop the remote connection when no more local connection are registered if (rsl.localSignalLink.size() == 0) { toDisco = rsl.remoteSignalLink; _localToRemoteSignalLink.erase(it); } } if (toDisco != qi::SignalBase::invalidSignalLink) { TransportSocketPtr sock = _socket; if (sock && sock->isConnected()) return _self.async<void>("unregisterEvent", _service, event, toDisco); } return fut; }
//++ ------------------------------------------------------------------------------------ // Details: Wait for thread to stop. // Type: Method. // Args: None. // Return: MIstatus::success - Functional succeeded. // MIstatus::failure - Functional failed. // Throws: None. //-- bool CMIUtilThread::Join() { if (m_pThread != nullptr) { // Wait for this thread to die m_pThread->join(); // Scope the thread lock while we modify the pointer { CMIUtilThreadLock _lock(m_mutex); delete m_pThread; m_pThread = nullptr; } } return MIstatus::success; }
MBOOL IPostProcPipeBridge:: init() { MBOOL ret = MTRUE; Mutex::Autolock _lock(mLock); if ( 0 != mu4InitRefCount ) { mu4InitRefCount++; } else if ( (ret = getImp()->init()) ) { mu4InitRefCount = 1; } PIPE_DBG("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret); return ret; }
MBOOL IPostProcPipeBridge:: uninit() { MBOOL ret = MTRUE; Mutex::Autolock _lock(mLock); if ( 0 < mu4InitRefCount ) { mu4InitRefCount--; if ( 0 == mu4InitRefCount ) { ret = getImp()->uninit(); } } PIPE_DBG("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret); return ret; }
uint32_t ParamsManager:: getZoomRatio() const { RWLock::AutoRLock _lock(mRWLock); ssize_t index = mParameters.getInt(CameraParameters::KEY_ZOOM); if (index < 0) { index = 0; } else if(index >= (ssize_t)mvZoomRatios.size()) { index = mvZoomRatios.size() - 1; } return mvZoomRatios[index]; }
int CThreadPool::getInstanceCurrentThreadIsAssociatedWith() { if (_allThreadData.size()==0) return(-1); _lock(16); VTHREAD_ID_TYPE threadID=VThread::getCurrentThreadId(); int retVal=-1; for (int i=0;i<int(_allThreadData.size());i++) { if (VThread::areThreadIDsSame(_allThreadData[i]->threadID,threadID)) { retVal=_allThreadData[i]->threadInstanceIndex; break; } } _unlock(16); return(retVal); }
/** * @param workspaceToCheck :: A workspace to check. * @param level :: The current nesting level. Intended for internal use only by * WorkspaceGroup. * @return :: True if the worspace is found in any of the nested groups in this * group. */ bool WorkspaceGroup::isInGroup(const Workspace &workspaceToCheck, size_t level) const { // Check for a cycle. if (level > MAXIMUM_DEPTH) { throw std::runtime_error("WorkspaceGroup nesting level is too deep."); } std::lock_guard<std::recursive_mutex> _lock(m_mutex); for (const auto &workspace : m_workspaces) { if (workspace.get() == &workspaceToCheck) return true; WorkspaceGroup *group = dynamic_cast<WorkspaceGroup *>(workspace.get()); if (group) { if (group->isInGroup(workspaceToCheck, level + 1)) return true; } } return false; }
Status LinuxThread::Terminate() { CHECK_ERROR(m_threadId); _lock(m_terminateMutex); if(m_bTerminate){ _unlock(m_terminateMutex); return ER; } m_bTerminate = true; _unlock(m_terminateMutex); if(!IsRunning()) _assume(); Status retval; int ret = pthread_join(*m_threadId,(void**)&retval); return (ret == 0 && val == OK) ? OK : ER; }
MBOOL ICamIOPipeBridge:: init() { MBOOL ret = MTRUE; Mutex::Autolock _lock(mLock); if ( 0 != mu4InitRefCount ) { mu4InitRefCount++; } else if ( (ret = getImp()->init()) ) { mu4InitRefCount = 1; } MY_LOGD("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret); return ret; }
MBOOL ICamIOPipeBridge:: uninit() { MBOOL ret = MTRUE; Mutex::Autolock _lock(mLock); if ( 0 < mu4InitRefCount ) { mu4InitRefCount--; if ( 0 == mu4InitRefCount ) { ret = getImp()->uninit(); } } MY_LOGD("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret); return ret; }
// PD_TRACE_DECLARE_FUNCTION ( SDB_COORDSN_DISCONN, "CoordSession::disConnect" ) INT32 CoordSession::disConnect( const MsgRouteID &routeID ) { INT32 rc = SDB_OK; PD_TRACE_ENTRY ( SDB_COORDSN_DISCONN ); BOOLEAN hasSession = FALSE; { ossScopedLock _lock( &_mutex ) ; COORD_SUBSESSION_MAP::iterator it; it = _subSessionMap.find( routeID.value ); if ( it != _subSessionMap.end() ) { hasSession = TRUE; it->second.isConnected = FALSE; } } if ( hasSession ) { MsgOpReply *pMsg = (MsgOpReply *)SDB_OSS_MALLOC( sizeof(MsgOpReply) ); if ( NULL != pMsg ) { pMsg->header.messageLength = sizeof(MsgOpReply); pMsg->header.opCode = MSG_COOR_REMOTE_DISC; pMsg->header.routeID = routeID; pMsg->header.requestID = pmdGetKRCB()->getCoordCB( )->getRouteAgent()->reqIDNew(); pMsg->flags = SDB_COORD_REMOTE_DISC; pMsg->numReturned = 0; pMsg->contextID = -1 ; pMsg->startFrom = 0 ; _pEduCB->postEvent ( pmdEDUEvent( PMD_EDU_EVENT_MSG, PMD_EDU_MEM_ALLOC, pMsg ) ) ; } else { rc = SDB_OOM; PD_LOG( PDERROR, "malloc failed(size=%d)", sizeof(MsgHeader) ); } } PD_TRACE_EXITRC ( SDB_COORDSN_DISCONN, rc ); return rc; }
uint32_t ParamsManager:: getMultFrameBlending() const { RWLock::AutoRLock _lock(mRWLock); char const* pMfb = mParameters.get(MtkCameraParameters::KEY_MFB_MODE); char const*const pScene = mParameters.get(CameraParameters::KEY_SCENE_MODE); bool mNightMode = false; uint32_t mfbMode = 0; if(!pMfb) { MY_LOGD("No KEY_MFB_MODE"); return 0; } if ( pScene && (0 == ::strcmp(pScene, CameraParameters::SCENE_MODE_NIGHT)) ) { MY_LOGD(" MFB enable for NightMode"); mNightMode = true; } // default MFB off, leave for CCT MFLL if (0 == ::strcmp(pMfb, MtkCameraParameters::KEY_MFB_MODE_MFLL) ) { MY_LOGD(" MFB enable for CCT"); mfbMode = 1; } if (0 == ::strcmp(pMfb, MtkCameraParameters::KEY_MFB_MODE_AIS) ) { MY_LOGD(" MFB enable for AIS"); mfbMode = 2; } if ((0 == ::strcmp(pMfb, MtkCameraParameters::OFF))&& true == mNightMode) { mfbMode = 1; } return mfbMode; }
status_t LivePhotoSource::read(MediaBuffer **buffer, const ReadOptions *options) { ALOGD("+"); *buffer = NULL; if(options != NULL) { ALOGE("Failed: LivePhotoSource dose not support read options"); return ERROR_UNSUPPORTED; } { Mutex::Autolock _lock(mLock); if( (mSourceStarted && !mLivePhotoStarted) || (mSourceStarted && mLivePhotoStarted && (mMediaBufferPool.empty() && mCodecConfigBuffer==NULL))) { status_t status = mFrameAvailableCond.wait(mLock); if ( NO_ERROR != status ) { ALOGE("wait status(%d) err", status); return UNKNOWN_ERROR; } } if(mLivePhotoStarted && (mMediaBufferPool.empty() && mCodecConfigBuffer==NULL)) mLivePhotoStarted = false; if( !mSourceStarted && !mLivePhotoStarted ) { mWriterReadEndCond.signal(); ALOGD("- Live photo stoped, return ERROR_END_OF_STREAM"); return ERROR_END_OF_STREAM; } if( mCodecConfigBuffer != NULL) { ALOGD("codec config buffer"); *buffer = mCodecConfigBuffer; mCodecConfigBuffer = NULL; } else if(!(mMediaBufferPool.empty())) { List<MediaBuffer *>::iterator it = mMediaBufferPool.begin(); *buffer = (*it); mMediaBufferPool.erase(it); } ALOGD("-"); return OK; } }
static void _namenode_decref(struct hdfs_namenode *n) { bool lastref = false; int rc; _lock(&n->nn_lock); ASSERT(n->nn_refs >= 1); n->nn_refs--; if (n->nn_refs == 0) lastref = true; _unlock(&n->nn_lock); if (lastref) { hdfs_namenode_destroy_cb dcb = NULL; ASSERT(n->nn_dead); if (n->nn_recver_started) { rc = write(n->nn_recv_sigpipe[1], "a", 1); ASSERT(rc == 1); rc = pthread_join(n->nn_recv_thr, NULL); ASSERT(rc == 0); close(n->nn_recv_sigpipe[1]); close(n->nn_recv_sigpipe[0]); } if (n->nn_sock != -1) close(n->nn_sock); if (n->nn_pending) free(n->nn_pending); if (n->nn_recvbuf) free(n->nn_recvbuf); if (n->nn_objbuf) free(n->nn_objbuf); if (n->nn_destroy_cb) dcb = n->nn_destroy_cb; if (n->nn_sasl_ctx) sasl_dispose(&n->nn_sasl_ctx); memset(n, 0, sizeof *n); if (dcb) dcb(n); } }
void flashpage_write(int page, const void *data) { assert(page < FLASHPAGE_NUMOF); uint32_t *page_addr = (uint32_t *)flashpage_addr(page); /* erase given page (the ADDR register uses 16-bit addresses) */ _unlock(); NVMCTRL->ADDR.reg = (((uint32_t)page_addr) >> 1); NVMCTRL->CTRLA.reg = (NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_ER); while (!NVMCTRL->INTFLAG.bit.READY) {} _lock(); /* write data to page */ if (data != NULL) { flashpage_write_raw(page_addr, data, FLASHPAGE_SIZE); } }
// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSLOCKBUCKET_WAITLOCKX, "dpsLockBucket::waitLockX" ) INT32 dpsLockBucket::waitLockX( _pmdEDUCB *eduCB, const dpsTransLockId &lockId ) { INT32 rc = SDB_OK; dpsTransLockUnit *pLockUnit = NULL; { ossScopedLock _lock( &_lstMutex ); dpsTransLockUnitList::iterator iterLst = _lockLst.find( lockId ); if ( _lockLst.end() == iterLst ) { rc = SDB_SYS; goto error; } pLockUnit = iterLst->second; } waitretry: rc = waitLock( eduCB ); { ossScopedLock _lock_2( &_lstMutex ); if ( rc ) { removeFromWait( eduCB, pLockUnit, lockId ); goto error ; } rc = appendToRun( eduCB, DPS_TRANSLOCK_X, pLockUnit ); if ( rc ) { goto waitretry; } removeFromWait( eduCB, pLockUnit, lockId ); } done: PD_TRACE_EXIT ( SDB_DPSLOCKBUCKET_WAITLOCKX ); return rc; error: PD_LOG ( PDERROR, "Failed to get the lock(rc=%d)", rc ); goto done; }
//========================================================== static bool _ram_test (void) //========================================================== { vu16 *ram = _unlock(); ram[0] = 0x1234; if(ram[0] == 0x1234) // test writability { _lock(); ram[0] = 0x4321; if(ram[0] != 0x4321) // test non-writability { return true; } } return false; }
static ssize_t diag_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) { struct bt_diag_context *ctxt = &_context; int r = 0; int ret; struct bt_request *req; UINT8 *tmp; int i; if (_lock(&ctxt->read_excl)) return 0; ret = wait_event_interruptible(ctxt->read_wq, ctxt->read_avail); dbg("read_wq wake up\n"); if (ret < 0) { dbg("diag:Exit diag_read()\n"); _unlock(&ctxt->read_excl); return ret; } while (req = bt_get_req(ctxt, &ctxt->rx_done)) { if (req) { tmp = (UINT8 *) req->buf; for (i = 0; i < req->length; i++, tmp++) printk(KERN_INFO "%x", *tmp); printk(KERN_INFO "\n"); if (copy_to_user(buf, req->buf, req->length)) dbg("diag:diag_read: copy_to_user fail\n"); buf += req->length; r += req->length; bt_put_req(ctxt, &ctxt->rx_idle, req); } } ctxt->read_avail = 0; _unlock(&ctxt->read_excl); return r; }
RenderTask* RenderThread::nextTask(nsecs_t* nextWakeup) { AutoMutex _lock(mLock); RenderTask* next = mQueue.peek(); if (!next) { mNextWakeup = LLONG_MAX; } else { mNextWakeup = next->mRunAt; // Most tasks won't be delayed, so avoid unnecessary systemTime() calls if (next->mRunAt <= 0 || next->mRunAt <= systemTime(SYSTEM_TIME_MONOTONIC)) { next = mQueue.next(); } else { next = nullptr; } } if (nextWakeup) { *nextWakeup = mNextWakeup; } return next; }
EventWorkspaceMRU::~EventWorkspaceMRU() { // Make sure you free up the memory in the MRUs { Poco::ScopedWriteRWLock _lock(m_changeMruListsMutexY); for (auto &data : m_bufferedDataY) { if (data) { data->clear(); delete data; } } } Poco::ScopedWriteRWLock _lock2(m_changeMruListsMutexE); for (auto &data : m_bufferedDataE) { if (data) { data->clear(); delete data; } } }
void CSimxSocket::instancePass() { // 3/3/2014 // if (!_simulationOnly) { int simState=simGetSimulationState(); if ((simState&sim_simulation_advancing)==0) _executeCommands(); } if (_debug) { // we should never access the V-REP API from a thread not created in V-REP! _lock(); for (unsigned int i=0;i<_textToPrintToConsole.size();i++) simAuxiliaryConsolePrint(_auxConsoleHandle,_textToPrintToConsole[i].c_str()); _textToPrintToConsole.clear(); _unlock(); } }
int free_memory(void) { struct fpack *ptr; int memsz = 0; _lock(); ptr = sys_free; if (!first_call) /* IF MEMORY IS INITIALIZED */ { while (ptr != LIMIT) { memsz -= ptr->packet_size; ptr = ptr->next_free; } } _unlock(); return memsz; }
bool d3d_display::create(uint32_t width = 1024, uint32_t height = 768, bool fullscreen = false) { std::lock_guard<std::mutex> _lock(_render_lock); _fullscreen = fullscreen; WNDCLASSEXW wcex; wcex.cbSize = sizeof(WNDCLASSEXW); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = (WNDPROC)&ace::debug::d3d_display::wndproc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = (HINSTANCE)GetCurrentProcess(); //wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_SAMPLE1); //wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wcex.lpszMenuName = nullptr; wcex.lpszClassName = L"ACE3BaseDisplayClass"; //wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SAMPLE1); if (!RegisterClassExW(&wcex)) { return false; } // Create window _hInst = (HINSTANCE)GetCurrentProcess(); RECT rc = { 0, 0, width, height }; AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE); _hWnd = CreateWindowW(L"ACE3BaseDisplayClass", L"ACE3 D3D Render", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, _hInst, nullptr); if (!_hWnd) { return false; } // Attach our input to the master input //AttachThreadInput(GetCurrentThreadId(), GetMainThraedId()); SetWindowLongPtr(_hWnd, GWLP_USERDATA, (LONG)this); ShowWindow(_hWnd, 5); return true; }
static int diag2arm9_open(struct inode *ip, struct file *fp) { struct diag_context *ctxt = &_context; DBG_OP("+diag2arm9_open()\n"); if (_lock(&ctxt->open_arm9_excl)) return -EBUSY; msm_diag_smd_open(); diag_configure(1, ctxt); /* clear the error latch */ //ctxt->error = 0; DBG_OP("-diag2arm9_open()\n"); return 0; }
uint32_t ParamsManager:: getVHdr() const { RWLock::AutoRLock _lock(mRWLock); char const* p = mParameters.get(MtkCameraParameters::KEY_VIDEO_HDR); char const* pMode = mParameters.get(MtkCameraParameters::KEY_VIDEO_HDR_MODE); if(!p) { MY_LOGI("No KEY_VIDEO_HDR"); return 0; } if(!pMode) { MY_LOGI("No KEY_VIDEO_HDR_MODE"); return 0; } //> check vhdr mode if(::strcmp(p, MtkCameraParameters::OFF) == 0) { return 0; } else { if(::strcmp(pMode, MtkCameraParameters::VIDEO_HDR_MODE_IVHDR) == 0) { return 1; } else if(::strcmp(pMode, MtkCameraParameters::VIDEO_HDR_MODE_MVHDR) == 0) { return 2; } else { MY_LOGE("wrong mode(%s)",pMode); return 0; } } }
int64_t SparseMatrix<VALUE_T>::timed_vector_put(std::vector<std::string> row_key, std::vector<std::string> column_key, int64_t time_stamp, std::vector<VALUE_T> value) { CHECK_EQ(row_key.size(), column_key.size()); CHECK_EQ(row_key.size(), value.size()); write_lock _lock(KVStorage::_timed_rwmutex); for (uint64_t i = 0; i < row_key.size(); ++i) { _timed_storage[time_stamp][row_key[i]][column_key[i]] = value[i]; } if (_timed_storage.size() >= 3) { _timed_storage.erase(_timed_storage.begin()); } vector_put(row_key, column_key, value); return 1; }
/////////////////////////////////////////////////////////////////////////////// // Register - Register a new subject/observer relationsship Error ChangeManager::Register(ISystemObject* pInSubject, IObserver* pInObserver) { BOOST_ASSERT_MSG(pInSubject != nullptr, "Subject cannot be null"); BOOST_ASSERT_MSG(pInObserver != nullptr, "Observer cannot be null"); auto observerIntrestBits = pInObserver->GetDesiredSystemChanges(); if (pInSubject->GetPotentialSystemChanges() & observerIntrestBits) { // Lock out updates while we register a subject tbb::spin_mutex::scoped_lock _lock(m_swUpdate); unsigned int uID = pInSubject->getObserverId(this); if (uID != ISystemObject::InvalidObserverID) { // Subject has already been registered. Add new observer to the list SubjectInfo &si = m_subjectsList[uID]; si.m_observersList.push_back(ObserverRequest(pInObserver, uID, observerIntrestBits)); observerIntrestBits &= ~si.m_interestBits; if (observerIntrestBits) { si.m_interestBits |= observerIntrestBits; pInSubject->UpdateInterestBits(this, observerIntrestBits); } } else { // New subject if (m_freeIDsList.empty()) { // No zero ID should ever be assigned, so use pre-increment uID = ++m_lastID; BOOST_ASSERT(uID == m_subjectsList.size()); m_subjectsList.resize(uID + 1); } else { uID = m_freeIDsList.back(); m_freeIDsList.pop_back(); } SubjectInfo &si = m_subjectsList[uID]; si.m_pSubject = pInSubject; si.m_observersList.push_back(ObserverRequest(pInObserver, uID, observerIntrestBits)); si.m_interestBits = observerIntrestBits; pInSubject->Attach(this, observerIntrestBits, uID); } } return Errors::Success; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL, "_SDB_DMSCB::_CSCBNameRemoveP1Cancel" ) INT32 _SDB_DMSCB::_CSCBNameRemoveP1Cancel ( const CHAR *pName, _pmdEDUCB *cb, SDB_DPSCB *dpsCB ) { INT32 rc = SDB_OK ; PD_TRACE_ENTRY ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL ); dmsStorageUnitID suID ; SDB_DMS_CSCB *pCSCB = NULL; #if defined (_WINDOWS) std::map<const CHAR*, dmsStorageUnitID, cmp_cscb>::const_iterator it ; #elif defined (_LINUX) std::map<const CHAR*, dmsStorageUnitID>::const_iterator it ; #endif { ossScopedLock _lock(&_mutex, EXCLUSIVE) ; if ( _cscbNameMap.end() == (it = _cscbNameMap.find(pName)) ) { SDB_ASSERT( FALSE, "faint, why the cs is not in the map?" ); rc = SDB_DMS_CS_NOTEXIST; goto error; } suID = (*it).second; pCSCB = _delCscbVec[suID]; if ( pCSCB ) { SDB_ASSERT( pCSCB->_su, "su can't be null!" ); _cscbVec[suID] = pCSCB; _delCscbVec[suID] = NULL; } else { SDB_ASSERT( FALSE, "faint, where is the CSCB?" ); } } done : PD_TRACE_EXITRC ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL, rc ); return rc ; error : goto done ; }
int fcntl(int fd, int cmd, ... /* arg */ ) { SocketExtDataLock _lock(); int res = 0; va_list args; va_start(args, cmd); if (cmd == F_SETFL) { int flags = va_arg(args, int); bool blocking; if ((flags & O_NONBLOCK) != 0) { blocking = false; } else { blocking = true; } if (socket_ext_data.find(fd) == socket_ext_data.end()) { // we know nothing about this socket fd yet socket_ext_data[fd] = SocketData(); } socket_ext_data[fd].nonblocking = !blocking; u_long socketMode = blocking ? 0 : 1; int rc = ioctl(fd, FIONBIO, &socketMode); if (rc == SOCKET_ERROR) { // ioctl sets the errno in Unix format res = -1; goto exit_end_args; } if ((flags & (~O_NONBLOCK)) != 0) { // We don't support any other flags errno = EBADF; res = -1; goto exit_end_args; } }