/* * alloc_sem() - allocate semaphores * @num - no. of semaphores to create * * Allocate and initialize semaphores in a shared memory area, so that * the semaphore can be used accross processes. * * RETURNS: * Array of initialized semaphores. */ sem_t *alloc_sem(int num) { sem_t *sem; void *sem_mem; int i, ret; sem_mem = mmap(NULL, get_page_size(), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0); if (sem_mem == MAP_FAILED) { tst_resm(TBROK | TERRNO, "allocation of semaphore page failed"); goto err_exit; } sem = sem_mem; for (i = 0; i < num; i++) { ret = sem_init(&sem[i], 1, 0); if (ret == -1) { tst_resm(TBROK | TERRNO, "semaphore initialization " "failed"); goto err_free_mem; } } return sem; err_free_mem: ret = munmap(sem_mem, get_page_size()); if (ret == -1) tst_resm(TWARN | TERRNO, "error freeing semaphore memory"); err_exit: return NULL; }
/* * alloc_shared_pages_on_node() - allocate shared pages on a NUMA node * @pages: array to store the allocated pages * @num: the no. of pages to allocate * @node: the node in which the pages should be allocated * * RETURNS: * 0 on success, -1 on allocation failure */ int alloc_shared_pages_on_node(void **pages, unsigned int num, int node) { #if HAVE_NUMA_H char *shared; unsigned int i; int nodes[num]; size_t total_size = num * get_page_size(); shared = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0); if (shared == MAP_FAILED) { tst_resm(TBROK | TERRNO, "allocation of shared pages failed"); return -1; } numa_tonode_memory(shared, total_size, node); for (i = 0; i < num; i++) { char *page; pages[i] = shared; shared += get_page_size(); nodes[i] = node; /* Touch the page to force allocation */ page = pages[i]; page[0] = i; } return 0; #else return -1; #endif }
void *kmalloc(unsigned sz) { /* We need to add a small header to the allocation to track which cache (if any) it came from. It must be a multiple of the pointer size in order that the address after it (which we will be returning) has natural alignment. */ sz += sizeof(uintptr_t); uintptr_t *ptr; unsigned l2 = log2_roundup(sz); if (l2 < MIN_CACHESZ_LOG2) l2 = MIN_CACHESZ_LOG2; if (l2 >= MIN_CACHESZ_LOG2 && l2 <= MAX_CACHESZ_LOG2) { ptr = (uintptr_t*)slab_cache_alloc(&caches[l2-MIN_CACHESZ_LOG2]); } else { /* Get the size as the smallest power of 2 >= sz */ unsigned sz_p2 = 1U << l2; if (sz_p2 < get_page_size()) { sz_p2 = get_page_size(); l2 = log2_roundup(sz_p2); } ptr = (uintptr_t*)vmspace_alloc(&kernel_vmspace, sz_p2, 1); } ptr[0] = (KMALLOC_CANARY << 8) | l2; return &ptr[1]; }
static void * map_buffer (counter_t *counter, GError **err) { int n_bytes = N_PAGES * get_page_size(); void *address; address = mmap (NULL, n_bytes + get_page_size(), PROT_READ | PROT_WRITE, MAP_SHARED, counter->fd, 0); if (address == MAP_FAILED) return fail (err, "mmap"); return address; }
static void perf_event_read(struct event_ring_info *ring, void **buf, size_t *buf_len) { enum bpf_perf_event_ret ret; ret = bpf_perf_event_read_simple(ring->mem, MMAP_PAGE_CNT * get_page_size(), get_page_size(), buf, buf_len, print_bpf_output, ring); if (ret != LIBBPF_PERF_EVENT_CONT) { fprintf(stderr, "perf read loop failed with %d\n", ret); stop = true; } }
void *realloc(void *addr, size_t len) { t_page_list *lst; int item; if (addr == NULL) return (malloc(len)); MALLOC_LOCK(); lst = g_pages; while (lst) { if (lst->page.type == LARGE && addr == lst->page.addr) return (realloc_large(lst, addr, len)); else if (lst->page.type != LARGE && addr >= lst->page.addr && addr <= lst->page.addr + get_page_size(lst->page.type)) { item = (addr - lst->page.addr) / get_block_size(lst->page.type); if (lst->page.addr + get_block_size(lst->page.type) * item == addr) return (realloc_small_tiny(lst, addr, len)); return (return_enomem(NULL)); } lst = lst->next; } MALLOC_UNLOCK(); return (return_enomem(NULL)); }
/* * alloc_pages_on_nodes() - allocate pages on specified NUMA nodes * @pages: array in which the page pointers will be stored * @num: no. of pages to allocate * @nodes: array of NUMA nodes * * A page will be allocated in each node specified by @nodes, and the * page pointers will be stored in @pages array. * * RETURNS: * 0 on success, -1 on allocation failure. */ int alloc_pages_on_nodes(void **pages, unsigned int num, int *nodes) { int i; #if HAVE_NUMA_ALLOC_ONNODE size_t onepage = get_page_size(); #endif for (i = 0; i < num; i++) { pages[i] = NULL; } for (i = 0; i < num; i++) { char *page; #if HAVE_NUMA_ALLOC_ONNODE pages[i] = numa_alloc_onnode(onepage, nodes[i]); #endif if (pages[i] == NULL) { tst_resm(TBROK, "allocation of page on node " "%d failed", nodes[i]); break; } /* Touch the page, to force allocation. */ page = pages[i]; page[0] = i; } if (i == num) return 0; free_pages(pages, num); return -1; }
void get_proc_mem (dbgov_proc_mem * buf, pid_t pid, pid_t tid) { char buffer[BUFSIZ], *p; const size_t pagesize = get_page_size (); memset (buf, 0, sizeof (dbgov_proc_mem)); int res = try_file_to_buffer (buffer, "/proc/%d/task/%d/stat", pid, tid); if (res == TRY_FILE_TO_BUFFER_OK_IOSTAT) { p = proc_stat_after_cmd (buffer); if (!p) return; p = skip_multiple_token (p, 20); buf->vsize = strtoull (p, &p, 0); buf->rss = strtoull (p, &p, 0); buf->rss_rlim = strtoull (p, &p, 0); int res = try_file_to_buffer(buffer, "/proc/%d/task/%d/statm", pid, tid); if (res == TRY_FILE_TO_BUFFER_OK_IOSTAT) { buf->size = strtoull (buffer, &p, 0); buf->resident = strtoull (p, &p, 0); buf->share = strtoull (p, &p, 0); } buf->size *= pagesize; buf->resident *= pagesize; buf->share *= pagesize; buf->rss *= pagesize; } }
void free(void *addr) { t_page_list *prv; t_page_list *lst; if (!addr) return ; MALLOC_LOCK(); prv = NULL; lst = g_pages; while (lst) { if (lst->page.type == LARGE && case_large(addr, prv, lst)) return ; else if (lst->page.type != LARGE && addr >= lst->page.addr && addr <= lst->page.addr + get_page_size(lst->page.type)) { case_else(addr, lst); return ; } prv = lst; lst = lst->next; } MALLOC_UNLOCK(); }
int main(int argc, char *argv[]) { DCL_THREADGBL_ACCESS; GTM_THREADGBL_INIT; set_blocksig(); gtm_imagetype_init(DSE_IMAGE); gtm_wcswidth_fnptr = gtm_wcswidth; gtm_env_init(); /* read in all environment variables */ licensed = TRUE; TREF(transform) = TRUE; op_open_ptr = op_open; patch_curr_blk = get_dir_root(); err_init(util_base_ch); GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */ sig_init(generic_signal_handler, dse_ctrlc_handler, suspsigs_handler); atexit(util_exit_handler); SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE); get_page_size(); stp_init(STP_INITSIZE); rts_stringpool = stringpool; getjobname(); INVOKE_INIT_SECSHR_ADDRS; getzdir(); prealloc_gt_timers(); initialize_pattern_table(); gvinit(); region_init(FALSE); INIT_GBL_ROOT(); /* Needed for GVT initialization */ getjobnum(); util_out_print("!/File !_!AD", TRUE, DB_LEN_STR(gv_cur_region)); util_out_print("Region!_!AD!/", TRUE, REG_LEN_STR(gv_cur_region)); cli_lex_setup(argc, argv); CREATE_DUMMY_GBLDIR(gd_header, original_header, gv_cur_region, gd_map, gd_map_top); gtm_chk_dist(argv[0]); # ifdef DEBUG if ((gtm_white_box_test_case_enabled && (WBTEST_SEMTOOLONG_STACK_TRACE == gtm_white_box_test_case_number) )) { sgmnt_addrs * csa; node_local_ptr_t cnl; csa = &FILE_INFO(gv_cur_region)->s_addrs; cnl = csa->nl; cnl->wbox_test_seq_num = 1; /*Signal the first step and wait here*/ while (2 != cnl->wbox_test_seq_num) /*Wait for another process to get hold of the semaphore and signal next step*/ LONG_SLEEP(10); } # endif if (argc < 2) display_prompt(); io_init(TRUE); while (1) { if (!dse_process(argc)) break; display_prompt(); } dse_exit(); REVERT; }
/* * free_shared_pages() - free shared pages * @pages: array of pages to be freed * @num: the no. of pages to free */ void free_shared_pages(void **pages, unsigned int num) { int ret; ret = munmap(pages[0], num * get_page_size()); if (ret == -1) tst_resm(TWARN | TERRNO, "unmapping of shared pages failed"); }
/* check if the current directory allows exec mappings */ static int check_current_dir_for_exec(void) { int fd; char tmpfn[] = "anonmap.XXXXXX"; void *ret = MAP_FAILED; fd = mkstemps( tmpfn, 0 ); if (fd == -1) return 0; if (grow_file( fd, 1 )) { ret = mmap( NULL, get_page_size(), PROT_READ | PROT_EXEC, MAP_PRIVATE, fd, 0 ); if (ret != MAP_FAILED) munmap( ret, get_page_size() ); } close( fd ); unlink( tmpfn ); return (ret != MAP_FAILED); }
static void free_stack_and_tls(uintptr_t stack) { unsigned pagesz = get_page_size(); unsigned flags; for (unsigned i = 0; i < THREAD_STACK_SZ; i += pagesz) { free_page(get_mapping(stack+i, &flags)); unmap(stack+i, 1); } }
static int test() { xbitmap_t xb; uintptr_t loc = 0x20000000; xbitmap_init(&xb, get_page_size(), &alloc, &free, (void*)&loc); // CHECK: isset(0) = 0 kprintf("isset(0) = %d\n", xbitmap_isset(&xb, 0)); // CHECK: isclear(0) = 1 kprintf("isclear(0) = %d\n", xbitmap_isclear(&xb, 0)); xbitmap_set(&xb, 0); // CHECK: isset(0) = 1 kprintf("isset(0) = %d\n", xbitmap_isset(&xb, 0)); // CHECK: isclear(0) = 0 kprintf("isclear(0) = %d\n", xbitmap_isclear(&xb, 0)); xbitmap_clear(&xb, 0); // CHECK: isset(0) = 0 kprintf("isset(0) = %d\n", xbitmap_isset(&xb, 0)); xbitmap_set(&xb, 5); xbitmap_set(&xb, 7); xbitmap_set(&xb, 12); xbitmap_set(&xb, 20); // CHECK: first_set() = 5 kprintf("first_set() = %d\n", xbitmap_first_set(&xb)); xbitmap_clear(&xb, 5); // CHECK: first_set() = 7 kprintf("first_set() = %d\n", xbitmap_first_set(&xb)); // CHECK: isset(0x8456) = 0 kprintf("isset(0x8456) = %d\n", xbitmap_isset(&xb, 0x8456)); xbitmap_set(&xb, 0x8456); // CHECK: isset(0x8456) = 1 kprintf("isset(0x8456) = %d\n", xbitmap_isset(&xb, 0x8456)); // CHECK: isset(0x8455) = 0 kprintf("isset(0x8455) = %d\n", xbitmap_isset(&xb, 0x8455)); // CHECK: isset(12) = 1 kprintf("isset(12) = %d\n", xbitmap_isset(&xb, 12)); xbitmap_clear(&xb, 7); xbitmap_clear(&xb, 12); xbitmap_clear(&xb, 20); // CHECK: isset(6) = 0 kprintf("isset(6) = %d\n", xbitmap_isset(&xb, 6)); // CHECK: first_set() = 0x8456 kprintf("first_set() = 0x%x\n", xbitmap_first_set(&xb)); xbitmap_clear(&xb, 0x8456); // CHECK: first_set() = -1 kprintf("first_set() = %d\n", xbitmap_first_set(&xb)); return 0; }
static uintptr_t alloc_stack_and_tls() { unsigned pagesz = get_page_size(); uintptr_t addr = vmspace_alloc(&kernel_vmspace, THREAD_STACK_SZ, 0); for (unsigned i = 0; i < THREAD_STACK_SZ; i += pagesz) map(addr+i, alloc_page(PAGE_REQ_NONE), 1, PAGE_WRITE); return addr; }
Queue* create_queue() { int size = get_page_size()/sizeof(Elem); Queue* queue = (Queue*) malloc(sizeof(Queue)); queue->block = (Elem*) malloc(size*sizeof(Elem)); queue->head = 0; queue->tail = 0; queue->size = size; return queue; }
char* OS::allocate_idealized_page_aligned(int32 &size, const char *name, caddr_t desiredAddress, bool mustAllocate) { size= roundTo(size, idealized_page_size); assert(idealized_page_size % get_page_size() == 0, "page size mismatch"); char* b = allocate_heap_aligned(desiredAddress, size, idealized_page_size, name, mustAllocate); if (b == NULL) size= 0; return b; }
int ibv_fork_init(void) { void *tmp, *tmp_aligned; int ret; unsigned long size; if (mm_root) return 0; if (too_late) return EINVAL; page_size = sysconf(_SC_PAGESIZE); if (page_size < 0) return errno; if (posix_memalign(&tmp, page_size, page_size)) return ENOMEM; if (getenv("RDMAV_HUGEPAGES_SAFE")) huge_page_enabled = 1; else huge_page_enabled = 0; if (huge_page_enabled) { size = get_page_size(tmp); tmp_aligned = (void *)((uintptr_t) tmp & ~(size - 1)); } else { size = page_size; tmp_aligned = tmp; } ret = madvise(tmp_aligned, size, MADV_DONTFORK) || madvise(tmp_aligned, size, MADV_DOFORK); free(tmp); if (ret) return ENOSYS; mm_root = malloc(sizeof *mm_root); if (!mm_root) return ENOMEM; mm_root->parent = NULL; mm_root->left = NULL; mm_root->right = NULL; mm_root->color = IBV_BLACK; mm_root->start = 0; mm_root->end = UINTPTR_MAX; mm_root->refcnt = 0; return 0; }
static void counter_free (counter_t *counter) { d_print ("munmap\n"); munmap (counter->mmap_page, (N_PAGES + 1) * get_page_size()); fd_remove_watch (counter->fd); close (counter->fd); g_free (counter); }
int appfs_mem_getpageinfo(const devfs_handle_t * handle, void * ctl){ DECLARE_APPFS_CONFIG(); u32 size = 0; mem_pageinfo_t * pageinfo = ctl; if( pageinfo->o_flags & MEM_FLAG_IS_QUERY ){ u32 type; pageinfo->num = get_page(config, pageinfo->addr, 0, &type); pageinfo->size = get_page_size(config, pageinfo->num, MEM_FLAG_IS_RAM); pageinfo->o_flags = type; if( type == 0 ){ return SYSFS_SET_RETURN(EINVAL); } return 0; } size = get_page_size(config, pageinfo->num, pageinfo->o_flags); if (size == 0 ){ return SYSFS_SET_RETURN(EINVAL); } pageinfo->addr = get_page_addr(config, pageinfo->num, pageinfo->o_flags); pageinfo->size = size; return 0; }
int FlashIAP::init() { int ret = 0; _mutex->lock(); if (flash_init(&_flash)) { ret = -1; } uint32_t page_size = get_page_size(); _page_buf = new uint8_t[page_size]; _mutex->unlock(); return ret; }
/* len is the total size (in ints) */ static int check_process_write_access( struct thread *thread, long *addr, data_size_t len ) { int page = get_page_size() / sizeof(int); for (;;) { if (write_thread_long( thread, addr, 0, 0 ) == -1) return 0; if (len <= page) break; addr += page; len -= page; } return (write_thread_long( thread, addr + len - 1, 0, 0 ) != -1); }
void mapped_region::move(offset_t offset, std::size_t length, void *buffer) { if(buffer_ != 0) { close(); } int prots = 0; int flags = 0; switch(acmode_) { case ReadOnly: prots |= PROT_READ; flags |= MAP_SHARED; break; case ReadWrite: prots |= (PROT_WRITE | PROT_READ); flags |= MAP_SHARED; break; case CopyOnWrite: prots |= (PROT_WRITE | PROT_READ); flags |= MAP_PRIVATE; break; default: throw ipc_error("unknown mapping mode", 0); break; } // mapped region must be page aligned size_t page_size = get_page_size(); offset_t extra_offset= offset - (offset / page_size) * page_size; if(buffer) { buffer = static_cast<char* >(buffer) - extra_offset; } void* base = mmap(buffer, extra_offset + length, prots, flags, handle_, offset - extra_offset); if(base == MAP_FAILED) { int errcode = sys::err::get(); close(); throw ipc_error("mmap failed", errcode); } buffer_ = static_cast<char* >(base) + extra_offset; extoff_ = extra_offset; offset_ = offset; length_ = length; if(buffer && (base != buffer)) { close(); throw ipc_error("can't mapping to specified address", 0); } }
static int read_misc(unsigned page_offset, void *buf, unsigned size) { const char *ptn_name = "misc"; uint32_t pagesize = get_page_size(); unsigned offset; if (size == 0 || buf == NULL) return -1; offset = page_offset * pagesize; if (target_is_emmc_boot()) { int index; unsigned long long ptn; unsigned long long ptn_size; index = partition_get_index(ptn_name); if (index == INVALID_PTN) { dprintf(CRITICAL, "No '%s' partition found\n", ptn_name); return -1; } ptn = partition_get_offset(index); ptn_size = partition_get_size(index); mmc_set_lun(partition_get_lun(index)); if (ptn_size < offset + size) { dprintf(CRITICAL, "Read request out of '%s' boundaries\n", ptn_name); return -1; } if (mmc_read(ptn + offset, (unsigned int *)buf, size)) { dprintf(CRITICAL, "Reading MMC failed\n"); return -1; } } else { dprintf(CRITICAL, "Misc partition not supported for NAND targets.\n"); return -1; } return 0; }
int FlashIAP::program(const void *buffer, uint32_t addr, uint32_t size) { uint32_t page_size = get_page_size(); uint32_t flash_size = flash_get_size(&_flash); uint32_t flash_start_addr = flash_get_start_address(&_flash); uint32_t chunk, prog_size; const uint8_t *buf = (uint8_t *) buffer; const uint8_t *prog_buf; // addr should be aligned to page size if (!is_aligned(addr, page_size) || (!buffer) || ((addr + size) > (flash_start_addr + flash_size))) { return -1; } int ret = 0; _mutex->lock(); while (size) { uint32_t current_sector_size = flash_get_sector_size(&_flash, addr); bool unaligned_src = (((size_t) buf / sizeof(uint32_t) * sizeof(uint32_t)) != (size_t) buf); chunk = std::min(current_sector_size - (addr % current_sector_size), size); // Need to use the internal page buffer in any of these two cases: // 1. Size is not page aligned // 2. Source buffer is not aligned to uint32_t. This is not supported by many targets (although // the pointer they accept is of uint8_t). if (unaligned_src || (chunk < page_size)) { chunk = std::min(chunk, page_size); memcpy(_page_buf, buf, chunk); if (chunk < page_size) { memset(_page_buf + chunk, 0xFF, page_size - chunk); } prog_buf = _page_buf; prog_size = page_size; } else { chunk = chunk / page_size * page_size; prog_buf = buf; prog_size = chunk; } if (flash_program_page(&_flash, addr, prog_buf, prog_size)) { ret = -1; break; } size -= chunk; addr += chunk; buf += chunk; } _mutex->unlock(); return ret; }
/* * free_pages() - free an array of pages * @pages: array of page pointers to be freed * @num: no. of pages in the array */ void free_pages(void **pages, unsigned int num) { #if HAVE_NUMA_H int i; size_t onepage = get_page_size(); for (i = 0; i < num; i++) { if (pages[i] != NULL) { numa_free(pages[i], onepage); } } #endif }
/* * free_sem() - free semaphores * @sem - array of semphores to be freed * @num - no. of semaphores in the array */ void free_sem(sem_t * sem, int num) { int i; int ret; for (i = 0; i < num; i++) { ret = sem_destroy(&sem[i]); if (ret == -1) tst_resm(TWARN | TERRNO, "error destroying semaphore"); } ret = munmap(sem, get_page_size()); if (ret == -1) tst_resm(TWARN | TERRNO, "error freeing semaphore memory"); }
static int free_memory() { if ((mboot.flags & MBOOT_MMAP) == 0) panic("Bootloader did not provide memory map info!"); range_t ranges[32], ranges_cpy[32]; uint32_t i = mboot.mmap_addr; unsigned n = 0; uint64_t extent = 0; while (i < mboot.mmap_addr+mboot.mmap_length) { if (n >= 128) break; multiboot_mmap_entry_t *entry = (multiboot_mmap_entry_t*)i; if (MBOOT_IS_MMAP_TYPE_RAM(entry->type)) { ranges[n].start = entry->base_addr; ranges[n++].extent = entry->length; if (entry->base_addr + entry->length > extent) extent = entry->base_addr + entry->length; } //kprintf("e: sz %x addr %x len %x ty %x\n", entry->size, (uint32_t)entry->base_addr, (uint32_t)entry->length, entry->type); i += entry->size + 4; } extern int __start, __end; uintptr_t end = (((uintptr_t)&__end) & ~get_page_mask()) + get_page_size(); for (i = 0; i < n; ++i) remove_range(&ranges[i], (uintptr_t)&__start, end); for (i = 0; i < n; ++i) { //kprintf("r: %x ext %x\n", (uint32_t)ranges[i].start, (uint32_t)ranges[i].extent); } /* Copy the ranges to a backup, as init_physical_memory mutates them and init_cow_refcnts needs to run after init_physical_memory */ for (i = 0; i < n; ++i) ranges_cpy[i] = ranges[i]; init_physical_memory_early(ranges, n, extent); init_virtual_memory(ranges, n); init_physical_memory(); init_cow_refcnts(ranges, n); return 0; }
int get_ffbm(char *ffbm, unsigned size) { const char *ffbm_cmd = "ffbm-"; uint32_t page_size = get_page_size(); char *ffbm_page_buffer = NULL; int retval = 0; if (size < FFBM_MODE_BUF_SIZE || size >= page_size) { dprintf(CRITICAL, "Invalid size argument passed to get_ffbm\n"); retval = -1; goto cleanup; } ffbm_page_buffer = (char*)malloc(page_size); if (!ffbm_page_buffer) { dprintf(CRITICAL, "Failed to alloc buffer for ffbm cookie\n"); retval = -1; goto cleanup; } if (read_misc(0, ffbm_page_buffer, page_size)) { dprintf(CRITICAL, "Error reading MISC partition\n"); retval = -1; goto cleanup; } ffbm_page_buffer[size] = '\0'; if (strncmp(ffbm_cmd, ffbm_page_buffer, strlen(ffbm_cmd))) { retval = 0; goto cleanup; } else { if (strlcpy(ffbm, ffbm_page_buffer, size) < FFBM_MODE_BUF_SIZE -1) { dprintf(CRITICAL, "Invalid string in misc partition\n"); retval = -1; } else retval = 1; } cleanup: if(ffbm_page_buffer) free(ffbm_page_buffer); return retval; }
void mips_cp0_unmap_tlb_to_mts (cpu_mips_t * cpu, int index) { m_va_t v0_addr, v1_addr; m_uint32_t page_size; tlb_entry_t *entry; entry = &cpu->cp0.tlb[index]; page_size = get_page_size (entry->mask); v0_addr = entry->hi & mips_cp0_get_vpn2_mask (cpu); v1_addr = v0_addr + page_size; if (entry->lo0 & MIPS_TLB_V_MASK) cpu->mts_unmap (cpu, v0_addr, page_size, MTS_ACC_T, index); if (entry->lo1 & MIPS_TLB_V_MASK) cpu->mts_unmap (cpu, v1_addr, page_size, MTS_ACC_T, index); }