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