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;
}
