int main(int argc, char *argv[]) { char *kernel="/kernel", *ptr; int i, dos=0; long howto=0; extern unsigned long get_diskinfo(int); VCPIboot = 0; slice = 0; for (i = 1; i < argc; i++) { /* check arguments */ if (argv[i][0] != '-') { /* kernel name */ kernel = argv[i]; break; } ptr = &argv[i][1]; while (*ptr) { /* check options */ switch(*ptr) { case 'r': howto |= RB_DFLTROOT; break; case 's': howto |= RB_SINGLE; break; case 'a': howto |= RB_ASKNAME; break; case 'c': howto |= RB_CONFIG; break; case 'd': howto |= RB_KDB; break; case 'g': howto |= RB_GDB; break; case 'v': howto |= RB_VERBOSE; break; case 'C': howto |= RB_CDROM; break; case 'D': dos = 1; kernel = "c:\\kernel"; break; case '?': default: usage(argv[0]); } ptr++; } } bootinfo.bi_version = BOOTINFO_VERSION; for (i = 0; i < N_BIOS_GEOM; i++) bootinfo.bi_bios_geom[i] = get_diskinfo(0x80+i); bootinfo.bi_basemem = memsize(0); bootinfo.bi_extmem = memsize(1); bootinfo.bi_memsizes_valid = 0; /* that is not yet valid!! */ bootinfo.bi_kernelname = (char *) ptr2pa(kernel); bootinfo.bi_nfs_diskless = NULL; bootinfo.bi_size = sizeof(bootinfo); if (dos) dosboot(howto, kernel); /* boot given kernel from DOS partition */ else bsdboot(0x80, howto, kernel); /* boot from FreeBSD partition */ return 0; }
void __init prom_meminit(void) { unsigned long pages; pages = memsize() >> PAGE_SHIFT; add_memory_region(PHYS_OFFSET, pages << PAGE_SHIFT, BOOT_MEM_RAM); }
static int pt_section_memsize_locked(const struct pt_section *section, uint64_t *psize) { uint64_t msize, bcsize; int (*memsize)(const struct pt_section *section, uint64_t *size); int errcode; if (!section || !psize) return -pte_internal; memsize = section->memsize; if (!memsize) { if (section->mcount) return -pte_internal; *psize = 0ull; return 0; } errcode = memsize(section, &msize); if (errcode < 0) return errcode; errcode = pt_section_bcache_memsize(section, &bcsize); if (errcode < 0) return errcode; *psize = msize + bcsize; return 0; }
void bitmap::clear(void) { unsigned bs = memsize(); if(size % bs) ++size; while(size--) { switch(bus) { #if !defined(_MSC_VER) || _MSC_VER >= 1400 case B64: *(addr.d++) = 0ll; break; #endif case B32: *(addr.l++) = 0l; break; case B16: *(addr.w++) = 0; break; default: *(addr.b++) = 0; } } }
//------------------------------------------------------------------------ //------------------------------------------------------------------------ void Texture::deallocBuffer() { if (buffer) MemPool::getSingleton()->free(memsize(),buffer); buffer=0; }
/* * Machine-dependent startup code */ startup() { register i; maxmem = memsize (); i = usermem (); /* * zero and free all of core */ for(;;) { if(i == maxmem) break; clearseg(i); mfree (coremap, 1, i); i++; } printf("mem = %D\n", ctob((long)maxmem)); if(MAXMEM < maxmem) maxmem = MAXMEM; mfree(swapmap, nswap, 1); swplo--; }
/* NORETURN */ void boot(int drive) { int ret; #ifdef PC98 int i; unsigned char disk_equips; #endif /* Pick up the story from the Bios on geometry of disks */ #ifdef PC98 for(ret = 0; ret < 2; ret ++) { if (*(unsigned char*)V(0xA155d) & (1 << ret)) { bootinfo.bi_bios_geom[ret] = get_diskinfo(ret + 0x80); } #else /* IBM-PC */ for(ret = 0; ret < N_BIOS_GEOM; ret ++) bootinfo.bi_bios_geom[ret] = get_diskinfo(ret + 0x80); #endif /* PC98 */ } bootinfo.bi_basemem = memsize(0); bootinfo.bi_extmem = memsize(1); bootinfo.bi_memsizes_valid = 1; gateA20(); #ifdef PC98 /* set machine type to PC98_SYSTEM_PARAMETER */ machine_check(); #endif /* PC98 */ /* * The default boot device is the first partition in the * compatibility slice on the boot drive. */ dosdev = drive; #ifdef PC98 maj = (drive&0x70) >> 3; /* a good first bet */ if (maj == 4) { /* sd */ disk_equips = *(unsigned char *)V(0xA1482); unit = 0; for (i=0; i<(drive&0x0f); i++) { unit += (disk_equips >> i) & 1; } } else {
void *malloc_hook(stable_t *sp, size_t size) { void *ptr; size_t ms = memsize(size); size += sizeof (size_t); ptr = malloc(size); if ( !ptr ) return NULL; *(size_t *) ptr = size; if ( sp ) sp->memalloced += ms; return ((size_t *) ptr) + 1; }
/* * reallocs the memory at *ptr so that it is always * available for use by anoter thread */ void realloc_hook(stable_t *sp, void **ptr, size_t size) { void *ptrtmp, *ptrsave; size_t ms = memsize(size); size_t oldsize = *(((size_t *)*ptr) - 1) - sizeof(size_t); assert(oldsize>0); if ( oldsize>=size ) return; size += sizeof(size_t); assert(oldsize<size); ptrtmp = malloc(size); if ( !ptrtmp ) { *ptr = NULL; return; } *(size_t *)ptrtmp = size; if ( sp ) sp->memalloced += ms - memsize(oldsize); ptrtmp = ((size_t *)ptrtmp) + 1; memcpy(ptrtmp, *ptr, oldsize); ptrsave = *ptr; *ptr = ptrtmp; free((void *)(((size_t *) ptrsave) - 1)); }
// ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- void Texture::change(int width,int height,int bpp) { //supported only these formats if (!(bpp==24 || bpp==32 || bpp==8)) Utils::Error(HERE,"Texture::Texture(int width,int height,int bpp,unsigned char* buffer) bpp=%d is not supported",(int)bpp); this->gpu.reset(); int oldsize=this->memsize(); this->bpp = bpp; this->width = width; this->height= height; int imgsize=memsize(); this->buffer=(unsigned char*)MemPool::getSingleton()->realloc(oldsize,this->buffer,imgsize); memset(this->buffer,0,imgsize); }
// ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- void Texture::change(int width,int height,int bpp,const std::vector<unsigned char>& buffer) { if (buffer.size()!=width*height*(bpp/8)) Utils::Error(HERE,"void Texture::change(int width,int height,int bpp,const std::vector<unsigned char>& buffer) invalid argument buffer, buffer.size()=%d but it's size must be %d",(int)buffer.size(),(int)width*height*(bpp/8)); //supported only these formats if (!(bpp==24 || bpp==32 || bpp==8)) Utils::Error(HERE,"Texture::Texture(int width,int height,int bpp,unsigned char* buffer) bpp=%d is not supported",(int)bpp); this->gpu.reset(); int oldsize=this->memsize(); this->bpp = bpp; this->width = width; this->height= height; int imgsize=memsize(); this->buffer=(unsigned char*)MemPool::getSingleton()->realloc(oldsize,this->buffer,imgsize); memcpy(this->buffer,&buffer[0],imgsize); }
static void meminfo(void) { uint64_t size; struct sys_info *si; int t[3] = { MR_ATTR_DRAM, MR_ATTR_FLASH, MR_ATTR_SRAM }; int i; if ((si = ub_get_sys_info()) == NULL) panic("could not retrieve system info"); for (i = 0; i < 3; i++) { size = memsize(si, t[i]); if (size > 0) printf("%s: %lldMB\n", ub_mem_type(t[i]), size / 1024 / 1024); } }
//------------------------------------------------------------------------ //------------------------------------------------------------------------ Texture::Texture(int width,int height,int bpp) { //supported only these formats if (!(bpp==24 || bpp==32 || bpp==8)) { Utils::Error(HERE,"Texture::Texture(int width,int height,int bpp) bpp=%d is not supported",(int)bpp); } this->filename=""; this->width=width; this->height=height; this->bpp=bpp; this->buffer=0; int imgsize=memsize(); this->buffer=(unsigned char*)MemPool::getSingleton()->malloc(imgsize); memset(this->buffer,0,imgsize); }
void bitmap::set(size_t offset, bool bit) { unsigned bs = memsize(); size_t pos = offset / bs; unsigned rem = offset % bs; uint64_t b64; uint32_t b32; uint16_t b16; uint8_t b8; if(offset >= size) return; switch(bus) { case B64: b64 = ((uint64_t)(1))<<rem; if(bit) addr.d[pos] |= b64; else addr.d[pos] &= ~b64; break; case B32: b32 = 1<<rem; if(bit) addr.l[pos] |= b32; else addr.l[pos] &= ~b32; break; case B16: b16 = 1<<rem; if(bit) addr.w[pos] |= b16; else addr.w[pos] &= ~b16; break; default: b8 = 1<<rem; if(bit) addr.b[pos] |= b8; else addr.b[pos] &= ~b8; break; } }
/* * init the devices * wipe some of the file systems, or all if ream is set * this code really assumes that only one file system exists */ int fsinit(int ream, int newbufsize) { Filsys *fs; RBUFSIZE = 4 * 1024; for(fs=filesys; fs->name; fs++) (*devcall[fs->dev.type].init)(fs->dev); if(newbufsize == 0) newbufsize = RBUFSIZE; if(conf.niobuf == 0) { conf.niobuf = memsize()/10; if(conf.niobuf > 2*1024*1024) conf.niobuf = 2*1024*1024; conf.niobuf /= newbufsize; if(conf.niobuf < 30) conf.niobuf = 30; } BUFSIZE = RBUFSIZE - sizeof(Tag); for(fs=filesys; fs->name; fs++) if(ream || (*devcall[fs->dev.type].check)(fs->dev) && askream(fs)){ RBUFSIZE = newbufsize; BUFSIZE = RBUFSIZE - sizeof(Tag); (*devcall[fs->dev.type].ream)(fs->dev); fs->flags |= FREAM; ream = 1; } /* * set up the block size dependant variables */ BUFSIZE = RBUFSIZE - sizeof(Tag); DIRPERBUF = BUFSIZE / sizeof(Dentry); INDPERBUF = BUFSIZE / sizeof(int32_t); INDPERBUF2 = INDPERBUF * INDPERBUF; FEPERBUF = (BUFSIZE - sizeof(Super1) - sizeof(int32_t)) / sizeof(int32_t); return ream; }
bool bitmap::get(size_t offset) const { unsigned bs = memsize(); size_t pos = offset / bs; unsigned rem = offset % bs; if(offset >= size) return false; switch(bus) { #if !defined(_MSC_VER) || _MSC_VER >= 1400 case B64: return (addr.d[pos] & 1ll<<rem) > 0; #endif case B32: return (addr.l[pos] & 1l<<rem) > 0; case B16: return (addr.w[pos] & 1<<rem) > 0; default: return (addr.b[pos] & 1<<rem) > 0; } }
//------------------------------------------------------------------------ //------------------------------------------------------------------------ Texture::Texture(int width,int height,int bpp,const std::vector<unsigned char>& buffer) { if (buffer.size()!=width*height*(bpp/8)) { Utils::Error(HERE,"Texture::Texture(int width,int height,int bpp,const std::vector<unsigned char>& buffer) invalid argument buffer, buffer.size()=%d but it's size must be %d",(int)buffer.size(),(int)width*height*(bpp/8)); } if (!(bpp==24 || bpp==32 || bpp==8)) { Utils::Error(HERE,"Texture::Texture(int width,int height,int bpp,const std::vector<unsigned char>& buffer) bpp=%d is not supported",(int)bpp); } this->filename=""; this->width=width; this->height=height; this->bpp=bpp; int imgsize=memsize(); this->buffer=(unsigned char*)MemPool::getSingleton()->malloc(imgsize); memcpy(this->buffer,&buffer[0],imgsize); }
void ski_main(void) { static char malloc[512*1024]; int i; /* * initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ setheap((void *)malloc, (void *)(malloc + 512*1024)); /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * Initialise the block cache XXX: Fixme: do we need the bcache ? */ /* bcache_init(32, 512); */ /* 16k XXX tune this */ /* Initialise skifs.c */ skifs_dev_init(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); #if 0 printf("Memory: %ld k\n", memsize() / 1024); #endif /* XXX presumes that biosdisk is first in devsw */ currdev.d_dev = &devsw[0]; currdev.d_type = DEVT_DISK; currdev.d_kind.skidisk.unit = 0; /* XXX should be able to detect this, default to autoprobe */ currdev.d_kind.skidisk.slice = -1; /* default to 'a' */ currdev.d_kind.skidisk.partition = 0; #if 0 /* Create arc-specific variables */ bootfile = GetEnvironmentVariable(ARCENV_BOOTFILE); if (bootfile) setenv("bootfile", bootfile, 1); #endif env_setenv("currdev", EV_VOLATILE, ski_fmtdev(&currdev), (ev_sethook_t *) ski_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, ski_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = ski_autoload; archsw.arch_getdev = ski_getdev; archsw.arch_copyin = ski_copyin; archsw.arch_copyout = ski_copyout; archsw.arch_readin = ski_readin; interact(); /* doesn't return */ exit(0); }
void loader_main(struct loader_callbacks *cb, void *arg, int version, int ndisks) { static char mallocbuf[MALLOCSZ]; const char *var; int i; if (version < USERBOOT_VERSION) abort(); callbacks = cb; callbacks_arg = arg; userboot_disk_maxunit = ndisks; /* * initialise the heap as early as possible. Once this is done, * alloc() is usable. */ setheap((void *)mallocbuf, (void *)(mallocbuf + sizeof(mallocbuf))); /* * Hook up the console */ cons_probe(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); #if 0 printf("Memory: %ld k\n", memsize() / 1024); #endif setenv("LINES", "24", 1); /* optional */ /* * Set custom environment variables */ i = 0; while (1) { var = CALLBACK(getenv, i++); if (var == NULL) break; putenv(var); } archsw.arch_autoload = userboot_autoload; archsw.arch_getdev = userboot_getdev; archsw.arch_copyin = userboot_copyin; archsw.arch_copyout = userboot_copyout; archsw.arch_readin = userboot_readin; #if defined(USERBOOT_ZFS_SUPPORT) archsw.arch_zfs_probe = userboot_zfs_probe; #endif /* * Initialise the block cache. Set the upper limit. */ bcache_init(32768, 512); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); extract_currdev(); if (setjmp(jb)) return; interact(NULL); /* doesn't return */ exit(0); }
int main(int (*openfirm)(void *)) { phandle_t root; int i; char bootpath[64]; char *ch; int bargc; char **bargv; /* * Initialize the Open Firmware routines by giving them the entry point. */ OF_init(openfirm); root = OF_finddevice("/"); scells = acells = 1; OF_getprop(root, "#address-cells", &acells, sizeof(acells)); OF_getprop(root, "#size-cells", &scells, sizeof(scells)); /* * Initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ init_heap(); /* * Set up console. */ cons_probe(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); printf("Memory: %lldKB\n", memsize() / 1024); OF_getprop(chosen, "bootpath", bootpath, 64); ch = strchr(bootpath, ':'); *ch = '\0'; printf("Booted from: %s\n", bootpath); printf("\n"); /* * Only parse the first bootarg if present. It should * be simple to handle extra arguments */ OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs)); bargc = 0; parse(&bargc, &bargv, bootargs); if (bargc == 1) env_setenv("currdev", EV_VOLATILE, bargv[0], ofw_setcurrdev, env_nounset); else env_setenv("currdev", EV_VOLATILE, bootpath, ofw_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, bootpath, env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_getdev = ofw_getdev; archsw.arch_copyin = ofw_copyin; archsw.arch_copyout = ofw_copyout; archsw.arch_readin = ofw_readin; archsw.arch_autoload = ofw_autoload; interact(NULL); /* doesn't return */ OF_exit(); return 0; }
void get_memsizes(void) { /* Ensure we don't stomp bios data structutres. * the interrupt table: 0x000 - 0x3ff * the bios data area: 0x400 - 0x502 * Dos variables: 0x502 - 0x5ff */ static const unsigned min_addr = 0x600; unsigned i; unsigned basemem; basemem = get_free_base_memory(); meminfo.basememsize = basememsize(); meminfo.memsize = memsize(); #ifndef IGNORE_E820_MAP meminfo.map_count = meme820(meminfo.map, E820MAX); #else meminfo.map_count = 0; #endif if (meminfo.map_count == 0) { /* If we don't have an e820 memory map fake it */ meminfo.map_count = 2; meminfo.map[0].addr = 0; meminfo.map[0].size = meminfo.basememsize << 10; meminfo.map[0].type = E820_RAM; meminfo.map[1].addr = 1024*1024; meminfo.map[1].size = meminfo.memsize << 10; meminfo.map[1].type = E820_RAM; } /* Scrub the e820 map */ for(i = 0; i < meminfo.map_count; i++) { if (meminfo.map[i].type != E820_RAM) { continue; } /* Reserve the bios data structures */ if (meminfo.map[i].addr < min_addr) { unsigned long delta; delta = min_addr - meminfo.map[i].addr; if (delta > meminfo.map[i].size) { delta = meminfo.map[i].size; } meminfo.map[i].addr = min_addr; meminfo.map[i].size -= delta; } /* Ensure the returned e820 map is in sync * with the actual memory state */ if ((meminfo.map[i].addr < 0xa0000) && ((meminfo.map[i].addr + meminfo.map[i].size) > basemem)) { if (meminfo.map[i].addr <= basemem) { meminfo.map[i].size = basemem - meminfo.map[i].addr; } else { meminfo.map[i].addr = basemem; meminfo.map[i].size = 0; } } } #if MEMSIZES_DEBUG { int i; printf("basememsize %d\n", meminfo.basememsize); printf("memsize %d\n", meminfo.memsize); printf("Memory regions(%d):\n", meminfo.map_count); for(i = 0; i < meminfo.map_count; i++) { unsigned long long r_start, r_end; r_start = meminfo.map[i].addr; r_end = r_start + meminfo.map[i].size; printf("[%X%X, %X%X) type %d\n", (unsigned long)(r_start >> 32), (unsigned long)r_start, (unsigned long)(r_end >> 32), (unsigned long)r_end, meminfo.map[i].type); #if defined(CONSOLE_FIRMWARE) sleep(1); /* No way to see 32 entries on a standard 80x25 screen... */ #endif } } #endif }
void boot(int drive) { int addr; int top; int kern_entry; int boot_start; int boot_region_desc; int boot_thread_state; unsigned int size; int env_start; int env_size = 0; char *p; char *env = 0; char *defaults = 0; int defaults_size = 0; int i; int idt[2]; delayprompt = 10; /* default to 10s at the prompt */ switch(drive) { case BIOS_DEV_FLOPPY: dev = DEV_FLOPPY; break; case BIOS_FAKE_WD: dev = DEV_WD; break; case BIOS_DEV_WIN: default: dev = DEV_HD; break; } cnvmem = memsize(0); extmem = memsize(1); printf("\n>> Secondary Mach boot %s\n>> %d/%dk (? for help, ^C for intr)\n", VERSIONDATE, cnvmem, extmem); #ifdef DEBUG printf("end x%x data 0x%x\n",end,edata); #endif /* sanity check: */ if ((int)end > KALLOC_OFFSET || (int)end > (BOOTSTACK-0x300)) { printf("Size problem: 0x%x > 0x%x\n",end, ((int)end > KALLOC_OFFSET)?KALLOC_OFFSET:BOOTSTACK-0x300); } #if DEBUG if (debug) { printf("dev = %x\n", dev); printf("unit = %x\n", unit); printf("part = %x\n", part); } #endif #if 0 dev = DEV_HD; unit = 0; part = 0; #endif reset_pic(); /* Lilo breaks PIC, BIOS disk ints fail */ calibrate_delay(); /* adjust delay for i/o operation */ gateA20(); if (dev == DEV_FLOPPY && devfs()) { printf("No fd FS, using hd\n"); dev = DEV_HD; part = 0; } bcopy(MACH_KERNEL, kern_prog.name, sizeof(MACH_KERNEL)); bcopy(BOOTSTRAP, boot_prog.name, sizeof(BOOTSTRAP)); bcopy(MACH_BOOT_ENV, env_prog.name, sizeof(MACH_BOOT_ENV)); reload_env_file: if (openrd(env_prog.name, NULL) == 0 && fsize() != 0) { const char *value; /* * Read mach_boot environment file if exists */ printf("Reading defaults from %s:\n",env_prog.name); defaults_size = fsize()+1; if (defaults != (char *)0) free(defaults); defaults = (char *)malloc(defaults_size); read(defaults, defaults_size-1); *(defaults+defaults_size-1) = 0; printf("%s", defaults); for (p = defaults; p < defaults + defaults_size; p++) if (*p == '\n') *p = '\0'; value = get_env("CONSOLE", defaults, defaults_size); if (strcmp(value, "vga") == 0 || strcmp(value, "VGA") == 0) com_enabled = 0; /* WARNING: do not enable the remote console based * on the latter argument in an environment file, since * now, remote console enabling is decided by the primary * boot ONLY and passed along through secondary's. */ if (*get_env("PROMPT", defaults, defaults_size) == '1') prompt = 1; if (com_enabled && (value = get_env("COM1_SETUP", defaults, defaults_size))) com_setup(value); if (value = get_env("DELAYPROMPT", defaults, defaults_size)) { delayprompt = atoi(value); /* don't allow stupid values */ if (delayprompt < 3) delayprompt = 3; } } for (;;) { if ((!getbootline(kern_prog.name, boot_prog.name)) && defaults ) { /* * Get defaults from /mach_boot.env if any. */ const char *value; if (value = get_env("KERNEL_NAME", defaults, defaults_size)) { strcpy(kern_prog.name, (char *)value); strcpy(kern_prog.args, (char *)value); kern_prog.args_size = strlen(value)+1; } if (value = get_env("KERNEL_ARGS", defaults, defaults_size)) { char *args; args = kern_prog.args + kern_prog.args_size; while (*value) value = copyargs((char *)value, &args); kern_prog.args_size = args - kern_prog.args; } if (value = get_env("BOOTSTRAP_NAME", defaults, defaults_size)) { strcpy(boot_prog.name, (char *)value); strcpy(boot_prog.args, (char *)value); boot_prog.args_size = strlen(value)+1; } if (value = get_env("BOOTSTRAP_ARGS", defaults, defaults_size)) { char *args; args = boot_prog.args + boot_prog.args_size; while (*value) value = copyargs((char *)value, &args); boot_prog.args_size = args - boot_prog.args; } } if (cons_is_com) { printf("console is COM1\n"); /* check if we already enabled remote console? */ p = kern_prog.args + kern_prog.args_size; *p++ = '-'; *p++ = 'r'; *p++ = 0; kern_prog.args_size += 3; } addr = KERNEL_BOOT_ADDR; if (loadtext(&addr, &kern_prog)) { strcpy(env_prog.name, kern_prog.name); goto reload_env_file; } else if (loadprog(&addr, &kern_prog)) { printf("Can't load %s\n", kern_prog.name); usage(); continue; } kern_entry = entry; if (dev == DEV_WD) net_get_root_device(); env_start = addr; if (openrd("/mach_servers/environment", NULL) == 0 && fsize() != 0) { unsigned int total = fsize()+1; printf("Loading environment from /mach_servers/environment\n"); env = (char *)malloc(total); read(env, total-1); *(env+total-1) = 0; for (p = env; p < env + total; p++) if (*p == '\n') *p = '\0'; pcpy(env, (void *)addr, total); addr += total; env_size += total; free(env); } env = (char *)malloc(BOOT_LINE_LENGTH); #if BOOT_ENV_COMPAT /* should go away when all kernels are converted to use BOOT_DEVICE */ p = env; strcpy(p, "BOOTOFFSET="); p = itoa(p + strlen(p), boff) + 1; strcpy(p, "BOOTDEV=hd"); p += strlen(p)+1; *(p-3) = dev; strcpy(p, "BOOTUNIT="); p = itoa(p + strlen(p), unit) + 1; strcpy(p, "BOOTPART="); p = itoa(p + strlen(p), part) + 1; size = p - env; pcpy(env, (void *)addr, size); addr += size; env_size += size; #endif /* BOOT_ENV_COMPAT */ p = env; strcpy(p, "BOOT_DEVICE=hd"); p += strlen(p); *(p-2) = dev; p = itoa(p, unit); *p++ = 'a'+part; size = p - env; pcpy(env, (void *)addr, size); addr += size; env_size += size; free(env); if (strncmp("none",boot_prog.name,sizeof("none"))==0 ||strncmp("null",boot_prog.name,sizeof("null"))==0) { boot_start = 0; boot_region_desc = 0; boot_prog.sym_start = 0; boot_prog.sym_size = 0; boot_prog.args_start = 0; boot_prog.args_size = 0; region_count = 0; boot_thread_state = 0; top = page_align(addr); goto boot_kernel_only; } boot_start = addr = page_align(addr); if (loadprog(&addr, &boot_prog)) { printf("Can't load %s\n", boot_prog.name); usage(); continue; } boot_region_desc = addr; addr = boot_region_desc + (region_count * sizeof(regions[0])); pcpy(regions, (void *) boot_region_desc, addr - boot_region_desc); boot_thread_state = addr; addr += sizeof(thread_state); pcpy(&thread_state, (void *) boot_thread_state, addr - boot_thread_state); top = page_align(addr); boot_kernel_only: #ifdef DEBUG if (debug) { printf("startprog(\n"); printf(" entry 0x%x,\n", kern_entry); printf(" -1,\n"); printf(" extmem 0x%x,\n", extmem); printf(" cnvmem 0x%x,\n", cnvmem); printf(" kern_sym_start 0x%x,\n", kern_prog.sym_start); printf(" kern_sym_size 0x%x,\n", kern_prog.sym_size); printf(" kern_args_start 0x%x,\n", kern_prog.args_start); printf(" kern_args_size 0x%x,\n", kern_prog.args_size); for (p = kern_prog.args; p < &kern_prog.args[kern_prog.args_size]; p += strlen(p)+1) printf("<%s>", p); printf("\n"); printf(" boot_sym_start 0x%x,\n", boot_prog.sym_start); printf(" boot_sym_size 0x%x,\n", boot_prog.sym_size); printf(" boot_args_start 0x%x,\n", boot_prog.args_start); printf(" boot_args_size 0x%x,\n", boot_prog.args_size); for (p = boot_prog.args; p < &boot_prog.args[boot_prog.args_size]; p += strlen(p)+1) printf("<%s>", p); printf("\n"); printf(" boot_start 0x%x,\n", boot_start); printf(" boot_size 0x%x,\n", boot_prog.sym_start - boot_start); printf(" boot_region_desc 0x%x,\n", boot_region_desc); printf(" boot_region_count 0x%x,\n", region_count); printf(" boot_thread_state_flavor %d,\n", THREAD_SYSCALL_STATE); printf(" boot_thread_state 0x%x (eip 0x%x, esp 0x%x),\n", boot_thread_state, thread_state.eip, thread_state.esp); printf(" boot_thread_state_count %d,\n", (int) i386_THREAD_SYSCALL_STATE_COUNT); printf(" env_start 0x%x,\n", env_start); printf(" env_size 0x%x,\n", env_size); printf(" top 0x%x)\n", (int) top); getchar(); continue; } #endif /* DEBUG */ /* * New calling convention * * %esp -> -1 * size of extended memory (K) * size of conventional memory (K) * kern_sym_start * kern_sym_size * kern_args_start * kern_args_size * boot_sym_start * boot_sym_size * boot_args_start * boot_args_size * boot_start * boot_size * boot_region_desc * boot_region_count * boot_thread_state_flavor * boot_thread_state * boot_thread_state_count * env_start * env_size * top of loaded memory */ startprog( kern_entry, -1, extmem, cnvmem, kern_prog.sym_start, kern_prog.sym_size, kern_prog.args_start, kern_prog.args_size, boot_prog.sym_start, boot_prog.sym_size, boot_prog.args_start, boot_prog.args_size, boot_start, boot_prog.sym_start - boot_start, boot_region_desc, region_count, THREAD_SYSCALL_STATE, boot_thread_state, i386_THREAD_SYSCALL_STATE_COUNT, env_start, env_size, top); } }
void free_hook (stable_t *sp, void *ptr) { if ( sp ) sp->memalloced -= memsize(* (((size_t *) ptr) - 1)); ptr = (void *) (((size_t *) ptr) - 1); free(ptr); }
void ski_main(void) { static char malloc[512*1024]; int i; /* * initialise the heap as early as possible. Once this is done, * alloc() is usable. The stack is buried inside us, so this is * safe. */ setheap((void *)malloc, (void *)(malloc + 512*1024)); /* * XXX Chicken-and-egg problem; we want to have console output * early, but some console attributes may depend on reading from * eg. the boot device, which we can't do yet. We can use * printf() etc. once this is done. */ cons_probe(); /* * March through the device switch probing for things. */ for (i = 0; devsw[i] != NULL; i++) if (devsw[i]->dv_init != NULL) (devsw[i]->dv_init)(); printf("\n"); printf("%s, Revision %s\n", bootprog_name, bootprog_rev); printf("(%s, %s)\n", bootprog_maker, bootprog_date); #if 0 printf("Memory: %ld k\n", memsize() / 1024); #endif /* XXX presumes that biosdisk is first in devsw */ currdev.d_dev = devsw[0]; currdev.d_type = currdev.d_dev->dv_type; currdev.d_unit = 0; #if 0 /* Create arc-specific variables */ bootfile = GetEnvironmentVariable(ARCENV_BOOTFILE); if (bootfile) setenv("bootfile", bootfile, 1); #endif env_setenv("currdev", EV_VOLATILE, ia64_fmtdev(&currdev), ia64_setcurrdev, env_nounset); env_setenv("loaddev", EV_VOLATILE, ia64_fmtdev(&currdev), env_noset, env_nounset); setenv("LINES", "24", 1); /* optional */ archsw.arch_autoload = ia64_autoload; archsw.arch_copyin = ia64_copyin; archsw.arch_copyout = ia64_copyout; archsw.arch_getdev = ia64_getdev; archsw.arch_loadaddr = ia64_loadaddr; archsw.arch_loadseg = ia64_loadseg; archsw.arch_readin = ia64_readin; interact(); /* doesn't return */ exit(0); }
int main(void) { char cmd[512], cmdtmp[512]; int autoboot, dskupdated; ufs_ino_t ino; dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base); v86.ctl = V86_FLAGS; v86.efl = PSL_RESERVED_DEFAULT | PSL_I; dsk.drive = *(uint8_t *)PTOV(ARGS); dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; dsk.unit = dsk.drive & DRV_MASK; dsk.part = -1; dsk.start = 0; bootinfo.bi_version = BOOTINFO_VERSION; bootinfo.bi_size = sizeof(bootinfo); bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */ bootinfo.bi_extmem = memsize(); bootinfo.bi_memsizes_valid++; /* Process configuration file */ if (gptinit() != 0) return (-1); autoboot = 1; *cmd = '\0'; for (;;) { *kname = '\0'; if ((ino = lookup(PATH_CONFIG)) || (ino = lookup(PATH_DOTCONFIG))) fsread(ino, cmd, sizeof(cmd)); if (*cmd != '\0') { memcpy(cmdtmp, cmd, sizeof(cmdtmp)); if (parse(cmdtmp, &dskupdated)) break; if (dskupdated && gptinit() != 0) break; if (!OPT_CHECK(RBX_QUIET)) printf("%s: %s", PATH_CONFIG, cmd); *cmd = '\0'; } if (autoboot && keyhit(3)) { if (*kname == '\0') memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3)); break; } autoboot = 0; /* * Try to exec stage 3 boot loader. If interrupted by a * keypress, or in case of failure, try to load a kernel * directly instead. */ if (*kname != '\0') load(); memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3)); load(); memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL)); load(); gptbootfailed(&dsk); if (gptfind(&freebsd_ufs_uuid, &dsk, -1) == -1) break; dsk_meta = 0; } /* Present the user with the boot2 prompt. */ for (;;) { if (!OPT_CHECK(RBX_QUIET)) { printf("\nFreeBSD/x86 boot\n" "Default: %u:%s(%up%u)%s\n" "boot: ", dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit, dsk.part, kname); } if (ioctrl & IO_SERIAL) sio_flush(); *cmd = '\0'; if (keyhit(0)) getstr(cmd, sizeof(cmd)); else if (!OPT_CHECK(RBX_QUIET)) putchar('\n'); if (parse(cmd, &dskupdated)) { putchar('\a'); continue; } if (dskupdated && gptinit() != 0) continue; load(); } /* NOTREACHED */ }
int main(int argc, char* argv[]) { if (argc != 2) { fprintf(stderr, "[-] Error: usage: %s config_file\n", argv[0]); return EXIT_FAILURE; } char* filename = argv[1]; FILE* fp = fopen(filename, "r"); if (!fp) { fprintf(stderr, "[-] Error: failed to open file %s\n", filename); return EXIT_FAILURE; } /* File buffer */ char* buffer; int nbytes = 128; buffer = (char*)malloc(2048*sizeof(char)); /* Parsing vars */ int m_size; int p_id; int p_size; int r_page; int r_id; int w_page; int w_id; int e_id; init_process_table(); /* Main loop */ while ((getline(&buffer, (size_t*)&nbytes, fp) != -1)) { /* Todas as operações começam com letras diferentes */ switch(buffer[0]) { case 'M': /* MEMSIZE SIZE */ case 'm': parse_memsize(buffer, &m_size); printf("[+] MEMSIZE %d\n", m_size); memsize(m_size); break; case 'P': /* PROCSIZE ID SIZE */ case 'p': parse_procsize(buffer, &p_id, &p_size); printf("[+] PROCSIZE %d %d\n", p_id, p_size); procsize(p_id, p_size); break; case 'R': /* READ PAGE ID */ case 'r': parse_read(buffer, &r_page, &r_id); printf("[+] READ %d %d\n", r_page, r_id); read_p(r_page, r_id); break; case 'W': /* WRITE PAGE ID */ case 'w': parse_write(buffer, &w_page, &w_id); printf("[+] WRITE %d %d\n", w_page, w_id); write_p(w_page, w_id); break; case 'E': /* ENDPROC ID */ case 'e': parse_endproc(buffer, &e_id); printf("[+] ENDPROC %d\n", e_id); endproc(e_id); break; default: printf("[-] Invalid Operation!\n"); } } /* Write stats here */ write_stats(); fclose(fp); return EXIT_SUCCESS; }
int main(void) { int autoboot; ino_t ino; dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base); v86.ctl = V86_FLAGS; dsk.drive = *(uint8_t *)PTOV(ARGS); dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD; dsk.unit = dsk.drive & DRV_MASK; dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1; bootinfo.bi_version = BOOTINFO_VERSION; bootinfo.bi_size = sizeof(bootinfo); bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */ bootinfo.bi_extmem = memsize(); bootinfo.bi_memsizes_valid++; /* Process configuration file */ autoboot = 1; if ((ino = lookup(PATH_CONFIG))) fsread(ino, cmd, sizeof(cmd)); if (*cmd) { printf("%s: %s", PATH_CONFIG, cmd); if (parse()) autoboot = 0; /* Do not process this command twice */ *cmd = 0; } /* * Try to exec stage 3 boot loader. If interrupted by a keypress, * or in case of failure, try to load a kernel directly instead. */ if (autoboot && !*kname) { memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3)); if (!keyhit(3*SECOND)) { load(); memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL)); } } /* Present the user with the boot2 prompt. */ for (;;) { printf("\nFreeBSD/i386 boot\n" "Default: %u:%s(%u,%c)%s\n" "boot: ", dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit, 'a' + dsk.part, kname); if (ioctrl & IO_SERIAL) sio_flush(); if (!autoboot || keyhit(5*SECOND)) getstr(); else putchar('\n'); autoboot = 0; if (parse()) putchar('\a'); else load(); } }
int main(int ac, char **av) { int c, i, nnodes=0; long node=-1; char *end; char shortopts[array_len(opts)*2 + 1]; struct bitmask *mask = NULL; get_short_opts(opts,shortopts); while ((c = getopt_long(ac, av, shortopts, opts, NULL)) != -1) { switch (c) { case 's': /* --show */ show(); exit(0); case 'H': /* --hardware */ nopolicy(); hardware(); exit(0); case 'i': /* --interleave */ checknuma(); mask = numactl_parse_nodestring(optarg); if (!mask) { printf ("<%s> is invalid\n", optarg); usage(); } errno = 0; setpolicy(MPOL_INTERLEAVE); if (shmfd >= 0) numa_interleave_memory(shmptr, shmlen, mask); else numa_set_interleave_mask(mask); checkerror("setting interleave mask"); break; case 'N': /* --cpunodebind */ case 'c': /* --cpubind */ dontshm("-c/--cpubind/--cpunodebind"); checknuma(); mask = numactl_parse_nodestring(optarg); if (!mask) { printf ("<%s> is invalid\n", optarg); usage(); } errno = 0; check_cpubind(do_shm); did_cpubind = 1; numa_run_on_node_mask(mask); checkerror("sched_setaffinity"); break; case 'C': /* --physcpubind */ { struct bitmask *cpubuf; dontshm("-C/--physcpubind"); cpubuf = numa_parse_cpustring(optarg); if (!cpubuf) { printf ("<%s> is invalid\n", optarg); usage(); } errno = 0; check_cpubind(do_shm); did_cpubind = 1; numa_sched_setaffinity(0, cpubuf); checkerror("sched_setaffinity"); free(cpubuf); break; } case 'm': /* --membind */ checknuma(); setpolicy(MPOL_BIND); mask = numactl_parse_nodestring(optarg); if (!mask) { printf ("<%s> is invalid\n", optarg); usage(); } errno = 0; numa_set_bind_policy(1); if (shmfd >= 0) { numa_tonodemask_memory(shmptr, shmlen, mask); } else { numa_set_membind(mask); } numa_set_bind_policy(0); checkerror("setting membind"); break; case 'p': /* --preferred */ checknuma(); setpolicy(MPOL_PREFERRED); mask = numactl_parse_nodestring(optarg); if (!mask) { printf ("<%s> is invalid\n", optarg); usage(); } for (i=0; i<mask->size; i++) { if (numa_bitmask_isbitset(mask, i)) { node = i; nnodes++; } } if (nnodes != 1) usage(); numa_bitmask_free(mask); errno = 0; numa_set_bind_policy(0); if (shmfd >= 0) numa_tonode_memory(shmptr, shmlen, node); else numa_set_preferred(node); checkerror("setting preferred node"); break; case 'l': /* --local */ checknuma(); setpolicy(MPOL_DEFAULT); errno = 0; if (shmfd >= 0) numa_setlocal_memory(shmptr, shmlen); else numa_set_localalloc(); checkerror("local allocation"); break; case 'S': /* --shm */ check_cpubind(did_cpubind); nopolicy(); attach_sysvshm(optarg, "--shm"); shmattached = 1; break; case 'f': /* --file */ check_cpubind(did_cpubind); nopolicy(); attach_shared(optarg, "--file"); shmattached = 1; break; case 'L': /* --length */ noshm("--length"); shmlen = memsize(optarg); break; case 'M': /* --shmmode */ noshm("--shmmode"); shmmode = strtoul(optarg, &end, 8); if (end == optarg || *end) usage(); break; case 'd': /* --dump */ if (shmfd < 0) complain( "Cannot do --dump without shared memory.\n"); dump_shm(); do_dump = 1; break; case 'D': /* --dump-nodes */ if (shmfd < 0) complain( "Cannot do --dump-nodes without shared memory.\n"); dump_shm_nodes(); do_dump = 1; break; case 't': /* --strict */ did_strict = 1; numa_set_strict(1); break; case 'I': /* --shmid */ shmid = strtoul(optarg, &end, 0); if (end == optarg || *end) usage(); break; case 'u': /* --huge */ noshm("--huge"); shmflags |= SHM_HUGETLB; break; case 'o': /* --offset */ noshm("--offset"); shmoffset = memsize(optarg); break; case 'T': /* --touch */ needshm("--touch"); check_shmbeyond("--touch"); numa_police_memory(shmptr, shmlen); break; case 'V': /* --verify */ needshm("--verify"); if (set_policy < 0) complain("Need a policy first to verify"); check_shmbeyond("--verify"); numa_police_memory(shmptr, shmlen); if (!mask) complain("Need a mask to verify"); else verify_shm(set_policy, mask); break; default: usage(); } } av += optind; ac -= optind; if (shmfd >= 0) { if (*av) usage(); exit(exitcode); } if (did_strict) fprintf(stderr, "numactl: warning. Strict flag for process ignored.\n"); if (do_dump) usage_msg("cannot do --dump|--dump-shm for process"); if (shmoption) usage_msg("shm related option %s for process", shmoption); if (*av == NULL) usage(); execvp(*av, av); complain("execution of `%s': %s\n", av[0], strerror(errno)); return 0; /* not reached */ }
int main (int argc, char** argv) { int ret, c; int i, repeat = 5; int cpu = 2; static int errortype = 1; static int verbose = 1; static int disableHuge = 0; static int madvisePoison = 0; static int poll_exit=0; static long length; struct bitmask *nodes, *gnodes; int gpolicy; unsigned long error_opt; void *vaddrmin = (void *)-1UL, *vaddrmax = NULL; static size_t pdcount=0; unsigned long mattr, addrend, pages, count, nodeid, paddr = 0; unsigned long addr_start=0, nodeid_start=-1, mattr_start=-1; unsigned int pagesize = getpagesize(); char pte_str[20]; struct dlook_get_map_info req; static page_desc_t *pdbegin=NULL; page_desc_t *pd, *pdend; length = memsize("100k"); nodes = numa_allocate_nodemask(); gnodes = numa_allocate_nodemask(); progname = argv[0]; while (1) { static struct option long_options[] = { {"verbose", no_argument, &verbose, 1}, {"delay", no_argument, &delay, 1}, {"disableHuge", no_argument, &disableHuge, 1}, {"poll", no_argument, &poll_exit, 1}, {"madvisePoison", no_argument, &madvisePoison, 1}, {"manual", no_argument, &manual, 1}, {"cpu", required_argument, 0, 'c'}, {"errortype", required_argument, 0, 'e'}, {"help", no_argument, 0, 'h'}, {"length", required_argument, 0, 'l'} }; /* getopt_long stores the option index here. */ int option_index = 0; c = getopt_long (argc, argv, "hc:e:l:", long_options, &option_index); /* Detect the end of the options. */ if (c == -1) break; switch (c) { case 'c': cpu = atoi(optarg); break; case 'e': errortype = atoi(optarg); break; case 'h': help(); case 'l': /* Not exposed */ printf ("option -l with value `%s'\n", optarg); length = memsize("optarg"); break; case '?': /* getopt_long already printed an error message. */ exit(-1); } } cpu_process_setaffinity(getpid(), cpu); error_opt = get_etype(errortype); buf = mmap(NULL, length, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0); if (mbind((void *)buf, length, MPOL_DEFAULT, nodes->maskp, nodes->size, 0) < 0){ perror("mbind error\n"); } /* Disable Hugepages */ if (disableHuge) madvise((void *)buf, length, MADV_NOHUGEPAGE); if (madvisePoison) madvise((void *)buf, length,MADV_HWPOISON ); gpolicy = -1; if (get_mempolicy(&gpolicy, gnodes->maskp, gnodes->size, (void *)buf, MPOL_F_ADDR) < 0) perror("get_mempolicy"); if (!numa_bitmask_equal(gnodes, nodes)) { printf("nodes differ %lx, %lx!\n", gnodes->maskp[0], nodes->maskp[0]); } strcpy(pte_str, ""); addrend = ((unsigned long)buf)+length; pages = (addrend-((unsigned long)buf))/pagesize; if (pages > pdcount) { pdbegin = realloc(pdbegin, sizeof(page_desc_t)*pages); pdcount = pages; } req.pid = getpid(); req.start_vaddr = (unsigned long)buf; req.end_vaddr = addrend; req.pd = pdbegin; sigaction(SIGBUS, &recover_act, NULL); /*Fault in Pages */ if(!poll_exit) hog((void *)buf, length); /* Get mmap phys_addrs */ if ((fd = open(UVMCE_DEVICE, O_RDWR)) < 0) { printf("Failed to open: %s\n", UVMCE_DEVICE); exit (1); } if (ioctl(fd, UVMCE_DLOOK, &req ) < 0){ printf("Failed to INJECT_UCE\n"); exit(1); } process_map(pd,pdbegin, pdend, pages, buf, addrend, pagesize, mattr, nodeid, paddr, pte_str, nodeid_start, mattr_start, addr_start); printf("\n\tstart_vaddr\t 0x%016lx length\t 0x%x\n\tend_vaddr\t 0x%016lx pages\t %ld\n", buf , length, addrend, pages); uv_inject(pd,pdbegin, pdend, pages, (unsigned long)buf, addrend, pagesize, mattr, nodeid, paddr, pte_str, nodeid_start, mattr_start, addr_start, error_opt); if (delay){ printf("Enter char to consume bad memory.."); getchar(); } if (error_opt != UVMCE_PATROL_SCRUB_UCE){ consume_it((void *)buf, length); } out: close(fd); return 0; }