void player_msg(char *text, char *name) { buffer_t buffer; uint32 len = str_size(text); clear_buffer(&buffer); add_opcode(&buffer,CPLAYERMSG); add_string(&buffer, name); add_buffer(&buffer,&len, SIZE32); add_string(&buffer, text); send_data(&buffer); }
int send_one(char *msg, int fd, t_stck *s) { char *mode; char *tmp; mode = "\n"; if (s->fds[fd].tmode) mode = s->fds[fd].tmode; tmp = Xmalloc(strlen(msg) + strlen(mode) + 3); sprintf(tmp, "%s%s", msg, mode); add_buffer(&(s->fds[fd].cbuf_write), s, tmp, strlen(tmp)); free(tmp); return (0); }
int decrypt_packet(buffer_t* buffer, size_t size) { uint32 x = 0; char *decrypted = (char *)calloc(size, sizeof(char)); uint32 buffersize = size; for (x = 0; x < size; x++) decrypted[x] = (buffer->buff[x] ^ ENCRYPT_KEY[x]); clear_buffer(buffer); if(add_buffer(buffer, decrypted, buffersize)) return 1; buffer->offset = 0; return 0; }
void send_save_spell(uint16 spellnum) { buffer_t buffer; clear_buffer(&buffer); add_opcode(&buffer, CSAVESPELL); add_buffer(&buffer, &spellnum, SIZE16); add_string(&buffer,spell(spellnum)->name); add_buffer(&buffer, &spell(spellnum)->pic, SIZE16); add_buffer(&buffer, &spell(spellnum)->mpreq, SIZE16); add_buffer(&buffer, &spell(spellnum)->jobreq, SIZE8); add_buffer(&buffer, &spell(spellnum)->levelreq, SIZE8); add_buffer(&buffer, &spell(spellnum)->type, SIZE8); add_buffer(&buffer, &spell(spellnum)->data1, SIZE16); add_buffer(&buffer, &spell(spellnum)->data2, SIZE16); add_buffer(&buffer, &spell(spellnum)->data3, SIZE16); send_data(&buffer); }
void producer(void *dummy) { int i = 0; printf("I'm a producer\n"); for (i=0;i<10;i++){ MySemaphoreWait(produce_semaphore); add_buffer(i); //MyThreadExit(); MySemaphoreSignal(consume_semaphore); //i = i + 1; } MyThreadExit(); }
void send_save_npc(uint16 npcnum) { buffer_t buffer; clear_buffer(&buffer); add_opcode(&buffer, CSAVENPC); add_buffer(&buffer, &npcnum, SIZE16); add_string(&buffer,npc(npcnum)->name); add_string(&buffer,npc(npcnum)->say); add_buffer(&buffer, &npc(npcnum)->sprite, SIZE16); add_buffer(&buffer, &npc(npcnum)->behavior, SIZE16); add_buffer(&buffer, &npc(npcnum)->range, SIZE16); add_buffer(&buffer, &npc(npcnum)->dropitem, SIZE16); add_buffer(&buffer, &npc(npcnum)->dropchance, SIZE16); add_buffer(&buffer, &npc(npcnum)->dropitemvalue, SIZE16); add_buffer(&buffer, &npc(npcnum)->spawnsecs, SIZE16); add_buffer(&buffer, npc(npcnum)->stat, STAT_COUNT * sizeof(uint8)); send_data(&buffer); }
void add_file(char *name) { FILE *file; char *buffer; unsigned long fileLen; //Open file file = fopen(name, "rb"); if (!file) { fprintf(stderr, "Unable to open file %s\n", name); return 0; } //Get file length fseek(file, 0, SEEK_END); fileLen=ftell(file); fseek(file, 0, SEEK_SET); //Allocate memory buffer=(char *)malloc(fileLen+1); if (!buffer) { fprintf(stderr, "Memory error!"); fclose(file); return 0; } //Read file contents into buffer fread(buffer, fileLen, 1, file); fclose(file); printf("shuffle file size %lu \n", fileLen); int times = 0; unsigned long seed = nSeed; for (times = 0; times < timeslast; times++) { printf("shuffle file %lu \n", times); add_buffer(buffer, fileLen); nSeed = seed; nSeed2 = seed; } write_add_buffer(name, buffer, fileLen); // dump_buffer_hex(buffer, fileLen); free(buffer); }
/* * add_bufferf() builds a buffer from the formatted input */ static CURLcode add_bufferf(send_buffer *in, const char *fmt, ...) { CURLcode result = CURLE_OUT_OF_MEMORY; char *s; va_list ap; va_start(ap, fmt); s = vaprintf(fmt, ap); /* this allocs a new string to append */ va_end(ap); if(s) { result = add_buffer(in, s, strlen(s)); free(s); } return result; }
void recv_serv(t_main *c) { char buf[BUF_SIZE + 1]; int len; memset(buf, 0, BUF_SIZE + 1); if ((len = recv(c->sfd, buf, BUF_SIZE, 0)) <= 0) disconnect(c); if (!add_buffer(c, buf, len)) return ; c->start = 0; c->end = 0; str_clean(c->buf, strlen(c->buf)); aff_msg(c->m, str_clean(c->buf, strlen(c->buf))); memset(c->buf, 0, BUF_SIZE + 3); }
void edit_mail_send(USER_DATA *usr) { USER_DATA *to; FILE *fpMail; char buf[INPUT]; if (!usr->pCurrentMail) { send_to_user("ERROR: Null usr->pCurrentMail.\n\r", usr); bbs_bug("Edit_mail_send: Null usr->pCurrentMail"); return; } if ((to = get_user(usr->pCurrentMail->to)) != NULL) /* if user is online */ { LINK(usr->pCurrentMail, to->pMailFirst, to->pMailLast); save_mail(to); /* edit_mail_free(usr); BAXTER */ usr->pCurrentMail = NULL; if (isBusySelf(to)) add_buffer(to, "#WYou have new mail.#x\n\r"); else send_to_user("#WYou have new mail.#x\n\r", to); return; } sprintf(buf, "%s%s", MAIL_DIR, capitalize(usr->pCurrentMail->to)); fclose(fpReserve); if (!(fpMail = fopen(buf, "a"))) { print_to_user(usr, "ERROR: Could not open to write %s's mail file.\n\r", capitalize(usr->pCurrentMail->to)); bbs_bug("Save_mail: Could not open to write %s", buf); fpReserve = fopen(NULL_FILE, "r"); /* edit_mail_free(usr); BAXTER */ usr->pCurrentMail = NULL; return; } append_mail(usr->pCurrentMail, fpMail); fclose(fpMail); fpReserve = fopen(NULL_FILE, "r"); /* edit_mail_free(usr); */ usr->pCurrentMail = NULL; return; }
rtt::fbo* rtt::add_buffer(const unsigned int width, const unsigned int height, const GLenum target, const TEXTURE_FILTERING filtering, const TEXTURE_ANTI_ALIASING taa, const GLint wrap_s, const GLint wrap_t, const GLint internal_format, const GLenum format, const GLenum type, const unsigned int attachment_count, const rtt::DEPTH_TYPE depth_type, const rtt::STENCIL_TYPE stencil_type) { GLenum* targets = new GLenum[attachment_count]; TEXTURE_FILTERING* filterings = new TEXTURE_FILTERING[attachment_count]; TEXTURE_ANTI_ALIASING* taas = new TEXTURE_ANTI_ALIASING[attachment_count]; GLint* wraps_s = new GLint[attachment_count]; GLint* wraps_t = new GLint[attachment_count]; GLint* internal_formats = new GLint[attachment_count]; GLenum* formats = new GLenum[attachment_count]; GLenum* types = new GLenum[attachment_count]; for(unsigned int i = 0; i < attachment_count; i++) { targets[i] = target; filterings[i] = filtering; taas[i] = taa; wraps_s[i] = wrap_s; wraps_t[i] = wrap_t; internal_formats[i] = internal_format; formats[i] = format; types[i] = type; } rtt::fbo* ret_buffer = add_buffer(width, height, targets, filterings, taas, wraps_s, wraps_t, internal_formats, formats, types, attachment_count, depth_type, stencil_type); delete [] targets; delete [] filterings; delete [] taas; delete [] wraps_s; delete [] wraps_t; delete [] internal_formats; delete [] formats; delete [] types; return ret_buffer; }
int srb_http_mkmetadata(char *buff, int len, char *host, char *page) { char *bufp = buff; int mylen = len; int ret; *buff = 0; ret = add_buffer(&bufp, &mylen, "GET "); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, page); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, HTTP_METADATA " " HTTP_VER CRLF); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, HTTP_KEEPALIVE CRLF); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, HTTP_USER_AGENT CRLF); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, "Host: "); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, host); if (ret) return -ENOMEM; ret = add_buffer(&bufp, &mylen, CRLF CRLF); if (ret) return -ENOMEM; return (len - mylen); }
/* * Create a commit object in the repository using the current * index and the information from the provided rev_commit */ static int git_commit(rev_commit *commit) { cvs_author *author; char *full; char *email; char *log; unsigned char commit_sha1[20]; size_t size = 0; int encoding_is_utf8; if (!commit->sha1) return 0; log = git_log(commit); if (!log) return 0; author = git_fullname(commit->author); if (!author) { // fprintf (stderr, "%s: not in author map\n", commit->author); full = commit->author; email = commit->author; } else { full = author->full; email = author->email; } /* Not having i18n.commitencoding is the same as having utf-8 */ encoding_is_utf8 = is_encoding_utf8(git_commit_encoding); add_buffer(&size, "tree %s\n", commit->sha1); if (commit->parent) add_buffer(&size, "parent %s\n", commit->parent->sha1); add_buffer(&size, "author %s <%s> %lu +0000\n", full, email, commit->date); add_buffer(&size, "committer %s <%s> %lu +0000\n", full, email, commit->date); if (!encoding_is_utf8) add_buffer(&size, "encoding %s\n", git_commit_encoding); add_buffer(&size, "\n%s", log); if (write_sha1_file(commit_text, size, commit_type, commit_sha1)) return 0; commit->sha1 = atom(sha1_to_hex(commit_sha1)); if (!commit->sha1) return 0; return 1; }
void send_save_item(uint16 itemnum) { buffer_t buffer; clear_buffer(&buffer); add_opcode(&buffer, CSAVEITEM); add_buffer(&buffer, &itemnum, SIZE16); add_string(&buffer,item(itemnum)->name); add_buffer(&buffer, &item(itemnum)->type, SIZE8); add_buffer(&buffer, &item(itemnum)->pic, SIZE16); add_buffer(&buffer, &item(itemnum)->data1, SIZE16); add_buffer(&buffer, &item(itemnum)->data2, SIZE16); add_buffer(&buffer, &item(itemnum)->data3, SIZE16); send_data(&buffer); }
bool SocketInputStream2::gets(BaseString& str) { if (get_buffered_line(str)) return true; char buf[16]; do { ssize_t read_res = read_socket(buf, sizeof(buf)); if (read_res == -1) return false; if (!add_buffer(buf, read_res)) return false; if (get_buffered_line(str)) return true; } while(true); abort(); // Should never come here return false; };
void * block_allocator::allocate(size_t size_bytes){ int * P; ++alloc_count; if( !buffers.empty() && buffers.back().can_allocate(size_bytes)){//fits in the top buffer void * P = buffers.back().allocate((int)size_bytes); current_used += round_up(size_bytes); return P; }; if( spare.can_allocate(size_bytes)){//fits in the spare buffer buffers.push_back(spare); void * P = buffers.back().allocate((int)size_bytes); current_used += round_up(size_bytes); return P; }; if( size_bytes<buffer_size/16){//is small add_buffer(buffer_size); void * P = buffers.back().allocate((int)size_bytes); current_used += round_up(size_bytes); return P; }; // is large and does not fit in available buffers //use malloc for it (with 2 ints of overhead for signature and size) big_size cap = round_up(size_bytes); big_size size_allocate = cap+sizeof(int)+sizeof(size_t); if(size_allocate>(big_size)(std::numeric_limits<std::size_t>::max()/2)){ error_allocate(size_allocate); }; int * Q = (int*)malloc(size_t(size_allocate)); if(Q==0)error_allocate(size_allocate); took_mem(size_t(cap)); P = (int*)((char*)Q+sizeof(int)+sizeof(size_t)); *(P-1) = sign_malloc; *((size_t*)(P-1)-1) = cap; current_used += round_up(size_t(cap)); return (char*)P; };
/*ARGSUSED*/ static void door_server(void *cookie, char *argp, size_t sz, door_desc_t *dp, uint_t ndesc) { nvlist_t *args = NULL; nvlist_t *results = NULL; hp_cmd_t cmd; int rv; dprintf("Door call: cookie=%p, argp=%p, sz=%d\n", cookie, (void *)argp, sz); /* Special case to free a results buffer */ if (sz == sizeof (uint64_t)) { free_buffer(*(uint64_t *)(uintptr_t)argp); (void) door_return(NULL, 0, NULL, 0); return; } /* Unpack the arguments nvlist */ if (nvlist_unpack(argp, sz, &args, 0) != 0) { log_err("Cannot unpack door arguments.\n"); rv = EINVAL; goto fail; } /* Extract the requested command */ if (nvlist_lookup_int32(args, HPD_CMD, (int32_t *)&cmd) != 0) { log_err("Cannot decode door command.\n"); rv = EINVAL; goto fail; } /* Implement the command */ switch (cmd) { case HP_CMD_GETINFO: rv = cmd_getinfo(args, &results); break; case HP_CMD_CHANGESTATE: rv = cmd_changestate(args, &results); break; case HP_CMD_SETPRIVATE: case HP_CMD_GETPRIVATE: rv = cmd_private(cmd, args, &results); break; default: rv = EINVAL; break; } /* The arguments nvlist is no longer needed */ nvlist_free(args); args = NULL; /* * If an nvlist was constructed for the results, * then pack the results nvlist and return it. */ if (results != NULL) { uint64_t seqnum; char *buf = NULL; size_t len = 0; /* Add a sequence number to the results */ seqnum = get_seqnum(); if (nvlist_add_uint64(results, HPD_SEQNUM, seqnum) != 0) { log_err("Cannot add sequence number.\n"); rv = EFAULT; goto fail; } /* Pack the results nvlist */ if (nvlist_pack(results, &buf, &len, NV_ENCODE_NATIVE, 0) != 0) { log_err("Cannot pack door results.\n"); rv = EFAULT; goto fail; } /* Link results buffer into list */ add_buffer(seqnum, buf); /* The results nvlist is no longer needed */ nvlist_free(results); /* Return the results */ (void) door_return(buf, len, NULL, 0); return; } /* Return result code (when no nvlist) */ (void) door_return((char *)&rv, sizeof (int), NULL, 0); return; fail: log_err("Door call failed (%s)\n", strerror(rv)); nvlist_free(args); nvlist_free(results); (void) door_return((char *)&rv, sizeof (int), NULL, 0); }
int elf_ia64_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) { struct mem_ehdr ehdr; const char *command_line, *ramdisk=0, *vmm=0, *kernel_buf; char *ramdisk_buf = NULL; off_t ramdisk_size = 0, kernel_size; unsigned long command_line_len; unsigned long entry, max_addr, gp_value; unsigned long command_line_base, ramdisk_base, image_base; unsigned long efi_memmap_base, efi_memmap_size; unsigned long boot_param_base; unsigned long noio=0; int result; int opt; char *efi_memmap_buf, *boot_param; static const struct option options[] = { KEXEC_ARCH_OPTIONS {"command-line", 1, 0, OPT_APPEND}, {"append", 1, 0, OPT_APPEND}, {"initrd", 1, 0, OPT_RAMDISK}, {"noio", 0, 0, OPT_NOIO}, {"vmm", 1, 0, OPT_VMM}, {0, 0, 0, 0}, }; static const char short_options[] = KEXEC_ARCH_OPT_STR ""; command_line = 0; while ((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch (opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case '?': usage(); return -1; case OPT_APPEND: command_line = optarg; break; case OPT_RAMDISK: ramdisk = optarg; break; case OPT_NOIO: /* disable PIO and MMIO in purgatory code*/ noio = 1; break; case OPT_VMM: vmm = optarg; break; } } command_line_len = 0; if (command_line) { command_line_len = strlen(command_line) + 16; } if (vmm) kernel_buf = slurp_decompress_file(vmm, &kernel_size); else { kernel_buf = buf; kernel_size = len; } /* Parse the Elf file */ result = build_elf_exec_info(kernel_buf, kernel_size, &ehdr, 0); if (result < 0) { fprintf(stderr, "ELF parse failed\n"); free_elf_info(&ehdr); return result; } if (info->kexec_flags & KEXEC_ON_CRASH ) { if ((mem_min == 0x00) && (mem_max == ULONG_MAX)) { fprintf(stderr, "Failed to find crash kernel region " "in %s\n", proc_iomem()); free_elf_info(&ehdr); return -1; } move_loaded_segments(info, &ehdr, mem_min); } else if (update_loaded_segments(info, &ehdr) < 0) { fprintf(stderr, "Failed to place kernel\n"); return -1; } entry = ehdr.e_entry; max_addr = elf_max_addr(&ehdr); /* Load the Elf data */ result = elf_exec_load(&ehdr, info); if (result < 0) { fprintf(stderr, "ELF load failed\n"); free_elf_info(&ehdr); return result; } /* Load the setup code */ elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0x0, ULONG_MAX, -1, 0); if (load_crashdump_segments(info, &ehdr, max_addr, 0, &command_line) < 0) return -1; // reverve 4k for ia64_boot_param boot_param = xmalloc(4096); boot_param_base = add_buffer(info, boot_param, 4096, 4096, 4096, 0, max_addr, -1); elf_rel_set_symbol(&info->rhdr, "__noio", &noio, sizeof(long)); elf_rel_set_symbol(&info->rhdr, "__boot_param_base", &boot_param_base, sizeof(long)); // reserve efi_memmap of actual size allocated in production kernel efi_memmap_size = saved_efi_memmap_size; efi_memmap_buf = xmalloc(efi_memmap_size); efi_memmap_base = add_buffer(info, efi_memmap_buf, efi_memmap_size, efi_memmap_size, 4096, 0, max_addr, -1); elf_rel_set_symbol(&info->rhdr, "__efi_memmap_base", &efi_memmap_base, sizeof(long)); elf_rel_set_symbol(&info->rhdr, "__efi_memmap_size", &efi_memmap_size, sizeof(long)); if (command_line) { command_line_len = strlen(command_line) + 1; } if (command_line_len || (info->kexec_flags & KEXEC_ON_CRASH )) { char *cmdline = xmalloc(command_line_len); strcpy(cmdline, command_line); if (info->kexec_flags & KEXEC_ON_CRASH) { char buf[128]; sprintf(buf," max_addr=%lluM min_addr=%lluM", mem_max>>20, mem_min>>20); command_line_len = strlen(cmdline) + strlen(buf) + 1; cmdline = xrealloc(cmdline, command_line_len); strcat(cmdline, buf); }
if (command_line_len || (info->kexec_flags & KEXEC_ON_CRASH )) { char *cmdline = xmalloc(command_line_len); strcpy(cmdline, command_line); if (info->kexec_flags & KEXEC_ON_CRASH) { char buf[128]; sprintf(buf," max_addr=%lluM min_addr=%lluM", mem_max>>20, mem_min>>20); command_line_len = strlen(cmdline) + strlen(buf) + 1; cmdline = xrealloc(cmdline, command_line_len); strcat(cmdline, buf); } command_line_len = (command_line_len + 15)&(~15); command_line_base = add_buffer(info, cmdline, command_line_len, command_line_len, getpagesize(), 0UL, max_addr, -1); elf_rel_set_symbol(&info->rhdr, "__command_line_len", &command_line_len, sizeof(long)); elf_rel_set_symbol(&info->rhdr, "__command_line", &command_line_base, sizeof(long)); } if (ramdisk) { ramdisk_buf = slurp_file(ramdisk, &ramdisk_size); ramdisk_base = add_buffer(info, ramdisk_buf, ramdisk_size, ramdisk_size, getpagesize(), 0, max_addr, -1); elf_rel_set_symbol(&info->rhdr, "__ramdisk_base", &ramdisk_base, sizeof(long)); elf_rel_set_symbol(&info->rhdr, "__ramdisk_size",
/* Loads additional segments in case of a panic kernel is being loaded. * One segment for backup region, another segment for storing elf headers * for crash memory image. */ int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline, unsigned long max_addr, unsigned long min_base) { void *tmp; unsigned long sz, elfcorehdr; int nr_ranges, align = 1024, i; struct memory_range *mem_range, *memmap_p; struct crash_elf_info elf_info = { class: ELFCLASS64, data: ELFDATA2LSB, machine: EM_X86_64, backup_src_start: BACKUP_SRC_START, backup_src_end: BACKUP_SRC_END, page_offset: page_offset, }; if (get_kernel_paddr(info)) return -1; if (get_kernel_vaddr_and_size(info)) return -1; if (get_crash_memory_ranges(&mem_range, &nr_ranges, info->kexec_flags) < 0) return -1; /* Memory regions which panic kernel can safely use to boot into */ sz = (sizeof(struct memory_range) * (KEXEC_MAX_SEGMENTS + 1)); memmap_p = xmalloc(sz); memset(memmap_p, 0, sz); add_memmap(memmap_p, BACKUP_SRC_START, BACKUP_SRC_SIZE); sz = crash_reserved_mem.end - crash_reserved_mem.start +1; add_memmap(memmap_p, crash_reserved_mem.start, sz); /* Create a backup region segment to store backup data*/ if (!(info->kexec_flags & KEXEC_PRESERVE_CONTEXT)) { sz = (BACKUP_SRC_SIZE + align - 1) & ~(align - 1); tmp = xmalloc(sz); memset(tmp, 0, sz); info->backup_start = add_buffer(info, tmp, sz, sz, align, 0, max_addr, 1); if (delete_memmap(memmap_p, info->backup_start, sz) < 0) return -1; } /* Create elf header segment and store crash image data. */ if (crash_create_elf64_headers(info, &elf_info, crash_memory_range, nr_ranges, &tmp, &sz, ELF_CORE_HEADER_ALIGN) < 0) return -1; /* Hack: With some ld versions (GNU ld version 2.14.90.0.4 20030523), * vmlinux program headers show a gap of two pages between bss segment * and data segment but effectively kernel considers it as bss segment * and overwrites the any data placed there. Hence bloat the memsz of * elf core header segment to 16K to avoid being placed in such gaps. * This is a makeshift solution until it is fixed in kernel. */ elfcorehdr = add_buffer(info, tmp, sz, 16*1024, align, min_base, max_addr, -1); if (delete_memmap(memmap_p, elfcorehdr, sz) < 0) return -1; cmdline_add_memmap(mod_cmdline, memmap_p); cmdline_add_elfcorehdr(mod_cmdline, elfcorehdr); /* Inform second kernel about the presence of ACPI tables. */ for (i = 0; i < CRASH_MAX_MEMORY_RANGES; i++) { unsigned long start, end; if ( !( mem_range[i].type == RANGE_ACPI || mem_range[i].type == RANGE_ACPI_NVS) ) continue; start = mem_range[i].start; end = mem_range[i].end; cmdline_add_memmap_acpi(mod_cmdline, start, end); } return 0; }
void setup_linux_bootloader_parameters_high( struct kexec_info *info, struct x86_linux_param_header *real_mode, unsigned long real_mode_base, unsigned long cmdline_offset, const char *cmdline, off_t cmdline_len, const char *initrd_buf, off_t initrd_size, int initrd_high) { char *cmdline_ptr; unsigned long initrd_base, initrd_addr_max; /* Say I'm a boot loader */ real_mode->loader_type = LOADER_TYPE_KEXEC << 4; /* No loader flags */ real_mode->loader_flags = 0; /* Find the maximum initial ramdisk address */ if (initrd_high) initrd_addr_max = ULONG_MAX; else { initrd_addr_max = DEFAULT_INITRD_ADDR_MAX; if (real_mode->protocol_version >= 0x0203) { initrd_addr_max = real_mode->initrd_addr_max; dbgprintf("initrd_addr_max is 0x%lx\n", initrd_addr_max); } } /* Load the initrd if we have one */ if (initrd_buf) { initrd_base = add_buffer(info, initrd_buf, initrd_size, initrd_size, 4096, INITRD_BASE, initrd_addr_max, -1); dbgprintf("Loaded initrd at 0x%lx size 0x%lx\n", initrd_base, initrd_size); } else { initrd_base = 0; initrd_size = 0; } /* Ramdisk address and size */ real_mode->initrd_start = initrd_base & 0xffffffffUL; real_mode->initrd_size = initrd_size & 0xffffffffUL; if (real_mode->protocol_version >= 0x020c && (initrd_base & 0xffffffffUL) != initrd_base) real_mode->ext_ramdisk_image = initrd_base >> 32; if (real_mode->protocol_version >= 0x020c && (initrd_size & 0xffffffffUL) != initrd_size) real_mode->ext_ramdisk_size = initrd_size >> 32; /* The location of the command line */ /* if (real_mode_base == 0x90000) { */ real_mode->cl_magic = CL_MAGIC_VALUE; real_mode->cl_offset = cmdline_offset; /* setup_move_size */ /* } */ if (real_mode->protocol_version >= 0x0202) { unsigned long cmd_line_ptr = real_mode_base + cmdline_offset; real_mode->cmd_line_ptr = cmd_line_ptr & 0xffffffffUL; if ((real_mode->protocol_version >= 0x020c) && ((cmd_line_ptr & 0xffffffffUL) != cmd_line_ptr)) real_mode->ext_cmd_line_ptr = cmd_line_ptr >> 32; }
int elf_mips_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) { struct mem_ehdr ehdr; const char *command_line; int command_line_len; char *crash_cmdline; int opt; int result; unsigned long cmdline_addr; size_t i; unsigned long bss_start = 0, bss_size = 0; static const struct option options[] = { KEXEC_ARCH_OPTIONS {"command-line", 1, 0, OPT_APPEND}, {"append", 1, 0, OPT_APPEND}, {0, 0, 0, 0}, }; static const char short_options[] = KEXEC_ARCH_OPT_STR "d"; command_line = 0; while ((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch (opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case '?': usage(); return -1; case OPT_APPEND: command_line = optarg; break; } } command_line_len = 0; /* Need to append some command line parameters internally in case of * taking crash dumps. */ if (info->kexec_flags & KEXEC_ON_CRASH) { crash_cmdline = xmalloc(COMMAND_LINE_SIZE); memset((void *)crash_cmdline, 0, COMMAND_LINE_SIZE); } else crash_cmdline = NULL; result = build_elf_exec_info(buf, len, &ehdr, 0); if (result < 0) die("ELF exec parse failed\n"); /* Read in the PT_LOAD segments and remove CKSEG0 mask from address*/ for (i = 0; i < ehdr.e_phnum; i++) { struct mem_phdr *phdr; phdr = &ehdr.e_phdr[i]; if (phdr->p_type == PT_LOAD) phdr->p_paddr = virt_to_phys(phdr->p_paddr); } for (i = 0; i < ehdr.e_shnum; i++) { struct mem_shdr *shdr; unsigned char *strtab; strtab = (unsigned char *)ehdr.e_shdr[ehdr.e_shstrndx].sh_data; shdr = &ehdr.e_shdr[i]; if (shdr->sh_size && strcmp((char *)&strtab[shdr->sh_name], ".bss") == 0) { bss_start = virt_to_phys(shdr->sh_addr); bss_size = shdr->sh_size; break; } } /* Load the Elf data */ result = elf_exec_load(&ehdr, info); if (result < 0) die("ELF exec load failed\n"); info->entry = (void *)virt_to_phys(ehdr.e_entry); /* Put cmdline right after bss for crash*/ if (info->kexec_flags & KEXEC_ON_CRASH) cmdline_addr = bss_start + bss_size; else cmdline_addr = 0; if (!bss_size) die("No .bss segment present\n"); if (command_line) command_line_len = strlen(command_line) + 1; if (info->kexec_flags & KEXEC_ON_CRASH) { result = load_crashdump_segments(info, crash_cmdline, 0, 0); if (result < 0) { free(crash_cmdline); return -1; } } if (command_line) strncat(cmdline_buf, command_line, command_line_len); if (crash_cmdline) strncat(cmdline_buf, crash_cmdline, sizeof(crash_cmdline) - strlen(crash_cmdline) - 1); add_buffer(info, cmdline_buf, sizeof(cmdline_buf), sizeof(cmdline_buf), sizeof(void *), cmdline_addr, 0x0fffffff, 1); return 0; }
static int __devinit pxa3xx_gcu_probe(struct platform_device *dev) { int i, ret, irq; struct resource *r; struct pxa3xx_gcu_priv *priv; priv = kzalloc(sizeof(struct pxa3xx_gcu_priv), GFP_KERNEL); if (!priv) return -ENOMEM; for (i = 0; i < 8; i++) { ret = add_buffer(dev, priv); if (ret) { dev_err(&dev->dev, "failed to allocate DMA memory\n"); goto err_free_priv; } } init_waitqueue_head(&priv->wait_idle); init_waitqueue_head(&priv->wait_free); spin_lock_init(&priv->spinlock); /* we allocate the misc device structure as part of our own allocation, * so we can get a pointer to our priv structure later on with * container_of(). This isn't really necessary as we have a fixed minor * number anyway, but this is to avoid statics. */ priv->misc_fops.owner = THIS_MODULE; priv->misc_fops.write = pxa3xx_gcu_misc_write; priv->misc_fops.unlocked_ioctl = pxa3xx_gcu_misc_ioctl; priv->misc_fops.mmap = pxa3xx_gcu_misc_mmap; priv->misc_dev.minor = MISCDEV_MINOR, priv->misc_dev.name = DRV_NAME, priv->misc_dev.fops = &priv->misc_fops, /* register misc device */ ret = misc_register(&priv->misc_dev); if (ret < 0) { dev_err(&dev->dev, "misc_register() for minor %d failed\n", MISCDEV_MINOR); goto err_free_priv; } /* handle IO resources */ r = platform_get_resource(dev, IORESOURCE_MEM, 0); if (r == NULL) { dev_err(&dev->dev, "no I/O memory resource defined\n"); ret = -ENODEV; goto err_misc_deregister; } if (!request_mem_region(r->start, resource_size(r), dev->name)) { dev_err(&dev->dev, "failed to request I/O memory\n"); ret = -EBUSY; goto err_misc_deregister; } priv->mmio_base = ioremap_nocache(r->start, resource_size(r)); if (!priv->mmio_base) { dev_err(&dev->dev, "failed to map I/O memory\n"); ret = -EBUSY; goto err_free_mem_region; } /* allocate dma memory */ priv->shared = dma_alloc_coherent(&dev->dev, SHARED_SIZE, &priv->shared_phys, GFP_KERNEL); if (!priv->shared) { dev_err(&dev->dev, "failed to allocate DMA memory\n"); ret = -ENOMEM; goto err_free_io; } /* enable the clock */ priv->clk = clk_get(&dev->dev, NULL); if (IS_ERR(priv->clk)) { dev_err(&dev->dev, "failed to get clock\n"); ret = -ENODEV; goto err_free_dma; } ret = clk_enable(priv->clk); if (ret < 0) { dev_err(&dev->dev, "failed to enable clock\n"); goto err_put_clk; } /* request the IRQ */ irq = platform_get_irq(dev, 0); if (irq < 0) { dev_err(&dev->dev, "no IRQ defined\n"); ret = -ENODEV; goto err_put_clk; } ret = request_irq(irq, pxa3xx_gcu_handle_irq, 0, DRV_NAME, priv); if (ret) { dev_err(&dev->dev, "request_irq failed\n"); ret = -EBUSY; goto err_put_clk; } platform_set_drvdata(dev, priv); priv->resource_mem = r; pxa3xx_gcu_reset(priv); pxa3xx_gcu_init_debug_timer(); dev_info(&dev->dev, "registered @0x%p, DMA 0x%p (%d bytes), IRQ %d\n", (void *) r->start, (void *) priv->shared_phys, SHARED_SIZE, irq); return 0; err_put_clk: clk_disable(priv->clk); clk_put(priv->clk); err_free_dma: dma_free_coherent(&dev->dev, SHARED_SIZE, priv->shared, priv->shared_phys); err_free_io: iounmap(priv->mmio_base); err_free_mem_region: release_mem_region(r->start, resource_size(r)); err_misc_deregister: misc_deregister(&priv->misc_dev); err_free_priv: platform_set_drvdata(dev, NULL); free_buffers(dev, priv); kfree(priv); return ret; }
/* Loads additional segments in case of a panic kernel is being loaded. * One segment for backup region, another segment for storing elf headers * for crash memory image. */ int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline, unsigned long UNUSED(max_addr), unsigned long UNUSED(min_base)) { void *tmp; unsigned long sz, elfcorehdr; int nr_ranges, align = 1024; struct memory_range *mem_range; crash_create_elf_headers_func crash_create = crash_create_elf32_headers; struct crash_elf_info *elf_info = &elf_info32; unsigned long start_offset = 0x80000000UL; #ifdef __mips64 if (arch_options.core_header_type == CORE_TYPE_ELF64) { elf_info = &elf_info64; crash_create = crash_create_elf64; start_offset = 0xffffffff80000000UL; } #endif if (get_kernel_paddr(elf_info)) return -1; if (get_kernel_vaddr_and_size(elf_info, start_offset)) return -1; if (get_crash_memory_ranges(&mem_range, &nr_ranges) < 0) return -1; info->backup_src_start = BACKUP_SRC_START; info->backup_src_size = BACKUP_SRC_SIZE; /* Create a backup region segment to store backup data*/ sz = (BACKUP_SRC_SIZE + align - 1) & ~(align - 1); tmp = xmalloc(sz); memset(tmp, 0, sz); info->backup_start = add_buffer(info, tmp, sz, sz, align, crash_reserved_mem.start, crash_reserved_mem.end, -1); if (crash_create(info, elf_info, crash_memory_range, nr_ranges, &tmp, &sz, ELF_CORE_HEADER_ALIGN) < 0) return -1; elfcorehdr = add_buffer(info, tmp, sz, sz, align, crash_reserved_mem.start, crash_reserved_mem.end, -1); /* * backup segment is after elfcorehdr, so use elfcorehdr as top of * kernel's available memory */ cmdline_add_mem(mod_cmdline, crash_reserved_mem.start, elfcorehdr - crash_reserved_mem.start); cmdline_add_elfcorehdr(mod_cmdline, elfcorehdr); cmdline_add_savemaxmem(mod_cmdline, saved_max_mem); #ifdef DEBUG printf("CRASH MEMORY RANGES:\n"); printf("%016Lx-%016Lx\n", crash_reserved_mem.start, crash_reserved_mem.end); #endif return 0; }
static void button_click(gpointer data) { if(strcmp("button.open", (char *)data) == 0) { GtkWidget * dialog; dialog = gtk_file_chooser_dialog_new("Open file", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if(srecmpend(".dat", file) == 0) { add_buffer(); image_load_map(file); } else if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0) { GError * err = NULL; add_buffer(); if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox))) generate_image_dithered(mdata[current_buffer], file, colors, &err); else generate_image(mdata[current_buffer], file, colors, &err); if(err != NULL) { information("Error while loading image file!"); printf("%s\n", err->message); g_error_free(err); } set_image(); } else if(srecmpend(".imtm", file) == 0) { add_buffer(); load_raw_map(file, mdata[current_buffer]); set_image(); } else information("File format not supported!"); } gtk_widget_destroy(dialog); } else if(strcmp("button.save", (char *)data) == 0) { if(mdata[current_buffer] == NULL) return; GtkWidget * dialog; dialog = gtk_file_chooser_dialog_new ("Save Map", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat"); if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); printf("%s\n", file); if(srecmpend(".dat", file) == 0) save_map(file); } gtk_widget_destroy(dialog); printf("bracket cleared\n"); } else if(strcmp("button.exp_img", (char *)data) == 0) { if(mdata[current_buffer] == NULL) return; GtkWidget * dialog; dialog = gtk_file_chooser_dialog_new ("Export Image of Map", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.png"); if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); printf("%s\n", file); unsigned char * data = malloc(128 * 128 * 3); int i; for(i = 0; i < 128 * 128; i++) { if(mdata[current_buffer][i] > 3) { data[i * 3] = colors[mdata[current_buffer][i]].r; data[i * 3 + 1] = colors[mdata[current_buffer][i]].g; data[i * 3 + 2] = colors[mdata[current_buffer][i]].b; } else { int x = i % 128, y = i / 128; x /= 4; y /= 4; data[i * 3] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA; data[i * 3 + 1] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA; data[i * 3 + 2] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA; } } GdkPixbuf * spixbuf = image_from_data(data, 0); free(data); GError * err = NULL; gdk_pixbuf_save(spixbuf, file, "png", &err, "compression", "9", NULL); if (err != NULL) { /* Report error to user, and free error */ printf("Error while saving: %s\n", err->message); g_error_free(err); } g_object_unref(spixbuf); } gtk_widget_destroy(dialog); } else if(strcmp("button.save_rm", (char *)data) == 0) { if(mdata == NULL) return; GtkWidget * dialog; dialog = gtk_file_chooser_dialog_new("Save Map", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.imtm"); if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); printf("%s\n", file); save_raw_map(file, mdata[current_buffer]); } gtk_widget_destroy(dialog); } else if(strcmp("button.palette", (char *)data) == 0) { add_buffer(); generate_palette(mdata[current_buffer]); set_image(); } else if(strcmp("button.random_noise", (char *)data) == 0) { add_buffer(); generate_random_noise(mdata[current_buffer]); set_image(); } else if(strcmp("button.mandelbrot", (char *)data) == 0) { add_buffer(); generate_mandelbrot(mdata[current_buffer]); set_image(); } else if(strcmp("button.julia", (char *)data) == 0) { add_buffer(); generate_julia(mdata[current_buffer], 0.5, 0.5); set_image(); } else if(strcmp("button.from_clipboard", (char *)data) == 0) { GtkClipboard * clipboard; clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); gtk_clipboard_request_image(clipboard, clipboard_callback, NULL); } else printf("Unhandeled button press: %s\n", (char *)data); }
Ttoken* tokGet(FILE* source){ char c; char buffer[128]=""; int i; int state; bool loop=true; Ttoken* tkn; tkn=malloc(sizeof(Ttoken)); memset(buffer,128,'\0'); state=0; i=0; if (source==NULL){ perror("Error:Invalid FILE pointer\n"); } else{ while(loop){ c=fgetc(source); //if (i==126){ => buffer overflow - vyriesit if(c==EOF){ // Ak nazari na EOF a je prazdny buffer => koniec a vrati NULL if(buffer[0]=='\0'){ // Inak vrati to, co zatial precital a pri dalsom volani funkcie vrati NULL free(tkn); return NULL; } else{ break; } } else if((state==S_SLC)&&(c=='\n')){ // Koniec jednoriadkoveho komentu memset(buffer,128,'\0'); state=S_start; } else if((state==S_MLC)&&(c=='*')){ c=fgetc(source); if(c=='/'){ memset(buffer,128,'\0'); state=S_start; } else{ state=S_MLC; } } else if(isspace(c)){ // C je biely znak if(state==S_quotes){ add_buffer(&buffer[0],&i,c); } else if((state!=S_start)&&(state!=S_quotes)){ loop=false; } } else{ // C nieje koniec suboru ani whitespace if((state==S_quotes)&&(c>31)&&(c!=34)){ // Medzi uvodzovkami, a neni znak na ktory treba add_buffer(&buffer[0],&i,c); // escape sekvenciu ani " => lexema konci az " } else{ switch(c){ case 34:{ // Uvodzovky if(state==S_quotes){ add_buffer(&buffer[0],&i,c); loop=false; break; } else if((state!=S_start)&&(state!=S_quotes)){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); state=S_quotes; break; } } case '<':{ if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ // Precita dalsi znak ak to nieje '=' tak vracia '<' a pozicia v subore -1 add_buffer(&buffer[0],&i,c); c=fgetc(source); if (c=='='){ add_buffer(&buffer[0],&i,c); state=S_LEQ; loop=false; break; } else{ fseek(source,-1,SEEK_CUR); state=S_LSS; loop=false; break; } } } case '>':{ // Precita dalsi znak ak to nieje '=' tak vracia '>' a pozicia v subore -1 if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); c=fgetc(source); if (c=='='){ add_buffer(&buffer[0],&i,c); state=S_GEQ; loop=false; break; } else{ fseek(source,-1,SEEK_CUR); state=S_GTR; loop=false; break; } } } case '=':{ // Precita dalsi znak ak to nieje '=' tak vracia '=' a pozicia v subore -1 if(state!=S_start){ // inak vracia '==' fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); c=fgetc(source); if (c=='='){ state=S_EQ; loop=false; break; } else{ state=S_ASGN; loop=false; break; } } } case '!':{ // Ak dalsi znak nieje '=' => chyba if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); c=fgetc(source); if(c=='='){ state=S_NEQ; add_buffer(&buffer[0],&i,c); loop=false; break; } else{ free(tkn); perror(("Error:Invalid expression ! missing'='\n")); //Pridat pocitadlo pre riadky a poziciu na riadku + doplnit chybove hlasenie //return NULL; } } } case '+':{ if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); state=S_ADD; loop=false; break; } } case '-':{ if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); state=S_SUB; loop=false; break; } } case '/':{ // Delenie, jednoriadkovy koment, alebo viacriadkovy koment if(state!=S_start){ // Vyriesit prepinace na komenty fseek(source,-1,SEEK_CUR); // flushnut buffer, state=S_start a ist dalej loop=false; // pre SLC ked \n a pre MLC ked */ break; } else{ add_buffer(&buffer[0],&i,c); c=fgetc(source); if(c=='/'){ add_buffer(&buffer[0],&i,c); state=S_SLC; loop=false; break; } else if(c=='*'){ add_buffer(&buffer[0],&i,c); state=S_MLC; loop=false; break; } } } case '*':{ //ked za * nasleduje / tak skoncil MLC if(state!=S_start){ fseek(source,-1,SEEK_CUR); loop=false; break; } else{ add_buffer(&buffer[0],&i,c); c=fgetc(source); if(c=='/'){ state=S_start; memset(buffer,128,'\0'); break; } else{ state=S_MUL; loop=false; break; } } } default:{ if(isalpha(c) || (c=='_')){ //Identifikator if((state!=S_start)&&(state!=S_ID)){ //ERROR - add loop=false; } else{ add_buffer(&buffer[0],&i,c); state=S_ID; } } else if( (isdigit(c)) ){ //Cislo if((state!=S_start)&&(state!=S_int)){ }else{ add_buffer(&buffer[0],&i,c); state=S_int; } } } } } } } } //strncpy(tkn->lexeme,buffer,i-1); tkn->lexeme=buffer; tkn->type=state; return tkn; }
/* Loads additional segments in case of a panic kernel is being loaded. * One segment for backup region, another segment for storing elf headers * for crash memory image. */ int load_crashdump_segments(struct kexec_info *info, char* mod_cmdline, uint64_t max_addr, unsigned long min_base) { void *tmp; unsigned long sz; uint64_t elfcorehdr; int nr_ranges, align = 1024, i; unsigned long long end; struct memory_range *mem_range; if (get_crash_memory_ranges(&mem_range, &nr_ranges) < 0) return -1; /* Create a backup region segment to store backup data*/ sz = (BACKUP_SRC_SIZE + align - 1) & ~(align - 1); tmp = xmalloc(sz); memset(tmp, 0, sz); info->backup_start = add_buffer(info, tmp, sz, sz, align, 0, max_addr, 1); reserve(info->backup_start, sz); /* On ppc64 memory ranges in device-tree is denoted as start * and size rather than start and end, as is the case with * other architectures like i386 . Because of this when loading * the memory ranges in crashdump-elf.c the filesz calculation * [ end - start + 1 ] goes for a toss. * * To be in sync with other archs adjust the end value for * every crash memory range before calling the generic function */ for (i = 0; i < nr_ranges; i++) { end = crash_memory_range[i].end - 1; crash_memory_range[i].end = end; } /* Create elf header segment and store crash image data. */ if (arch_options.core_header_type == CORE_TYPE_ELF64) { if (crash_create_elf64_headers(info, &elf_info64, crash_memory_range, nr_ranges, &tmp, &sz, ELF_CORE_HEADER_ALIGN) < 0) return -1; } else { if (crash_create_elf32_headers(info, &elf_info32, crash_memory_range, nr_ranges, &tmp, &sz, ELF_CORE_HEADER_ALIGN) < 0) return -1; } elfcorehdr = add_buffer(info, tmp, sz, sz, align, min_base, max_addr, 1); reserve(elfcorehdr, sz); /* modify and store the cmdline in a global array. This is later * read by flatten_device_tree and modified if required */ add_cmdline_param(mod_cmdline, elfcorehdr, " elfcorehdr=", "K"); add_cmdline_param(mod_cmdline, saved_max_mem, " savemaxmem=", "M"); return 0; }
int multiboot_x86_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) /* Marshal up a multiboot-style kernel */ { struct multiboot_info *mbi; void *mbi_buf; struct mod_list *modp; unsigned long freespace; unsigned long long mem_lower = 0, mem_upper = 0; struct mem_ehdr ehdr; unsigned long mbi_base; struct entry32_regs regs; size_t mbi_bytes, mbi_offset; char *command_line = NULL; char *imagename, *cp, *append = NULL;; struct memory_range *range; int ranges; struct AddrRangeDesc *mmap; int command_line_len; int i; uint32_t u; int opt; int modules, mod_command_line_space; /* See options.h -- add any more there, too. */ static const struct option options[] = { KEXEC_ARCH_OPTIONS { "command-line", 1, 0, OPT_CL }, { "append", 1, 0, OPT_CL }, { "reuse-cmdline", 0, 0, OPT_REUSE_CMDLINE }, { "module", 1, 0, OPT_MOD }, { 0, 0, 0, 0 }, }; static const char short_options[] = KEXEC_ARCH_OPT_STR ""; /* Probe for the MB header if it's not already found */ if (mbh == NULL && multiboot_x86_probe(buf, len) != 1) { fprintf(stderr, "Cannot find a loadable multiboot header.\n"); return -1; } /* Parse the command line */ command_line = ""; command_line_len = 0; modules = 0; mod_command_line_space = 0; while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch(opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case '?': usage(); return -1; case OPT_CL: append = optarg; break; case OPT_REUSE_CMDLINE: command_line = get_command_line(); break; case OPT_MOD: modules++; mod_command_line_space += strlen(optarg) + 1; break; } } imagename = argv[optind]; command_line = concat_cmdline(command_line, append); command_line_len = strlen(command_line) + strlen(imagename) + 2; /* Load the ELF executable */ elf_exec_build_load(info, &ehdr, buf, len, 0); /* Load the setup code */ elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0, ULONG_MAX, 1, 0); /* The first segment will contain the multiboot headers: * ============= * multiboot information (mbi) * ------------- * kernel command line * ------------- * bootloader name * ------------- * module information entries * ------------- * module command lines * ============== */ mbi_bytes = (sizeof(*mbi) + command_line_len + strlen (BOOTLOADER " " BOOTLOADER_VERSION) + 1 + 3) & ~3; mbi_buf = xmalloc(mbi_bytes); mbi = mbi_buf; memset(mbi, 0, sizeof(*mbi)); sprintf(((char *)mbi) + sizeof(*mbi), "%s %s", imagename, command_line); sprintf(((char *)mbi) + sizeof(*mbi) + command_line_len, "%s", BOOTLOADER " " BOOTLOADER_VERSION); mbi->flags = MB_INFO_CMDLINE | MB_INFO_BOOT_LOADER_NAME; /* We'll relocate these to absolute addresses later. For now, * all addresses within the first segment are relative to the * start of the MBI. */ mbi->cmdline = sizeof(*mbi); mbi->boot_loader_name = sizeof(*mbi) + command_line_len; /* Memory map */ if ((get_memory_ranges(&range, &ranges, info->kexec_flags) < 0) || ranges == 0) { fprintf(stderr, "Cannot get memory information\n"); return -1; } mmap = xmalloc(ranges * sizeof(*mmap)); for (i=0; i<ranges; i++) { unsigned long long length; length = range[i].end - range[i].start; /* Translate bzImage mmap to multiboot-speak */ mmap[i].size = sizeof(mmap[i]) - 4; mmap[i].base_addr_low = range[i].start & 0xffffffff; mmap[i].base_addr_high = range[i].start >> 32; mmap[i].length_low = length & 0xffffffff; mmap[i].length_high = length >> 32; if (range[i].type == RANGE_RAM) { mmap[i].Type = 1; /* RAM */ /* Is this the "low" memory? */ if ((range[i].start == 0) && (range[i].end > mem_lower)) mem_lower = range[i].end; /* Is this the "high" memory? */ if ((range[i].start <= 0x100000) && (range[i].end > mem_upper + 0x100000)) mem_upper = range[i].end - 0x100000; } else mmap[i].Type = 0xbad; /* Not RAM */ } if (mbh->flags & MULTIBOOT_MEMORY_INFO) { /* Provide a copy of the memory map to the kernel */ mbi->flags |= MB_INFO_MEMORY | MB_INFO_MEM_MAP; freespace = add_buffer(info, mmap, ranges * sizeof(*mmap), ranges * sizeof(*mmap), 4, 0, 0xFFFFFFFFUL, 1); mbi->mmap_addr = freespace; mbi->mmap_length = ranges * sizeof(*mmap); /* For kernels that care naught for fancy memory maps * and just want the size of low and high memory */ mbi->mem_lower = MIN(mem_lower>>10, 0xffffffff); mbi->mem_upper = MIN(mem_upper>>10, 0xffffffff); /* done */ }
int elf_x86_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) { struct mem_ehdr ehdr; char *command_line = NULL, *modified_cmdline = NULL; const char *append = NULL; char *tmp_cmdline = NULL; char *error_msg = NULL; int result; int command_line_len; const char *ramdisk; unsigned long entry, max_addr; int arg_style; #define ARG_STYLE_ELF 0 #define ARG_STYLE_LINUX 1 #define ARG_STYLE_NONE 2 int opt; /* See options.h -- add any more there, too. */ static const struct option options[] = { KEXEC_ARCH_OPTIONS { "command-line", 1, NULL, OPT_APPEND }, { "append", 1, NULL, OPT_APPEND }, { "reuse-cmdline", 0, NULL, OPT_REUSE_CMDLINE }, { "initrd", 1, NULL, OPT_RAMDISK }, { "ramdisk", 1, NULL, OPT_RAMDISK }, { "args-elf", 0, NULL, OPT_ARGS_ELF }, { "args-linux", 0, NULL, OPT_ARGS_LINUX }, { "args-none", 0, NULL, OPT_ARGS_NONE }, { 0, 0, NULL, 0 }, }; static const char short_options[] = KEXEC_OPT_STR ""; /* * Parse the command line arguments */ arg_style = ARG_STYLE_ELF; ramdisk = 0; result = 0; while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch(opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) { break; } case OPT_APPEND: append = optarg; break; case OPT_REUSE_CMDLINE: tmp_cmdline = get_command_line(); break; case OPT_RAMDISK: ramdisk = optarg; break; case OPT_ARGS_ELF: arg_style = ARG_STYLE_ELF; break; case OPT_ARGS_LINUX: arg_style = ARG_STYLE_LINUX; break; case OPT_ARGS_NONE: #ifdef __i386__ arg_style = ARG_STYLE_NONE; #else die("--args-none only works on arch i386\n"); #endif break; } } command_line = concat_cmdline(tmp_cmdline, append); if (tmp_cmdline) { free(tmp_cmdline); } command_line_len = 0; if (command_line) { command_line_len = strlen(command_line) +1; } else { command_line = strdup("\0"); command_line_len = 1; } /* Need to append some command line parameters internally in case of * taking crash dumps. */ if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) { modified_cmdline = xmalloc(COMMAND_LINE_SIZE); memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE); if (command_line) { strncpy(modified_cmdline, command_line, COMMAND_LINE_SIZE); modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0'; } } /* Load the ELF executable */ elf_exec_build_load(info, &ehdr, buf, len, 0); entry = ehdr.e_entry; max_addr = elf_max_addr(&ehdr); /* Do we want arguments? */ if (arg_style != ARG_STYLE_NONE) { /* Load the setup code */ elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size, 0, ULONG_MAX, 1, 0); } if (arg_style == ARG_STYLE_NONE) { info->entry = (void *)entry; } else if (arg_style == ARG_STYLE_ELF) { unsigned long note_base; struct entry32_regs regs; uint32_t arg1, arg2; /* Setup the ELF boot notes */ note_base = elf_boot_notes(info, max_addr, command_line, command_line_len); /* Initialize the stack arguments */ arg2 = 0; /* No return address */ arg1 = note_base; elf_rel_set_symbol(&info->rhdr, "stack_arg32_1", &arg1, sizeof(arg1)); elf_rel_set_symbol(&info->rhdr, "stack_arg32_2", &arg2, sizeof(arg2)); /* Initialize the registers */ elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); regs.eip = entry; /* The entry point */ regs.esp = elf_rel_get_addr(&info->rhdr, "stack_arg32_2"); elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); if (ramdisk) { error_msg = "Ramdisks not supported with generic elf arguments"; goto out; } } else if (arg_style == ARG_STYLE_LINUX) { struct x86_linux_faked_param_header *hdr; unsigned long param_base; const char *ramdisk_buf; off_t ramdisk_length; struct entry32_regs regs; int rc = 0; /* Get the linux parameter header */ hdr = xmalloc(sizeof(*hdr)); /* Hack: With some ld versions, vmlinux program headers show * a gap of two pages between bss segment and data segment * but effectively kernel considers it as bss segment and * overwrites the any data placed there. Hence bloat the * memsz of parameter segment to 16K to avoid being placed * in such gaps. * This is a makeshift solution until it is fixed in kernel */ param_base = add_buffer(info, hdr, sizeof(*hdr), 16*1024, 16, 0, max_addr, 1); /* Initialize the parameter header */ memset(hdr, 0, sizeof(*hdr)); init_linux_parameters(&hdr->hdr); /* Add a ramdisk to the current image */ ramdisk_buf = NULL; ramdisk_length = 0; if (ramdisk) { ramdisk_buf = slurp_file(ramdisk, &ramdisk_length); } /* If panic kernel is being loaded, additional segments need * to be created. */ if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) { rc = load_crashdump_segments(info, modified_cmdline, max_addr, 0); if (rc < 0) { result = -1; goto out; } /* Use new command line. */ free(command_line); command_line = modified_cmdline; command_line_len = strlen(modified_cmdline) + 1; modified_cmdline = NULL; } /* Tell the kernel what is going on */ setup_linux_bootloader_parameters(info, &hdr->hdr, param_base, offsetof(struct x86_linux_faked_param_header, command_line), command_line, command_line_len, ramdisk_buf, ramdisk_length); /* Fill in the information bios calls would usually provide */ setup_linux_system_parameters(info, &hdr->hdr); /* Initialize the registers */ elf_rel_get_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); regs.ebx = 0; /* Bootstrap processor */ regs.esi = param_base; /* Pointer to the parameters */ regs.eip = entry; /* The entry point */ regs.esp = elf_rel_get_addr(&info->rhdr, "stack_end"); /* Stack, unused */ elf_rel_set_symbol(&info->rhdr, "entry32_regs", ®s, sizeof(regs)); } else {
int elf_ppc64_load(int argc, char **argv, const char *buf, off_t len, struct kexec_info *info) { struct mem_ehdr ehdr; char *cmdline, *modified_cmdline = NULL; const char *devicetreeblob; int cmdline_len, modified_cmdline_len; uint64_t max_addr, hole_addr; unsigned char *seg_buf = NULL; off_t seg_size = 0; struct mem_phdr *phdr; size_t size; uint64_t *rsvmap_ptr; struct bootblock *bb_ptr; unsigned int nr_segments, i; int result, opt; uint64_t my_kernel, my_dt_offset; unsigned int my_panic_kernel; uint64_t my_stack, my_backup_start; uint64_t toc_addr; unsigned int slave_code[256/sizeof (unsigned int)], master_entry; #define OPT_APPEND (OPT_ARCH_MAX+0) #define OPT_RAMDISK (OPT_ARCH_MAX+1) #define OPT_DEVICETREEBLOB (OPT_ARCH_MAX+2) #define OPT_ARGS_IGNORE (OPT_ARCH_MAX+3) static const struct option options[] = { KEXEC_ARCH_OPTIONS { "command-line", 1, NULL, OPT_APPEND }, { "append", 1, NULL, OPT_APPEND }, { "ramdisk", 1, NULL, OPT_RAMDISK }, { "initrd", 1, NULL, OPT_RAMDISK }, { "devicetreeblob", 1, NULL, OPT_DEVICETREEBLOB }, { "args-linux", 0, NULL, OPT_ARGS_IGNORE }, { 0, 0, NULL, 0 }, }; static const char short_options[] = KEXEC_OPT_STR ""; /* Parse command line arguments */ initrd_base = 0; initrd_size = 0; cmdline = 0; ramdisk = 0; devicetreeblob = 0; max_addr = 0xFFFFFFFFFFFFFFFFUL; hole_addr = 0; while ((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { switch (opt) { default: /* Ignore core options */ if (opt < OPT_ARCH_MAX) break; case '?': usage(); return -1; case OPT_APPEND: cmdline = optarg; break; case OPT_RAMDISK: ramdisk = optarg; break; case OPT_DEVICETREEBLOB: devicetreeblob = optarg; break; case OPT_ARGS_IGNORE: break; } } cmdline_len = 0; if (cmdline) cmdline_len = strlen(cmdline) + 1; else fprintf(stdout, "Warning: append= option is not passed. Using the first kernel root partition\n"); if (ramdisk && reuse_initrd) die("Can't specify --ramdisk or --initrd with --reuseinitrd\n"); setup_memory_ranges(info->kexec_flags); /* Need to append some command line parameters internally in case of * taking crash dumps. */ if (info->kexec_flags & KEXEC_ON_CRASH) { modified_cmdline = xmalloc(COMMAND_LINE_SIZE); memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE); if (cmdline) { strncpy(modified_cmdline, cmdline, COMMAND_LINE_SIZE); modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0'; } modified_cmdline_len = strlen(modified_cmdline); } /* Parse the Elf file */ result = build_elf_exec_info(buf, len, &ehdr, 0); if (result < 0) { free_elf_info(&ehdr); return result; } /* Load the Elf data. Physical load addresses in elf64 header do not * show up correctly. Use user supplied address for now to patch the * elf header */ phdr = &ehdr.e_phdr[0]; size = phdr->p_filesz; if (size > phdr->p_memsz) size = phdr->p_memsz; hole_addr = (uint64_t)locate_hole(info, size, 0, 0, max_addr, 1); ehdr.e_phdr[0].p_paddr = hole_addr; result = elf_exec_load(&ehdr, info); if (result < 0) { free_elf_info(&ehdr); return result; } /* If panic kernel is being loaded, additional segments need * to be created. */ if (info->kexec_flags & KEXEC_ON_CRASH) { result = load_crashdump_segments(info, modified_cmdline, max_addr, 0); if (result < 0) return -1; /* Use new command line. */ cmdline = modified_cmdline; cmdline_len = strlen(modified_cmdline) + 1; } /* Add v2wrap to the current image */ seg_buf = NULL; seg_size = 0; seg_buf = (unsigned char *) malloc(purgatory_size); if (seg_buf == NULL) { free_elf_info(&ehdr); return -1; } memcpy(seg_buf, purgatory, purgatory_size); seg_size = purgatory_size; elf_rel_build_load(info, &info->rhdr, (const char *)purgatory, purgatory_size, 0, max_addr, 1, 0); /* Add a ram-disk to the current image * Note: Add the ramdisk after elf_rel_build_load */ if (ramdisk) { if (devicetreeblob) { fprintf(stderr, "Can't use ramdisk with device tree blob input\n"); return -1; } seg_buf = (unsigned char *)slurp_file(ramdisk, &seg_size); add_buffer(info, seg_buf, seg_size, seg_size, 0, 0, max_addr, 1); hole_addr = (uint64_t) info->segment[info->nr_segments-1].mem; initrd_base = hole_addr; initrd_size = (uint64_t) info->segment[info->nr_segments-1].memsz; } /* ramdisk */ if (devicetreeblob) { unsigned char *blob_buf = NULL; off_t blob_size = 0; /* Grab device tree from buffer */ blob_buf = (unsigned char *)slurp_file(devicetreeblob, &blob_size); add_buffer(info, blob_buf, blob_size, blob_size, 0, 0, max_addr, -1); } else { /* create from fs2dt */ seg_buf = NULL; seg_size = 0; create_flatten_tree(info, (unsigned char **)&seg_buf, (unsigned long *)&seg_size,cmdline); add_buffer(info, seg_buf, seg_size, seg_size, 0, 0, max_addr, -1); } /* patch reserve map address for flattened device-tree * find last entry (both 0) in the reserve mem list. Assume DT * entry is before this one */ bb_ptr = (struct bootblock *)( (unsigned char *)info->segment[(info->nr_segments)-1].buf); rsvmap_ptr = (uint64_t *)( (unsigned char *)info->segment[(info->nr_segments)-1].buf + bb_ptr->off_mem_rsvmap); while (*rsvmap_ptr || *(rsvmap_ptr+1)) rsvmap_ptr += 2; rsvmap_ptr -= 2; *rsvmap_ptr = (uint64_t)( info->segment[(info->nr_segments)-1].mem); rsvmap_ptr++; *rsvmap_ptr = (uint64_t)bb_ptr->totalsize; nr_segments = info->nr_segments; /* Set kernel */ my_kernel = (uint64_t)info->segment[0].mem; elf_rel_set_symbol(&info->rhdr, "kernel", &my_kernel, sizeof(my_kernel)); /* Set dt_offset */ my_dt_offset = (uint64_t)info->segment[nr_segments-1].mem; elf_rel_set_symbol(&info->rhdr, "dt_offset", &my_dt_offset, sizeof(my_dt_offset)); /* get slave code from new kernel, put in purgatory */ elf_rel_get_symbol(&info->rhdr, "purgatory_start", slave_code, sizeof(slave_code)); master_entry = slave_code[0]; memcpy(slave_code, info->segment[0].buf, sizeof(slave_code)); slave_code[0] = master_entry; elf_rel_set_symbol(&info->rhdr, "purgatory_start", slave_code, sizeof(slave_code)); if (info->kexec_flags & KEXEC_ON_CRASH) { my_panic_kernel = 1; /* Set panic flag */ elf_rel_set_symbol(&info->rhdr, "panic_kernel", &my_panic_kernel, sizeof(my_panic_kernel)); /* Set backup address */ my_backup_start = info->backup_start; elf_rel_set_symbol(&info->rhdr, "backup_start", &my_backup_start, sizeof(my_backup_start)); } /* Set stack address */ my_stack = locate_hole(info, 16*1024, 0, 0, max_addr, 1); my_stack += 16*1024; elf_rel_set_symbol(&info->rhdr, "stack", &my_stack, sizeof(my_stack)); /* Set toc */ toc_addr = (unsigned long) my_r2(&info->rhdr); elf_rel_set_symbol(&info->rhdr, "my_toc", &toc_addr, sizeof(toc_addr)); #ifdef DEBUG my_kernel = 0; my_dt_offset = 0; my_panic_kernel = 0; my_backup_start = 0; my_stack = 0; toc_addr = 0; elf_rel_get_symbol(&info->rhdr, "kernel", &my_kernel, sizeof(my_kernel)); elf_rel_get_symbol(&info->rhdr, "dt_offset", &my_dt_offset, sizeof(my_dt_offset)); elf_rel_get_symbol(&info->rhdr, "panic_kernel", &my_panic_kernel, sizeof(my_panic_kernel)); elf_rel_get_symbol(&info->rhdr, "backup_start", &my_backup_start, sizeof(my_backup_start)); elf_rel_get_symbol(&info->rhdr, "stack", &my_stack, sizeof(my_stack)); elf_rel_get_symbol(&info->rhdr, "my_toc", &toc_addr, sizeof(toc_addr)); fprintf(stderr, "info->entry is %p\n", info->entry); fprintf(stderr, "kernel is %lx\n", my_kernel); fprintf(stderr, "dt_offset is %lx\n", my_dt_offset); fprintf(stderr, "panic_kernel is %x\n", my_panic_kernel); fprintf(stderr, "backup_start is %lx\n", my_backup_start); fprintf(stderr, "stack is %lx\n", my_stack); fprintf(stderr, "toc_addr is %lx\n", toc_addr); fprintf(stderr, "purgatory size is %lu\n", purgatory_size); #endif for (i = 0; i < nr_segments; i++) fprintf(stderr, "segment[%d].mem:%p memsz:%ld\n", i, info->segment[i].mem, info->segment[i].memsz); return 0; }