Object File::await(uint16_t events, double timeout) {
if (isClosed()) {
Cell closedResult;
closedResult.m_type = KindOfInt64;
closedResult.m_data.num = FileAwait::CLOSED;
return c_StaticWaitHandle::CreateSucceeded(closedResult);
}
if (fd() < 0) {
throw Object(SystemLib::AllocExceptionObject(
"Unable to await on stream, invalid file descriptor"));
}
events = events & FileEventHandler::READ_WRITE;
if (!events) {
throw Object(SystemLib::AllocExceptionObject(
"Must await for reading, writing, or both."));
}
auto ev = new FileAwait(fd(), events, timeout);
try {
return ev->getWaitHandle();
} catch (...) {
assert(false);
ev->abandon();
throw;
}
}
/* Executes a Load Programme instruction. Returns 1 if the UM should
quit. */
static int
exec_load( void)
{
int quit = 0;
rb = GET_REG_B(insn);
reg_b = regs[rb];
if( reg_b >= num_arrays)
{
fprintf( stderr, "ERROR: OP12 - Array index out of bounds!\n");
quit = 1;
}
else if( arrays[reg_b] == NULL)
{
fprintf( stderr, "ERROR: OP12 - Accessing abandoned array!\n");
quit = 1;
}
else
{
if( reg_b != 0)
{
abandon( arrays[0]);
arrays[0] = allocate( arrays[reg_b]->platters, 0);
memcpy( arrays[0]->array, arrays[reg_b]->array,
arrays[0]->platters * sizeof( platter_t));
}
rc = GET_REG_C(insn);
insn_ptr = arrays[0]->array + regs[rc];
}
return quit;
}
static Void heapInit() { /* initialise heap storage */
space1 = (Heap)(farCalloc(heapSize,sizeof(Cell)));
space2 = (Heap)(farCalloc(heapSize,sizeof(Cell)));
if (space1==(Heap)0 || space2==(Heap)0)
abandon("Cannot allocate heap storage");
from = space1 + heapSize;
to = space2 + heapSize;
hp = -heapSize-1;
}
static void
getAngle(const struct pam * const pamP,
sample ** const pixels,
unsigned int const hstep,
unsigned int const vstep,
unsigned int const hsamples,
float const maxangle,
float const astep,
float const qmin,
bool const fast,
bool const verbose,
float * const angleP) {
float a;
float da;
float lastq; /* quality (s/n ratio) of last measurement */
getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples,
-maxangle, maxangle, astep, verbose,
&a, &lastq);
if ((a < -maxangle + astep / 2) || (a > maxangle - astep / 2))
/* extreme val almost certainly wrong */
abandon();
if (lastq < qmin)
/* insufficient s/n ratio */
abandon();
/* make a finer search in the neighborhood */
da = astep / 10;
getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples,
a - 9 * da, a + 9 * da, da, verbose,
&a, &lastq);
/* iterate once more unless we don't need that much accuracy */
if (!fast) {
da /= 10;
getBestAngleLocal(pamP, pixels, hstep, vstep, hsamples,
a - 9 * da, a + 9 * da, da, verbose,
&a, &lastq);
}
*angleP = a;
}
Object MCRouter::issue(mcr::mcrouter_msg_t& msg) {
auto ev = new MCRouterResult(this, msg);
try {
return Object{ev->getWaitHandle()};
} catch (...) {
assert(false);
ev->abandon();
throw;
}
}
/**
* Abandon all received finished events.
*
* Returns true iff provided wait handle was abandoned.
*/
bool AsioExternalThreadEventQueue::abandonAllReceived(c_ExternalThreadEventWaitHandle* wait_handle) {
assert(m_received);
bool seen = false;
do {
auto ete_wh = m_received;
m_received = m_received->getNextToProcess();
ete_wh->abandon(true);
seen |= ete_wh == wait_handle;
} while (m_received);
return seen;
}
static int putConnSocket(int orig_sock,int sock,SAP addr,int leng,PCStr(what),int rcode){
int si;
int csi = -1;
SockPool *sp;
SockPool *osp = 0;
double Now = Time();
double oTime;
int csock = -1;
oTime = Now;
setupCSC("putConnSocket",sockCSC,sizeof(sockCSC));
enterCSC(sockCSC);
for( si = 0; si < elnumof(sockPool); si++ ){
sp = &sockPool[si];
if( sp->sp_Time != 0 ){
if( sp->sp_Time < oTime )
osp = sp;
continue;
}
osp = sp;
csi = si;
break;
}
if( osp ){
if( osp->sp_Time ){
LOGX_tcpConAbandon1++;
abandon(osp,0);
}
sockPoolN++;
setfdowner(sock,0,0);
osp->sp_what = what;
osp->sp_Time = Time();
osp->sp_sock = sock;
osp->sp_rcode = rcode;
osp->sp_leng = leng;
bcopy(addr,&osp->sp_addr,leng);
if( rcode != RCODE_RECYC ){
porting_dbg("--putConnSocket(%d) %d[%d]",
sockPoolN,sock,csi,csock);
porting_dbg("++putConnSock(%s)[%d] (%d)%d[%d]",
what,sock,csi,osp->sp_leng,osp->sp_sock);
}
syslog_ERROR("--putConnSocket([%d]%d)<-[%d]%d %s %d\n",
sock,SocketOf(sock),orig_sock,SocketOf(orig_sock),
what,rcode);
}
leaveCSC(sockCSC);
return 0;
}
/* Executes an Abandonment instruction. Returns 1 if the UM should quit. */
static int
exec_aban( void)
{
int quit = 0;
rc = GET_REG_C(insn);
reg_c = regs[rc];
if( reg_c == 0)
{
fprintf( stderr, "ERROR: Cannot abandon 0-th array!\n");
quit = 1;
}
else
{
abandon( (void *)reg_c);
}
return quit;
}
void c_ExternalThreadEventWaitHandle::sweep() {
assert(getState() == STATE_WAITING);
if (m_event->cancel()) {
// canceled; the processing thread will take care of cleanup
return;
}
// event has finished, but process() was not called yet
auto session = AsioSession::Get();
bool done = false;
do {
auto ete_wh = session->waitForExternalThreadEvents();
while (ete_wh) {
done |= ete_wh == this;
auto next_wh = ete_wh->getNextToProcess();
ete_wh->abandon(true);
ete_wh = next_wh;
}
} while (!done);
}
/* Executes an Abandonment instruction. Returns 1 if the UM should quit. */
static int
exec_aban( void)
{
int quit = 0;
rc = GET_REG_C(insn);
reg_c = regs[rc];
if( reg_c == 0)
{
fprintf( stderr, "ERROR: OP09 - Cannot abandon 0-th array!\n");
quit = 1;
}
else if( reg_c >= num_arrays)
{
fprintf( stderr, "ERROR: OP09 - Array index out of bounds!\n");
quit = 1;
}
else if( arrays[reg_c] == NULL)
{
fprintf( stderr, "ERROR: OP09 - Array already abandoned!\n");
quit = 1;
}
else
{
freed_array_t *f;
abandon( arrays[reg_c]);
arrays[reg_c] = NULL;
/* Remember the slot that was holding this array. */
f = emalloc( sizeof( freed_array_t));
f->idx = reg_c;
f->next = freed_arrays;
freed_arrays = f;
}
return quit;
}
static void
computeSteps(const struct pam * const pamP,
unsigned int const hstepReq,
unsigned int const vstepReq,
unsigned int * const hstepP,
unsigned int * const vstepP) {
/*----------------------------------------------------------------------------
Adjust parameters if necessary now that we have the image size
-----------------------------------------------------------------------------*/
if (pamP->width < 10 || pamP->height < 10)
abandon();
if (pamP->width < 10 * hstepReq)
*hstepP = pamP->width / 10;
else
*hstepP = hstepReq;
if (pamP->height < 10 * vstepReq)
*vstepP = pamP->height / 10;
else
*vstepP = vstepReq;
}
/* Executes a Load Programme instruction. Returns 1 if the UM should
quit. */
static int
exec_load( void)
{
int quit = 0;
rb = GET_REG_B(insn);
reg_b = regs[rb];
if( reg_b != 0)
{
unsigned int platters = *(unsigned int *)(reg_b - sizeof( platter_t));
abandon( array_0);
array_0 = allocate( platters, 0);
memcpy( array_0, (void *)reg_b, platters * sizeof( platter_t));
}
rc = GET_REG_C(insn);
reg_c = regs[rc];
insn_ptr = array_0 + reg_c;
return quit;
}
void action(struct map *map) {
int tmp;
printf("What do you want to do ?\n"
"\t1) Abandon\n"
"\t2) Set a flag\n"
"\t3) Erase a flag\n"
"\t4) Explore a cell\n"
"\t5) Quit\n\t");
scanf("%d", &tmp);
if(tmp == 1)
abandon();
else if(tmp == 2)
flag(map);
else if(tmp == 3)
unflag(map);
else if(tmp == 4)
explore(map);
else if(tmp == 5)
quit(map);
#if defined CHEAT_ALLOWED
else if(tmp == 16012006)
display_map_debug(map);
#endif
}
SurfaceTexture::~SurfaceTexture() {
ST_LOGV("~SurfaceTexture");
abandon();
}
void ConsumerBase::onLastStrongRef(const void* id) {
abandon();
}
boost::optional<Date_t> CollectionRangeDeleter::cleanUpNextRange(
OperationContext* opCtx,
NamespaceString const& nss,
OID const& epoch,
int maxToDelete,
CollectionRangeDeleter* forTestOnly) {
if (maxToDelete <= 0) {
maxToDelete = rangeDeleterBatchSize.load();
if (maxToDelete <= 0) {
maxToDelete = std::max(int(internalQueryExecYieldIterations.load()), 1);
}
}
StatusWith<int> wrote = 0;
auto range = boost::optional<ChunkRange>(boost::none);
auto notification = DeleteNotification();
{
UninterruptibleLockGuard noInterrupt(opCtx->lockState());
AutoGetCollection autoColl(opCtx, nss, MODE_IX);
auto* const collection = autoColl.getCollection();
auto* const csr = CollectionShardingRuntime::get(opCtx, nss);
auto& metadataManager = csr->_metadataManager;
if (!_checkCollectionMetadataStillValid(
opCtx, nss, epoch, forTestOnly, collection, metadataManager)) {
return boost::none;
}
auto* const self = forTestOnly ? forTestOnly : &metadataManager->_rangesToClean;
bool writeOpLog = false;
{
stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock);
if (self->isEmpty()) {
LOG(1) << "No further range deletions scheduled on " << nss.ns();
return boost::none;
}
auto& orphans = self->_orphans;
if (orphans.empty()) {
// We have delayed deletions; see if any are ready.
auto& df = self->_delayedOrphans.front();
if (df.whenToDelete > Date_t::now()) {
LOG(0) << "Deferring deletion of " << nss.ns() << " range "
<< redact(df.range.toString()) << " until " << df.whenToDelete;
return df.whenToDelete;
}
// Move a single range from _delayedOrphans to _orphans
orphans.splice(orphans.end(), self->_delayedOrphans, self->_delayedOrphans.begin());
LOG(1) << "Proceeding with deferred deletion of " << nss.ns() << " range "
<< redact(orphans.front().range.toString());
writeOpLog = true;
}
invariant(!orphans.empty());
const auto& frontRange = orphans.front().range;
range.emplace(frontRange.getMin().getOwned(), frontRange.getMax().getOwned());
notification = orphans.front().notification;
}
invariant(range);
if (writeOpLog) {
// Secondaries will watch for this update, and kill any queries that may depend on
// documents in the range -- excepting any queries with a read-concern option
// 'ignoreChunkMigration'
try {
AutoGetCollection autoAdmin(
opCtx, NamespaceString::kServerConfigurationNamespace, MODE_IX);
Helpers::upsert(opCtx,
NamespaceString::kServerConfigurationNamespace.ns(),
BSON("_id"
<< "startRangeDeletion"
<< "ns"
<< nss.ns()
<< "epoch"
<< epoch
<< "min"
<< range->getMin()
<< "max"
<< range->getMax()));
} catch (const DBException& e) {
stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock);
csr->_metadataManager->_clearAllCleanups(
scopedLock,
e.toStatus("cannot push startRangeDeletion record to Op Log,"
" abandoning scheduled range deletions"));
return boost::none;
}
}
const auto scopedCollectionMetadata =
metadataManager->getActiveMetadata(metadataManager, boost::none);
const auto& metadata = *scopedCollectionMetadata;
try {
wrote = self->_doDeletion(
opCtx, collection, metadata->getKeyPattern(), *range, maxToDelete);
} catch (const DBException& e) {
wrote = e.toStatus();
warning() << e.what();
}
} // drop autoColl
if (!wrote.isOK() || wrote.getValue() == 0) {
if (wrote.isOK()) {
LOG(0) << "No documents remain to delete in " << nss << " range "
<< redact(range->toString());
}
// Wait for majority replication even when wrote isn't OK or == 0, because it might have
// been OK and/or > 0 previously, and the deletions must be persistent before notifying
// clients in _pop().
LOG(0) << "Waiting for majority replication of local deletions in " << nss.ns() << " range "
<< redact(range->toString());
repl::ReplClientInfo::forClient(opCtx->getClient()).setLastOpToSystemLastOpTime(opCtx);
const auto clientOpTime = repl::ReplClientInfo::forClient(opCtx->getClient()).getLastOp();
// Wait for replication outside the lock
const auto replicationStatus = [&] {
try {
WriteConcernResult unusedWCResult;
return waitForWriteConcern(
opCtx, clientOpTime, kMajorityWriteConcern, &unusedWCResult);
} catch (const DBException& e) {
return e.toStatus();
}
}();
// Get the lock again to finish off this range (including notifying, if necessary).
// Don't allow lock interrupts while cleaning up.
UninterruptibleLockGuard noInterrupt(opCtx->lockState());
AutoGetCollection autoColl(opCtx, nss, MODE_IX);
auto* const collection = autoColl.getCollection();
auto* const csr = CollectionShardingRuntime::get(opCtx, nss);
auto& metadataManager = csr->_metadataManager;
if (!_checkCollectionMetadataStillValid(
opCtx, nss, epoch, forTestOnly, collection, metadataManager)) {
return boost::none;
}
auto* const self = forTestOnly ? forTestOnly : &metadataManager->_rangesToClean;
stdx::lock_guard<stdx::mutex> scopedLock(csr->_metadataManager->_managerLock);
if (!replicationStatus.isOK()) {
LOG(0) << "Error when waiting for write concern after removing " << nss << " range "
<< redact(range->toString()) << " : " << redact(replicationStatus.reason());
// If range were already popped (e.g. by dropping nss during the waitForWriteConcern
// above) its notification would have been triggered, so this check suffices to ensure
// that it is safe to pop the range here
if (!notification.ready()) {
invariant(!self->isEmpty() && self->_orphans.front().notification == notification);
LOG(0) << "Abandoning deletion of latest range in " << nss.ns() << " after local "
<< "deletions because of replication failure";
self->_pop(replicationStatus);
}
} else {
LOG(0) << "Finished deleting documents in " << nss.ns() << " range "
<< redact(range->toString());
self->_pop(wrote.getStatus());
}
if (!self->_orphans.empty()) {
LOG(1) << "Deleting " << nss.ns() << " range "
<< redact(self->_orphans.front().range.toString()) << " next.";
}
return Date_t::now() + Milliseconds(rangeDeleterBatchDelayMS.load());
}
invariant(range);
invariant(wrote.getStatus());
invariant(wrote.getValue() > 0);
notification.abandon();
return Date_t::now() + Milliseconds(rangeDeleterBatchDelayMS.load());
}
ConsumerBase::~ConsumerBase() {
CB_LOGV("~ConsumerBase");
abandon();
}
static int getConnSocket(int sock,SAP addr,int leng,int *rcsock,int *pending){
int si;
int csi = -1;
SockPool *sp;
int got_csock = -1;
double Now = Time();
double Age = 0;
static int getOk;
static int getNg;
int rcode = -1;
setupCSC("getConnSocket",sockCSC,sizeof(sockCSC));
enterCSC(sockCSC);
*pending = 0;
for( si = 0; si < elnumof(sockPool); si++ ){
sp = &sockPool[si];
if( sp->sp_Time == 0 )
continue;
if( PCON_TIMEOUT < Now - sp->sp_Time ){
LOGX_tcpConAbandon2++;
abandon(sp,1);
continue;
}
if( sp->sp_leng != leng ){
continue;
}
if( bcmp(addr,&sp->sp_addr,leng) != 0
&& VSA_addrcomp((VSAddr*)addr,&sp->sp_addr) != 0
){
continue;
}
rcode = sp->sp_rcode;
if( rcode == RCODE_RECYC ){
if( /* HTTP && */ inoutReady(sp->sp_sock,1)
|| !sock_isconnected(sp->sp_sock)
){
getNg++;
/*
porting_dbg("--getConnSock(%d/%d) age=%.2f [%d] NO-R %d:%d",
si,sockPoolN,Now-sp->sp_Time,sp->sp_sock,getNg,getOk);
*/
LOGX_tcpConAbandon3++;
abandon(sp,2);
continue;
}
LOGX_tcpConRecycleOk++;
}else{
if( inoutReady(sp->sp_sock,2) == 0 ){
if( PCON_TIMEOUT < Now - sp->sp_Time ){
porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] NO-A",
si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock);
LOGX_tcpConAbandon4++;
abandon(sp,3);
}else{
*pending += 1;
}
continue;
}
if( !sock_isconnected(sp->sp_sock) ){
porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] NO-B",
si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock);
LOGX_tcpConAbandon4++;
abandon(sp,3);
continue;
}
}
getOk++;
if( rcode != RCODE_RECYC )
porting_dbg("--getConnSock(%d/%d)%s age=%.2f [%d] OK (%d)",
si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock,getOk);
syslog_ERROR("--getConnSock(%d/%d)%s age=%.2f [%d] OK (%d)\n",
si,sockPoolN,sp->sp_what,Now-sp->sp_Time,sp->sp_sock,getOk);
Age = Now - sp->sp_Time;
sp->sp_Time = 0;
sockPoolN--;
csi = si;
got_csock = sp->sp_sock;
break;
}
leaveCSC(sockCSC);
if( got_csock < 0 ){
return -1;
}
if( rcode != RCODE_RECYC )
porting_dbg("--getConnSocket(%d)[%d]>>>%d[%d]",
sockPoolN,sock,csi,got_csock);
setfdowner(got_csock,getthreadid(),getthreadgid(0));
*rcsock = got_csock;
syslog_ERROR("--getConnSocket([%d]%d)<-[%d]%d %.2f (%d)\n",
sock,SocketOf(sock),got_csock,SocketOf(got_csock),
Age,*pending);
return 0;
}
