TimeZoneSnapshot::TimeZoneSnapshot(thread_db* tdbb, MemoryPool& pool)
: SnapshotData(pool)
{
RecordBuffer* tzBuffer = allocBuffer(tdbb, pool, rel_time_zones);
Record* tzRecord = tzBuffer->getTempRecord();
tzRecord->nullify();
TimeZoneUtil::iterateRegions(
[=]
(USHORT id, const char* name)
{
SINT64 idValue = id;
putField(tdbb, tzRecord, DumpField(f_tz_id, VALUE_INTEGER, sizeof(idValue), &idValue));
putField(tdbb, tzRecord, DumpField(f_tz_name, VALUE_STRING, static_cast<USHORT>(strlen(name)), name));
tzBuffer->store(tzRecord);
}
);
}
void MIPAudioRecorderInput::AudioRecorderCallback(void *pInfo)
{
android::AudioRecord::Buffer *pBuffer = (android::AudioRecord::Buffer *)pInfo;
// TODO: write some error here
if (pBuffer->size != m_blockSize*sizeof(uint16_t))
return;
RecordBuffer *pBuf = m_pRecordBuffers[m_curBuffer];
memcpy(pBuf->getBuffer(), pBuffer->i16, m_blockSize*sizeof(uint16_t));
pBuf->setOffset(0);
m_curBuffer++;
if (m_curBuffer == m_numBuffers)
m_curBuffer = 0;
m_blockMutex.Lock();
m_availableFrames += m_blockFrames;
m_blockMutex.Unlock();
m_sigWait2.signal();
}
void
Analyzer::step(long pos)
{
Event curr = trace->event(pos);
vector<cmp_event> ceventv;
// callbacks for primitive events
for ( size_t i = 0; i < eventcbm[curr.get_type()].size(); i++ )
{
cmp_event* ce = NULL;
switch( curr.get_type() )
{
case OMPALOCK:
ce = eventcbm[curr.get_type()][i]->ompalock(curr);
break;
case COLLEXIT:
ce = eventcbm[curr.get_type()][i]->collexit(curr);
if ( ce != NULL ) cequeue.push(ce);
ce = eventcbm[curr.get_type()][i]->exit(curr);
break;
case ENTER:
ce = eventcbm[curr.get_type()][i]->enter(curr);
if( (expert_opt->get_patterntrace()) & (ExpertOpt::PT_PATTERN) ){
RecordBuffer* buffer = PatternTrace::_pt_ptr->GetBuffer();
if( (curr.get_reg()->get_rtype() == "OMP_CRITICAL_SBLOCK") &&
(buffer->FindDeleteOpenEnter(curr.get_enterptr().get_pos(),
curr.get_loc()->get_id() ) ) )
buffer->AddEvent(curr.get_loc()->get_id(),
new ExitRecord(curr.get_time() ) );
}
break;
case EXIT:
ce = eventcbm[curr.get_type()][i]->exit(curr);
if( (expert_opt->get_patterntrace()) & (ExpertOpt::PT_PATTERN) ){
RecordBuffer* buffer = PatternTrace::_pt_ptr->GetBuffer();
if(buffer->FindDeleteOpenEnter
(curr.get_enterptr().get_pos(), curr.get_loc()->get_id() ) )
buffer->AddEvent(curr.get_loc()->get_id(),
new ExitRecord(curr.get_time() ) );
}
break;
case FORK:
ce = eventcbm[curr.get_type()][i]->fork(curr);
break;
case JOIN:
ce = eventcbm[curr.get_type()][i]->join(curr);
break;
case MPICEXIT:
ce = eventcbm[curr.get_type()][i]->mpicexit(curr);
if ( ce != NULL ) cequeue.push(ce);
ce = eventcbm[curr.get_type()][i]->exit(curr);
break;
case MPIWCEXIT:
ce = eventcbm[curr.get_type()][i]->rmawcexit(curr);
if ( ce != NULL ) cequeue.push(ce);
ce = eventcbm[curr.get_type()][i]->exit(curr);
break;
case MPIWEXIT:
ce = eventcbm[curr.get_type()][i]->rmawexit(curr);
if ( ce != NULL ) cequeue.push(ce);
ce = eventcbm[curr.get_type()][i]->exit(curr);
break;
case OMPCEXIT:
ce = eventcbm[curr.get_type()][i]->ompcexit(curr);
if ( ce != NULL ) cequeue.push(ce);
ce = eventcbm[curr.get_type()][i]->exit(curr);
break;
case RECV:
ce = eventcbm[curr.get_type()][i]->recv(curr);
break;
case OMPRLOCK:
ce = eventcbm[curr.get_type()][i]->omprlock(curr);
break;
case SEND:
ce = eventcbm[curr.get_type()][i]->send(curr);
break;
default:
/* ignore unknown events for now */
break;
}
if ( ce != NULL )
cequeue.push(ce);
}
// callbacks for compound events
while ( cequeue.size() > 0 )
{
cmp_event* ce = cequeue.front();
for ( size_t i = 0; i < ceventcbm[ce->type].size(); i++ )
{
cmp_event* new_ce = ceventcbm[ce->type][i]->cmpnd(ce);
if ( new_ce != NULL )
cequeue.push(new_ce);
}
delete ce;
cequeue.pop();
}
}
RecordBuffer* DbCreatorsList::getList(thread_db* tdbb, jrd_rel* relation)
{
fb_assert(relation);
fb_assert(relation->rel_id == rel_sec_db_creators);
RecordBuffer* buffer = getData(relation);
if (buffer)
{
return buffer;
}
RefPtr<IAttachment> att;
RefPtr<ITransaction> tra;
const char* dbName = tdbb->getDatabase()->dbb_config->getSecurityDatabase();
if (!openDb(dbName, att, tra))
{
// In embedded mode we are not raising any errors - silent return
if (MasterInterfacePtr()->serverMode(-1) < 0)
return makeBuffer(tdbb);
(Arg::Gds(isc_crdb_nodb) << dbName).raise();
}
Message gr;
Field<ISC_SHORT> uType(gr);
Field<Varying> u(gr, MAX_SQL_IDENTIFIER_LEN);
FbLocalStatus st;
RefPtr<IResultSet> curs(att->openCursor(&st, tra, 0,
"select RDB$USER_TYPE, RDB$USER from RDB$DB_CREATORS",
SQL_DIALECT_V6, NULL, NULL, gr.getMetadata(), NULL, 0));
if (st->getState() & IStatus::STATE_ERRORS)
{
if (!fb_utils::containsErrorCode(st->getErrors(), isc_dsql_relation_err))
check("IAttachment::openCursor", &st);
// isc_dsql_relation_err when opening cursor - i.e. table
// is missing due to non-FB3 security DB
// In embedded mode we are not raising any errors - silent return
if (MasterInterfacePtr()->serverMode(-1) < 0)
return makeBuffer(tdbb);
(Arg::Gds(isc_crdb_notable) << dbName).raise();
}
try
{
buffer = makeBuffer(tdbb);
while (curs->fetchNext(&st, gr.getBuffer()) == IStatus::RESULT_OK)
{
Record* record = buffer->getTempRecord();
record->nullify();
putField(tdbb, record,
DumpField(f_sec_crt_user, VALUE_STRING, u->len, u->data));
SINT64 v = uType;
putField(tdbb, record,
DumpField(f_sec_crt_u_type, VALUE_INTEGER, sizeof(v), &v));
buffer->store(record);
}
check("IResultSet::fetchNext", &st);
}
catch (const Exception&)
{
clearSnapshot();
throw;
}
return getData(relation);
}
void UserManagement::list(IUser* u, unsigned cachePosition)
{
RecordBuffer* buffer = getData(rel_sec_users);
Record* record = buffer->getTempRecord();
record->nullify();
const MetaName& plugName(managers[cachePosition].first);
putField(threadDbb, record,
DumpField(f_sec_plugin, VALUE_STRING, static_cast<USHORT>(plugName.length()), plugName.c_str()));
bool su = false;
if (u->userName()->entered())
{
const char* uname = u->userName()->get();
putField(threadDbb, record,
DumpField(f_sec_user_name, VALUE_STRING, static_cast<USHORT>(strlen(uname)), uname));
su = strcmp(uname, SYSDBA_USER_NAME) == 0;
}
if (u->firstName()->entered())
{
putField(threadDbb, record,
DumpField(f_sec_first_name, VALUE_STRING, static_cast<USHORT>(strlen(u->firstName()->get())), u->firstName()->get()));
}
if (u->middleName()->entered())
{
putField(threadDbb, record,
DumpField(f_sec_middle_name, VALUE_STRING, static_cast<USHORT>(strlen(u->middleName()->get())), u->middleName()->get()));
}
if (u->lastName()->entered())
{
putField(threadDbb, record,
DumpField(f_sec_last_name, VALUE_STRING, static_cast<USHORT>(strlen(u->lastName()->get())), u->lastName()->get()));
}
if (u->active()->entered())
{
UCHAR v = u->active()->get() ? '\1' : '\0';
putField(threadDbb, record,
DumpField(f_sec_active, VALUE_BOOLEAN, sizeof(v), &v));
}
if (su || u->admin()->entered())
{
UCHAR v = (su || u->admin()->get()) ? '\1' : '\0';
putField(threadDbb, record,
DumpField(f_sec_admin, VALUE_BOOLEAN, sizeof(v), &v));
}
if (u->comment()->entered())
{
putField(threadDbb, record,
DumpField(f_sec_comment, VALUE_STRING, static_cast<USHORT>(strlen(u->comment()->get())), u->comment()->get()));
}
buffer->store(record);
if (u->userName()->entered() && u->attributes()->entered())
{
buffer = getData(rel_sec_user_attributes);
ConfigFile cf(ConfigFile::USE_TEXT, u->attributes()->get(), ConfigFile::NO_COMMENTS);
ConfigFile::Parameters::const_iterator e(cf.getParameters().end());
for (ConfigFile::Parameters::const_iterator b(cf.getParameters().begin()); b != e; ++b)
{
record = buffer->getTempRecord();
record->nullify();
putField(threadDbb, record,
DumpField(f_sec_attr_user, VALUE_STRING, static_cast<USHORT>(strlen(u->userName()->get())), u->userName()->get()));
putField(threadDbb, record,
DumpField(f_sec_attr_key, VALUE_STRING, b->name.length(), b->name.c_str()));
putField(threadDbb, record,
DumpField(f_sec_attr_value, VALUE_STRING, b->value.length(), b->value.c_str()));
buffer->store(record);
}
}
}
MonitoringSnapshot::MonitoringSnapshot(thread_db* tdbb, MemoryPool& pool)
: SnapshotData(pool)
{
SET_TDBB(tdbb);
PAG_header(tdbb, true);
Database* const dbb = tdbb->getDatabase();
fb_assert(dbb);
Attachment* const attachment = tdbb->getAttachment();
fb_assert(attachment);
const AttNumber self_att_id = attachment->att_attachment_id;
// Initialize record buffers
RecordBuffer* const dbb_buffer = allocBuffer(tdbb, pool, rel_mon_database);
RecordBuffer* const att_buffer = allocBuffer(tdbb, pool, rel_mon_attachments);
RecordBuffer* const tra_buffer = allocBuffer(tdbb, pool, rel_mon_transactions);
RecordBuffer* const stmt_buffer = allocBuffer(tdbb, pool, rel_mon_statements);
RecordBuffer* const call_buffer = allocBuffer(tdbb, pool, rel_mon_calls);
RecordBuffer* const io_stat_buffer = allocBuffer(tdbb, pool, rel_mon_io_stats);
RecordBuffer* const rec_stat_buffer = allocBuffer(tdbb, pool, rel_mon_rec_stats);
RecordBuffer* const ctx_var_buffer = allocBuffer(tdbb, pool, rel_mon_ctx_vars);
RecordBuffer* const mem_usage_buffer = allocBuffer(tdbb, pool, rel_mon_mem_usage);
RecordBuffer* const tab_stat_buffer = allocBuffer(tdbb, pool, rel_mon_tab_stats);
// Dump our own data and downgrade the lock, if required
Monitoring::dumpAttachment(tdbb, attachment);
if (!(attachment->att_flags & ATT_monitor_done))
{
LCK_convert(tdbb, attachment->att_monitor_lock, LCK_SR, LCK_NO_WAIT);
attachment->att_flags |= ATT_monitor_done;
}
// Enumerate active sessions
const string& user_name = attachment->att_user->usr_user_name;
const bool locksmith = attachment->locksmith();
const char* user_name_ptr = locksmith ? NULL : user_name.c_str();
MonitoringData::SessionList sessions(pool);
Lock temp_lock(tdbb, sizeof(AttNumber), LCK_monitor), *lock = &temp_lock;
{ // scope for the guard
MonitoringData::Guard guard(dbb->dbb_monitoring_data);
dbb->dbb_monitoring_data->enumerate(sessions, user_name_ptr);
}
// Signal other sessions to dump their state
{ // scope for the temporary status
ThreadStatusGuard temp_status(tdbb);
for (AttNumber* iter = sessions.begin(); iter != sessions.end(); iter++)
{
if (*iter != self_att_id)
{
lock->lck_key.lck_long = *iter;
if (LCK_lock(tdbb, lock, LCK_SR, LCK_WAIT))
LCK_release(tdbb, lock);
}
}
}
// Collect monitoring data. Start by gathering database-level info,
// it goes directly to the temporary space (as it's not stored in the shared dump).
TempSpace temp_space(pool, SCRATCH);
{ // scope for putDatabase and its utilities
TempWriter writer(temp_space);
SnapshotData::DumpRecord tempRecord(pool, writer);
Monitoring::putDatabase(tdbb, tempRecord);
}
// Read the dump into a temporary space. While being there,
// also check for dead sessions and garbage collect them.
{ // scope for the guard
MonitoringData::Guard guard(dbb->dbb_monitoring_data);
ThreadStatusGuard temp_status(tdbb);
lock->lck_type = LCK_attachment;
for (AttNumber* iter = sessions.begin(); iter != sessions.end(); iter++)
{
if (*iter != self_att_id)
{
lock->lck_key.lck_long = *iter;
if (LCK_lock(tdbb, lock, LCK_EX, LCK_NO_WAIT))
{
LCK_release(tdbb, lock);
dbb->dbb_monitoring_data->cleanup(*iter);
}
}
}
dbb->dbb_monitoring_data->read(user_name_ptr, temp_space);
}
// Parse the dump
MonitoringData::Reader reader(pool, temp_space);
SnapshotData::DumpRecord dumpRecord(pool);
while (reader.getRecord(dumpRecord))
{
const int rid = dumpRecord.getRelationId();
RecordBuffer* buffer = NULL;
Record* record = NULL;
switch (rid)
{
case rel_mon_database:
buffer = dbb_buffer;
break;
case rel_mon_attachments:
buffer = att_buffer;
break;
case rel_mon_transactions:
buffer = tra_buffer;
break;
case rel_mon_statements:
buffer = stmt_buffer;
break;
case rel_mon_calls:
buffer = call_buffer;
break;
case rel_mon_io_stats:
buffer = io_stat_buffer;
break;
case rel_mon_rec_stats:
buffer = rec_stat_buffer;
break;
case rel_mon_ctx_vars:
buffer = ctx_var_buffer;
break;
case rel_mon_mem_usage:
buffer = mem_usage_buffer;
break;
case rel_mon_tab_stats:
buffer = tab_stat_buffer;
break;
default:
fb_assert(false);
}
if (buffer)
{
record = buffer->getTempRecord();
record->nullify();
}
bool store_record = false;
SnapshotData::DumpField dumpField;
while (dumpRecord.getField(dumpField))
{
if (record)
{
putField(tdbb, record, dumpField);
store_record = true;
}
}
if (store_record)
buffer->store(record);
}
}
