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);
}
示例#2
0
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);
}
示例#3
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;
}
示例#4
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);
}
示例#5
0
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();
}
示例#6
0
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);
}
示例#7
0
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);
}
示例#8
0
/* 
 * 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;
}
示例#9
0
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);
}
示例#10
0
文件: mail.c 项目: KodersCo/hayalevi
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;
}
示例#11
0
文件: rtt.cpp 项目: a2flo/a2elight
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;
}
示例#12
0
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);
}
示例#13
0
文件: git.c 项目: eatnumber1/parsecvs
/*
 * 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;
}
示例#14
0
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;
};
示例#16
0
	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;
	};
示例#17
0
/*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);
}
示例#18
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);
		}
示例#19
0
	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;
}
示例#21
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;
}
示例#23
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;
}
示例#24
0
/* 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;
}
示例#25
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);
}
示例#26
0
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;
}
示例#27
0
/* 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", &regs, 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", &regs, 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", &regs, 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", &regs, sizeof(regs));
	}
	else {
示例#30
0
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;
}