STATIC walk_result loadRoutineInfo( sym_walk_info swi, sym_handle *sym,
void *_new_mod )
/*********************************************************************/
{
mod_info *new_mod = _new_mod;
sym_info sinfo;
file_info *sym_file;
rtn_info *new_rtn;
int rtn_count;
int name_len;
int sym_size;
int demangle_type;
if( swi != SWI_SYMBOL ) {
return( WR_CONTINUE );
}
SymInfo( sym, NULL, &sinfo );
if( sinfo.kind != SK_CODE && sinfo.kind != SK_PROCEDURE ) {
return( WR_CONTINUE );
}
sym_file = loadFileInfo( new_mod, sym );
name_len = SymName( sym, NULL, SN_DEMANGLED, NULL, 0 );
if( name_len == 0 ) {
name_len = SymName( sym, NULL, SN_SOURCE, NULL, 0 );
demangle_type = SN_SOURCE;
} else {
demangle_type = SN_DEMANGLED;
}
new_rtn = ProfCAlloc( sizeof( rtn_info ) + name_len );
SymName( sym, NULL, demangle_type, new_rtn->name, name_len + 1 );
sym_size = DIPHandleSize( HK_SYM );
new_rtn->sh = ProfAlloc( sym_size );
memcpy( new_rtn->sh, sym, sym_size );
rtn_count = sym_file->rtn_count;
sym_file->rtn_count++;
sym_file->routine = ProfRealloc( sym_file->routine, sym_file->rtn_count * sizeof( pointer ) );
sym_file->routine[rtn_count] = new_rtn;
return( WR_CONTINUE );
}
void QNetworkAccessFileBackend::open()
{
QUrl url = this->url();
if (url.host() == QLatin1String("localhost"))
url.setHost(QString());
#if !defined(Q_OS_WIN)
// do not allow UNC paths on Unix
if (!url.host().isEmpty()) {
// we handle only local files
error(QNetworkReply::ProtocolInvalidOperationError,
QCoreApplication::translate("QNetworkAccessFileBackend", "Request for opening non-local file %1").arg(url.toString()));
finished();
return;
}
#endif // !defined(Q_OS_WIN)
if (url.path().isEmpty())
url.setPath(QLatin1String("/"));
setUrl(url);
QString fileName = url.toLocalFile();
if (fileName.isEmpty()) {
if (url.scheme() == QLatin1String("qrc"))
fileName = QLatin1Char(':') + url.path();
else
fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
}
file.setFileName(fileName);
if (operation() == QNetworkAccessManager::GetOperation) {
if (!loadFileInfo())
return;
}
QIODevice::OpenMode mode;
switch (operation()) {
case QNetworkAccessManager::GetOperation:
mode = QIODevice::ReadOnly;
break;
case QNetworkAccessManager::PutOperation:
mode = QIODevice::WriteOnly | QIODevice::Truncate;
uploadByteDevice = createUploadByteDevice();
QObject::connect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(uploadReadyReadSlot()));
QMetaObject::invokeMethod(this, "uploadReadyReadSlot", Qt::QueuedConnection);
break;
default:
Q_ASSERT_X(false, "QNetworkAccessFileBackend::open",
"Got a request operation I cannot handle!!");
return;
}
mode |= QIODevice::Unbuffered;
bool opened = file.open(mode);
// could we open the file?
if (!opened) {
QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Error opening %1: %2")
.arg(this->url().toString(), file.errorString());
// why couldn't we open the file?
// if we're opening for reading, either it doesn't exist, or it's access denied
// if we're opening for writing, not existing means it's access denied too
if (file.exists() || operation() == QNetworkAccessManager::PutOperation)
error(QNetworkReply::ContentAccessDenied, msg);
else
error(QNetworkReply::ContentNotFoundError, msg);
finished();
}
}
void ChunkManager::Private::loadPriorityInfo()
{
//load priority info and if that fails load file info
File fptr;
if (!fptr.open(file_priority_file,"rb"))
{
loadFileInfo();
return;
}
Torrent & tor = p->tor;
Uint32 num = 0;
// first read the number of lines
if (fptr.read(&num,sizeof(Uint32)) != sizeof(Uint32) || num > 2*tor.getNumFiles())
{
Out(SYS_DIO|LOG_IMPORTANT) << "Warning : error reading chunk_info file" << endl;
loadFileInfo();
return;
}
Array<Uint32> buf(num);
if (fptr.read(buf,sizeof(Uint32)*num) != sizeof(Uint32)*num)
{
Out(SYS_DIO|LOG_IMPORTANT) << "Warning : error reading chunk_info file" << endl;
loadFileInfo();
return;
}
fptr.close();
for (Uint32 i = 0;i < num;i += 2)
{
Uint32 idx = buf[i];
if (idx >= tor.getNumFiles())
{
Out(SYS_DIO|LOG_IMPORTANT) << "Warning : error reading chunk_info file" << endl;
loadFileInfo();
return;
}
bt::TorrentFile & tf = tor.getFile(idx);
if (!tf.isNull())
{
// numbers are to be compatible with old chunk info files
switch(buf[i+1])
{
case FIRST_PRIORITY:
case 3:
tf.setPriority(FIRST_PRIORITY);
break;
case NORMAL_PRIORITY:
case 2:
// By default priority is set to normal, so do nothing
//tf.setPriority(NORMAL_PRIORITY);
break;
case EXCLUDED:
case 0:
//tf.setDoNotDownload(true);
tf.setPriority(EXCLUDED);
break;
case ONLY_SEED_PRIORITY:
case -1:
tf.setPriority(ONLY_SEED_PRIORITY);
break;
default:
tf.setPriority(LAST_PRIORITY);
break;
}
}
}
}
bool
Loader::loadRPL(UserModule &module, const char *buffer, size_t size)
{
auto in = BigEndianView { buffer, size };
auto header = elf::Header { };
auto info = elf::FileInfo { };
auto sections = std::vector<elf::Section> { };
// Read header
if (!elf::readHeader(in, header)) {
gLog->error("Failed elf::readHeader");
return false;
}
// Check it is a CAFE abi rpl
if (header.abi != elf::EABI_CAFE) {
gLog->error("Unexpected elf abi found {:02x} expected {:02x}", header.abi, elf::EABI_CAFE);
return false;
}
// Read sections
if (!elf::readSections(in, header, sections)) {
gLog->error("Failed elf::readSections");
return false;
}
// Process sections, find our data and code sections
processSections(module, sections, sections[header.shstrndx].data.data());
// Update EntryInfo
loadFileInfo(info, sections);
module.entryPoint = header.entry;
module.defaultStackSize = info.stackSize;
// Allocate code & data sections in memory
auto codeStart = module.codeAddressRange.first;
auto codeSize = module.maxCodeSize;
gMemory.alloc(codeStart, codeSize); // TODO: Append code to end of other loaded code sections
auto dataStart = alignUp(codeStart + codeSize, 4096);
auto dataSize = alignUp(module.dataAddressRange.second - module.dataAddressRange.first, 4096);
auto dataEnd = dataStart + dataSize;
gMemory.alloc(dataStart, dataSize); // TODO: Use OSDynLoad_MemAlloc for data section allocation
// Update MEM2 memory bounds
be_val<uint32_t> mem2start, mem2size;
OSGetMemBound(OSMemoryType::MEM2, &mem2start, &mem2size);
OSSetMemBound(OSMemoryType::MEM2, dataEnd, mem2size - (dataEnd - mem2start));
// Relocate sections
relocateSections(sections, module.codeAddressRange.first, codeStart, module.dataAddressRange.first, dataStart);
module.codeAddressRange.first = codeStart;
module.codeAddressRange.second = codeStart + codeSize;
module.dataAddressRange.first = dataStart;
module.dataAddressRange.second = dataStart + dataSize;
// Relocate entry point
for (auto i = 0u; i < sections.size(); ++i) {
auto §ion = sections[i];
if (section.header.addr <= header.entry && section.header.addr + section.data.size() > header.entry) {
auto offset = section.section->address - section.header.addr;
module.entryPoint = header.entry + offset;
break;
}
}
// Load sections into memory
loadSections(sections);
// Process small data sections
processSmallDataSections(module);
// Process symbols
// TODO: Support more than one symbol section?
for (auto i = 0u; i < sections.size(); ++i) {
auto §ion = sections[i];
if (section.header.type != elf::SHT_SYMTAB) {
continue;
}
processSymbols(module, section, sections);
}
// Process relocations
for (auto i = 0u; i < sections.size(); ++i) {
auto §ion = sections[i];
if (section.header.type != elf::SHT_RELA) {
continue;
}
processRelocations(module, section, sections);
}
if (0) {
// Print address ranges
gLog->debug("Loaded module!");
gLog->debug("Code {:08x} -> {:08x}", module.codeAddressRange.first, module.codeAddressRange.second);
gLog->debug("Data {:08x} -> {:08x}", module.dataAddressRange.first, module.dataAddressRange.second);
// Print all sections
gLog->debug("Sections:");
for (auto i = 0u; i < module.sections.size(); ++i) {
auto section = module.sections[i];
gLog->debug("{:08x} {} {:x}", section->address, section->name, section->size);
}
// Print all symbols
gLog->debug("Symbols:");
for (auto i = 0u; i < module.symbols.size(); ++i) {
auto symbol = module.symbols[i];
if (symbol && symbol->name.size()) {
gLog->debug("{:08x} {}", symbol->address, symbol->name);
}
}
}
return true;
}