void chanfd::data (svccb *sbp) { assert (sbp->prog () == REX_PROG && sbp->proc () == REX_DATA); rex_payload *dp = sbp->Xtmpl getarg<rex_payload> (); assert (dp->channel == channo); if (dp->fd < 0 || implicit_cast<size_t> (dp->fd) >= fdi.size ()) { warn ("payload fd %d out of range\n", dp->fd); sbp->replyref (false); return; } int fdn = dp->fd; if (fdi[fdn].weof) { sbp->replyref (false); return; } if (dp->data.size ()) { bool wasempty = !fdi[fdn].wuio.resid (); fdi[fdn].wuio.print (dp->data.base (), dp->data.size ()); fdi[fdn].wuio.iovcb (wrap (this, &chanfd::scb, dp->fd, sbp)); if (wasempty) wcb (dp->fd); } else { fdi[fdn].weof = true; fdi[fdn].wuio.iovcb (wrap (this, &chanfd::voidshut, fdn, SHUT_WR)); sbp->replyref (true); } }
TEST(BitMap, is_full__unaligned) { BitMapMemory mx(aligned_size); BitMapView x = mx.make_view(unaligned_size, one_bits); EXPECT_TRUE(x.is_full()); // Check that a missing bit beyond the end doesn't count. { idx_t index = aligned_size - 1; BitMapView aligned = BitMapView(mx.memory(), aligned_size); WithBitClear wcb(aligned, index); EXPECT_FALSE(aligned.is_full()); EXPECT_TRUE(x.is_full()); } // Check that a missing bit in the final partial word does count. { WithBitClear wcb(x, unaligned_size - 1); EXPECT_FALSE(x.is_full()); } }
double wxPdfFontDataTrueType::GetStringWidth(const wxString& s, const wxPdfEncoding* encoding, bool withKerning) const { wxUnusedVar(encoding); // Get width of a string in the current font double w = 0; #if wxUSE_UNICODE wxString t = ConvertToValid(s); wxCharBuffer wcb(t.mb_str(*m_conv)); const char* str = (const char*) wcb; #else const char* str = s.c_str(); #endif wxPdfGlyphWidthMap::iterator charIter; size_t i; for (i = 0; i < s.Length(); i++) { charIter = m_cw->find((unsigned char) str[i]); if (charIter != m_cw->end()) { w += charIter->second; } else { w += m_desc.GetMissingWidth(); } } if (withKerning) { int kerningWidth = GetKerningWidth(s); if (kerningWidth != 0) { w += (double) kerningWidth; } } return w / 1000; }
/** * This functions runs in infinite blocking loop until there is no fd in * pfdset. It calls corresponding r/w handler if there is event on the fd. * * Before the callback is called, we set the flag to busy status; If other * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it * will wait until the flag is reset to zero(which indicates the callback is * finished), then it could free the context after fdset_del. */ void fdset_event_dispatch(struct fdset *pfdset) { fd_set rfds, wfds; int i, maxfds; struct fdentry *pfdentry; int num = MAX_FDS; fd_cb rcb, wcb; void *dat; int fd; int remove1, remove2; int ret; if (pfdset == NULL) return; while (1) { struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; FD_ZERO(&rfds); FD_ZERO(&wfds); pthread_mutex_lock(&pfdset->fd_mutex); maxfds = fdset_fill(&rfds, &wfds, pfdset); pthread_mutex_unlock(&pfdset->fd_mutex); /* * When select is blocked, other threads might unregister * listenfds from and register new listenfds into fdset. * When select returns, the entries for listenfds in the fdset * might have been updated. It is ok if there is unwanted call * for new listenfds. */ ret = select(maxfds + 1, &rfds, &wfds, NULL, &tv); if (ret <= 0) continue; for (i = 0; i < num; i++) { remove1 = remove2 = 0; pthread_mutex_lock(&pfdset->fd_mutex); pfdentry = &pfdset->fd[i]; fd = pfdentry->fd; rcb = pfdentry->rcb; wcb = pfdentry->wcb; dat = pfdentry->dat; pfdentry->busy = 1; pthread_mutex_unlock(&pfdset->fd_mutex); if (fd >= 0 && FD_ISSET(fd, &rfds) && rcb) rcb(fd, dat, &remove1); if (fd >= 0 && FD_ISSET(fd, &wfds) && wcb) wcb(fd, dat, &remove2); pfdentry->busy = 0; /* * fdset_del needs to check busy flag. * We don't allow fdset_del to be called in callback * directly. */ /* * When we are to clean up the fd from fdset, * because the fd is closed in the cb, * the old fd val could be reused by when creates new * listen fd in another thread, we couldn't call * fd_set_del. */ if (remove1 || remove2) fdset_del_slot(pfdset, i); } } }
void dnssock_tcp::sendpkt (const u_char *pkt, size_t size) { tcpstate.putpkt (pkt, size); wcb (); }
/** * This functions runs in infinite blocking loop until there is no fd in * pfdset. It calls corresponding r/w handler if there is event on the fd. * * Before the callback is called, we set the flag to busy status; If other * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it * will wait until the flag is reset to zero(which indicates the callback is * finished), then it could free the context after fdset_del. */ void * fdset_event_dispatch(void *arg) { int i; struct pollfd *pfd; struct fdentry *pfdentry; fd_cb rcb, wcb; void *dat; int fd, numfds; int remove1, remove2; int need_shrink; struct fdset *pfdset = arg; int val; if (pfdset == NULL) return NULL; while (1) { /* * When poll is blocked, other threads might unregister * listenfds from and register new listenfds into fdset. * When poll returns, the entries for listenfds in the fdset * might have been updated. It is ok if there is unwanted call * for new listenfds. */ pthread_mutex_lock(&pfdset->fd_mutex); numfds = pfdset->num; pthread_mutex_unlock(&pfdset->fd_mutex); val = poll(pfdset->rwfds, numfds, 1000 /* millisecs */); if (val < 0) continue; need_shrink = 0; for (i = 0; i < numfds; i++) { pthread_mutex_lock(&pfdset->fd_mutex); pfdentry = &pfdset->fd[i]; fd = pfdentry->fd; pfd = &pfdset->rwfds[i]; if (fd < 0) { need_shrink = 1; pthread_mutex_unlock(&pfdset->fd_mutex); continue; } if (!pfd->revents) { pthread_mutex_unlock(&pfdset->fd_mutex); continue; } remove1 = remove2 = 0; rcb = pfdentry->rcb; wcb = pfdentry->wcb; dat = pfdentry->dat; pfdentry->busy = 1; pthread_mutex_unlock(&pfdset->fd_mutex); if (rcb && pfd->revents & (POLLIN | FDPOLLERR)) rcb(fd, dat, &remove1); if (wcb && pfd->revents & (POLLOUT | FDPOLLERR)) wcb(fd, dat, &remove2); pfdentry->busy = 0; /* * fdset_del needs to check busy flag. * We don't allow fdset_del to be called in callback * directly. */ /* * When we are to clean up the fd from fdset, * because the fd is closed in the cb, * the old fd val could be reused by when creates new * listen fd in another thread, we couldn't call * fd_set_del. */ if (remove1 || remove2) { pfdentry->fd = -1; need_shrink = 1; } } if (need_shrink) fdset_shrink(pfdset); } return NULL; }