PortManager::PortManager( util::daemon::Daemon & daemon) : ppbox::common::CommonModuleBase<PortManager>(daemon, "PortManager") { ports_ = (PortContainer *)shared_memory().alloc_with_id(PORTMANAGE_OBJECT_ID, sizeof(PortContainer)); if (ports_) { new (ports_) PortContainer(); } else { ports_ = (PortContainer *)shared_memory().get_by_id(PORTMANAGE_OBJECT_ID); } }
SharedPtr<SharedMemory> SharedMemory::Create(std::string name) { SharedPtr<SharedMemory> shared_memory(new SharedMemory); shared_memory->name = std::move(name); return shared_memory; }
IDL_VPTR IDL_CDECL idl_bam_cxc_get_data(int argc, IDL_VPTR argv[]) { QSharedMemory shared_memory("photo"); //QTextStream(stdout) << shared_memory.nativeKey() << endl; if (!shared_memory.attach(QSharedMemory::ReadOnly)) { IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Could not attach to shared memory block photo"); } shared_memory.lock(); int size = shared_memory.size(); if (size != sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS) { shared_memory.unlock(); shared_memory.detach(); IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Unexpected size for shared memory block photo"); } const unsigned int *data = (const unsigned int *) shared_memory.data(); unsigned int *data_copy = (unsigned int *) malloc(sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS); memcpy(data_copy, data, sizeof(unsigned int) * NPIXELX * NPIXELY * NCHANNELS); shared_memory.unlock(); shared_memory.detach(); int n_dim = 3; IDL_MEMINT dim[3] = {NCHANNELS, NPIXELY, NPIXELX}; IDL_VPTR rv = IDL_ImportArray(n_dim, dim, IDL_TYP_ULONG, (UCHAR *) data_copy, (IDL_ARRAY_FREE_CB) free, 0); return rv; }
static unsigned long int* get_shared_memory(const char* key) { QSharedMemory shared_memory(key); //QTextStream(stdout) << shared_memory.nativeKey() << endl; if (!shared_memory.attach(QSharedMemory::ReadOnly)) { IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Could not attach to shared memory block %s", key); } shared_memory.lock(); int size = shared_memory.size(); if (size != sizeof(unsigned long int) * NPIXELX * NPIXELY) { shared_memory.unlock(); shared_memory.detach(); IDL_MessageFromBlock(bam_cxc_msg_block, BAM_CXC_ERROR, IDL_MSG_LONGJMP, "Unexpected size for shared memory block %s", key); } const unsigned long int *data = (const unsigned long int *) shared_memory.data(); unsigned long int *data_copy = (unsigned long int *) malloc(sizeof(unsigned long int) * NPIXELX * NPIXELY); memcpy(data_copy, data, sizeof(unsigned long int) * NPIXELX * NPIXELY); shared_memory.unlock(); shared_memory.detach(); return data_copy; }
Debuger::Debuger( util::daemon::Daemon & daemon) : ppbox::common::CommonModuleBase<Debuger>(daemon, "Debuger") , debug_log_stream_(NULL) , hook_log_stream_(NULL) , timer_(NULL) , msg_queue_("Debuger", shared_memory()) , out_streamed_(false) , hook_streamed_(false) { debug_mode_ = (boost::uint32_t *)shared_memory().alloc_with_id(DEBUG_OBJECT_ID, sizeof(boost::uint32_t)); if (debug_mode_) { new (debug_mode_) boost::uint32_t(0); } else { debug_mode_ = (boost::uint32_t *)shared_memory().get_by_id(DEBUG_OBJECT_ID); } check_debug_mode(); }
SharedPtr<SharedMemory> SharedMemory::Create(u32 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) { SharedPtr<SharedMemory> shared_memory(new SharedMemory); shared_memory->name = std::move(name); shared_memory->base_address = 0x0; shared_memory->fixed_address = 0x0; shared_memory->size = size; shared_memory->permissions = permissions; shared_memory->other_permissions = other_permissions; return shared_memory; }
void rpcudp::_recv_thread_impl(sysptr_t) { size_t bufsize = _get_mtu(); udpaddr addr; int addrlen = sizeof(addr); int code = 0; char* tmp = new char[bufsize]; char* buffer = tmp; while (true) { void* ptr = _alloc_memory_raw(bufsize); code = _recvfrom_impl(buffer, bufsize, 0, addr, addrlen); if (code == SOCKET_ERROR) {//TODO:加上udpsock失效不提示 #ifdef _LOG_RPCUDP_RUNNING mylog.log(log_error, "rpcudp recvfrom have socket error code:", WSAGetLastError()); #endif break; } shared_memory recvbuf; //减少ack包带来的内存损耗 /* if (code < static_cast<size_t>(bufsize / 2)) { char* small_buffer = new char[code]; memcpy(small_buffer, buffer, code); recvbuf = shared_memory(memory_block(small_buffer, code)); _memory_count += code; } else*/ if (true) { recvbuf = shared_memory(memory_block(buffer, code)); buffer = new char[bufsize]; _memory_count += bufsize; } _package_process(addr, addrlen, recvbuf, code); } delete buffer; }
SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) { SharedPtr<SharedMemory> shared_memory(new SharedMemory); shared_memory->owner_process = nullptr; shared_memory->name = std::move(name); shared_memory->size = size; shared_memory->permissions = permissions; shared_memory->other_permissions = other_permissions; shared_memory->backing_block = heap_block; shared_memory->backing_block_offset = offset; shared_memory->base_address = Memory::HEAP_VADDR + offset; return shared_memory; }
int main(int argc, char *argv[]){ pid_t pid; // initialize shared memory for IPCs shared_memory(); pid = fork(); switch(pid){ case -1: // process creation failed die("process creation failed"); case 0: // input process pid = fork(); switch(pid){ case -1: // process creation failed die("process creation failed"); case 0: // event key process (input) return eventkey_process(); default: // input process return input_process(); } default: pid = fork(); switch(pid){ case -1: // process creation failed die("process creation failed"); case 0: // output process return output_process(); default: // main process main_process(); } } free_shared(); return 0; }
void create() { jabber2avail = shared_memory("jabber2avail"); ::create(); }
SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u32 size, MemoryPermission permissions, MemoryPermission other_permissions, VAddr address, MemoryRegion region, std::string name) { SharedPtr<SharedMemory> shared_memory(new SharedMemory); shared_memory->owner_process = owner_process; shared_memory->name = std::move(name); shared_memory->size = size; shared_memory->permissions = permissions; shared_memory->other_permissions = other_permissions; if (address == 0) { // We need to allocate a block from the Linear Heap ourselves. // We'll manually allocate some memory from the linear heap in the specified region. MemoryRegionInfo* memory_region = GetMemoryRegion(region); auto& linheap_memory = memory_region->linear_heap_memory; ASSERT_MSG(linheap_memory->size() + size <= memory_region->size, "Not enough space in region to allocate shared memory!"); shared_memory->backing_block = linheap_memory; shared_memory->backing_block_offset = linheap_memory->size(); // Allocate some memory from the end of the linear heap for this region. linheap_memory->insert(linheap_memory->end(), size, 0); memory_region->used += size; shared_memory->linear_heap_phys_address = Memory::FCRAM_PADDR + memory_region->base + shared_memory->backing_block_offset; // Increase the amount of used linear heap memory for the owner process. if (shared_memory->owner_process != nullptr) { shared_memory->owner_process->linear_heap_used += size; } // Refresh the address mappings for the current process. if (Kernel::g_current_process != nullptr) { Kernel::g_current_process->vm_manager.RefreshMemoryBlockMappings(linheap_memory.get()); } } else { // TODO(Subv): What happens if an application tries to create multiple memory blocks // pointing to the same address? auto& vm_manager = shared_memory->owner_process->vm_manager; // The memory is already available and mapped in the owner process. auto vma = vm_manager.FindVMA(address)->second; // Copy it over to our own storage shared_memory->backing_block = std::make_shared<std::vector<u8>>( vma.backing_block->data() + vma.offset, vma.backing_block->data() + vma.offset + size); shared_memory->backing_block_offset = 0; // Unmap the existing pages vm_manager.UnmapRange(address, size); // Map our own block into the address space vm_manager.MapMemoryBlock(address, shared_memory->backing_block, 0, size, MemoryState::Shared); // Reprotect the block with the new permissions vm_manager.ReprotectRange(address, size, ConvertPermissions(permissions)); } shared_memory->base_address = address; return shared_memory; }