自学教程：C++ tag_size函数代码示例

/** Allocate from a fixed heap. * @param heap		Heap to allocate from. * @param size		Size of allocation to make. * @return		Pointer to allocation, or NULL if no space left. */void *fixed_heap_alloc(fixed_heap_t *heap, size_t size) {	fixed_heap_tag_t *tag, *other;	size_t total;	if(!size)		return NULL;	/* Minimum size and alignment of 8 bytes. */	total = round_up(size, 8) + sizeof(fixed_heap_tag_t);	/* Search for a free segment. */	for(tag = heap->tags; tag; tag = tag->next) {		if(tag_allocated(tag) || tag_size(tag) < total)			continue;		/* Found a suitable segment, chop it up if necessary (and if		 * there's enough room to do so). */		if(tag_size(tag) > total && (tag_size(tag) - total) > (sizeof(fixed_heap_tag_t) + 8)) {			other = (fixed_heap_tag_t *)((ptr_t)tag + total);			other->next = tag->next;			other->data = tag_size(tag) - total;			tag->next = other;			tag->data = total;		}		/* Mark as allocated. */		tag->data |= (1<<0);		return (void *)((ptr_t)tag + sizeof(fixed_heap_tag_t));	}	return NULL;}

void EAX_Decryption::finish(secure_vector<byte>& buffer, size_t offset){    BOTAN_ASSERT(buffer.size() >= offset, "Offset is sane");    const size_t sz = buffer.size() - offset;    byte* buf = buffer.data() + offset;    BOTAN_ASSERT(sz >= tag_size(), "Have the tag as part of final input");    const size_t remaining = sz - tag_size();    if(remaining)    {        m_cmac->update(buf, remaining);        m_ctr->cipher(buf, buf, remaining);    }    const byte* included_tag = &buf[remaining];    secure_vector<byte> mac = m_cmac->final();    mac ^= m_nonce_mac;    mac ^= m_ad_mac;    if(!same_mem(mac.data(), included_tag, tag_size()))        throw Integrity_Failure("EAX tag check failed");    buffer.resize(offset + remaining);}

/* * .KB_C_FN_DEFINITION_START * void InitTagList(char*, void *) *  This global function populates a linux-boot style tag list from the * string passed in the pointer at the location specified. * .KB_C_FN_DEFINITION_END */void InitTagList(char *parms, void *output) {	char *src, *dst;	struct tag *tagList = (struct tag*)output;	tagList->hdr.size  = tag_size(tag_core);	tagList->hdr.tag   = ATAG_CORE;	tagList->u.core.flags    = 1;	tagList->u.core.pagesize = PAGE_SIZE;	tagList->u.core.rootdev  = 0xff;	tagList = tag_next(tagList);	tagList->hdr.size  = tag_size(tag_mem32);	tagList->hdr.tag   = ATAG_MEM;	tagList->u.mem.size  = MEM_SIZE;	tagList->u.mem.start = PHYS_OFFSET;	tagList = tag_next(tagList);	tagList->hdr.size  = tag_size(tag_cmdline);	tagList->hdr.tag   = ATAG_CMDLINE;	src = parms;	dst = tagList->u.cmdline.cmdline;	while (*src) {		*dst++ = *src++;	}	*dst = 0;	tagList->hdr.size += ((unsigned)(src - parms) + 1) / sizeof(unsigned);	tagList = tag_next(tagList);	tagList->hdr.size  = 0;	tagList->hdr.tag   = ATAG_NONE;}

static void __initfixup_p720t(struct machine_desc *desc, struct tag *tag,	    char **cmdline, struct meminfo *mi){	/*	 * Our bootloader doesn't setup any tags (yet).	 */	if (tag->hdr.tag != ATAG_CORE) {		tag->hdr.tag = ATAG_CORE;		tag->hdr.size = tag_size(tag_core);		tag->u.core.flags = 0;		tag->u.core.pagesize = PAGE_SIZE;		tag->u.core.rootdev = 0x0100;		tag = tag_next(tag);		tag->hdr.tag = ATAG_MEM;		tag->hdr.size = tag_size(tag_mem32);		tag->u.mem.size = 4096;		tag->u.mem.start = PHYS_OFFSET;		tag = tag_next(tag);		tag->hdr.tag = ATAG_NONE;		tag->hdr.size = 0;	}}

/* * boot and execute the linux kernel * r0 = must contain a zero or else the kernel loops * r1 = architecture type * r2 = physical address of tagged list in system ram */static int bootlinux(int argc, char ** argv){	s32_t ret;	s32_t linux_mach_type, linux_kernel, linux_tag_placement;	struct machine * mach = get_machine();	struct tag * params;	s8_t *p;	s32_t i;	if(argc != 5)	{		printk("usage:/r/n    bootlinux <KERNEL ADDR> <PARAM ADDR> <MACH TYPE> <COMMAND LINE>/r/n");		return -1;	}	if(!mach)	{		printk("can not get machine information./r/n");		return -1;	}	linux_kernel = strtoul((const char *)argv[1], NULL, 0);	linux_tag_placement = strtoul((const char *)argv[2], NULL, 0);	linux_mach_type = strtoul((const char *)argv[3], NULL, 0);	/* setup linux kernel boot params */	params = (struct tag *)linux_tag_placement;	/* first tag */	params->hdr.tag = ATAG_CORE;	params->hdr.size = tag_size(tag_core);	params->u.core.flags = 0;	params->u.core.pagesize = 0;	params->u.core.rootdev = 0;	params = tag_next(params);	/* memory tags */	for(i = 0; i < ARRAY_SIZE(mach->res.mem_banks); i++)	{		if( (mach->res.mem_banks[i].start == 0) && (mach->res.mem_banks[i].end == 0) )			break;		params->hdr.tag = ATAG_MEM;		params->hdr.size = tag_size(tag_mem32);		params->u.mem.start = (u32_t)mach->res.mem_banks[i].start;		params->u.mem.size = (u32_t)(mach->res.mem_banks[i].end - mach->res.mem_banks[i].start + 1);		params = tag_next(params);	}	/* command line tags */	p = (s8_t *)argv[4];	if(p && strlen((const char *)p))	{		params->hdr.tag = ATAG_CMDLINE;		params->hdr.size = (sizeof (struct tag_header) + strlen((char *)p) + 1 + 4) >> 2;		strcpy((char *)(params->u.cmdline.cmdline), (char *)p);		params = tag_next (params);	}

void CCM_Decryption::finish(secure_vector<byte>& buffer, size_t offset)   {   BOTAN_ASSERT(buffer.size() >= offset, "Offset is sane");   buffer.insert(buffer.begin() + offset, msg_buf().begin(), msg_buf().end());   const size_t sz = buffer.size() - offset;   byte* buf = buffer.data() + offset;   BOTAN_ASSERT(sz >= tag_size(), "We have the tag");   const secure_vector<byte>& ad = ad_buf();   BOTAN_ASSERT(ad.size() % BS == 0, "AD is block size multiple");   const BlockCipher& E = cipher();   secure_vector<byte> T(BS);   E.encrypt(format_b0(sz - tag_size()), T);   for(size_t i = 0; i != ad.size(); i += BS)      {      xor_buf(T.data(), &ad[i], BS);      E.encrypt(T);      }   secure_vector<byte> C = format_c0();   secure_vector<byte> S0(BS);   E.encrypt(C, S0);   inc(C);   secure_vector<byte> X(BS);   const byte* buf_end = &buf[sz - tag_size()];   while(buf != buf_end)      {      const size_t to_proc = std::min<size_t>(BS, buf_end - buf);      E.encrypt(C, X);      xor_buf(buf, X.data(), to_proc);      inc(C);      xor_buf(T.data(), buf, to_proc);      E.encrypt(T);      buf += to_proc;      }   T ^= S0;   if(!same_mem(T.data(), buf_end, tag_size()))      throw Integrity_Failure("CCM tag check failed");   buffer.resize(buffer.size() - tag_size());   }

void setup_board_tags(struct tag **tmp){	struct tag *params = *tmp;	struct tag_asv_margin *t;	char *p = getenv("margin");	char *s = p;	int value = 0;	int minus = 0, percent = 0;	s = strchr(s, '-');	if (s)		minus = true;	else		s = strchr(s, '+');	if (!s)		s = p;	else		s++;	if (strchr(p, '%'))		percent = 1;	value = simple_strtol(s, NULL, 10);	printf("ASV Margin:%s%d%s/n", minus?"-":"+", value, percent?"%":"mV");	/* set ARM margin */	params->hdr.tag = ATAG_ARM_MARGIN;	params->hdr.size = tag_size(tag_asv_margin);	t = (struct tag_asv_margin *)&params->u;	t->value = value;	t->minus = minus;	t->percent = percent;	params = tag_next(params);	*tmp = params;	/* set ARM margin */	params = *tmp;	params->hdr.tag = ATAG_CORE_MARGIN;	params->hdr.size = tag_size(tag_asv_margin);	t = (struct tag_asv_margin *)&params->u;	t->value = value;	t->minus = minus;	t->percent = percent;	params = tag_next(params);	*tmp = params;}

/*  * build_params -- set up parameters for the kernel uImage  */static void build_params(char *cmdline, struct tag *params){	char *p;	/* 	 * set up the core tag 	 */	params->hdr.tag = ATAG_CORE;	params->hdr.size = tag_size(tag_core);	params->u.core.flags = 0;	params->u.core.pagesize = 0;	params->u.core.rootdev = 0;	params = tag_next(params);	/* 	 * set up the memory tags	 * Note: there should be one ATAG_MEM per memory bank, we have only one	 *       bank at this time.	 */	params->hdr.tag = ATAG_MEM;	params->hdr.size = tag_size(tag_mem32);	params->u.mem.start = SDRAM_START;	params->u.mem.size = SDRAM_SIZE;	params = tag_next(params);	/* 	 * set up the kernel command line tag 	 */	if(cmdline == 0)		goto END_TAG;		/* eat leading spaces */	for(p = cmdline; *p == ' '; p++);	if(*p == '/0')		goto END_TAG;	params->hdr.tag = ATAG_CMDLINE;	params->hdr.size = (sizeof(struct tag_header) + strlen(p) + 1 + 4) >> 2;	strcpy(params->u.cmdline.cmdline, p);	params = tag_next(params);	/*	 * set up the end tag	 */END_TAG:	params->hdr.tag = ATAG_NONE;	params->hdr.size = 0;}

static void setup_videolfb_tag (gd_t *gd){	/* An ATAG_VIDEOLFB node tells the kernel where and how large	 * the framebuffer for video was allocated (among other things).	 * Note that a _physical_ address is passed !	 *	 * We only use it to pass the address and size, the other entries	 * in the tag_videolfb are not of interest.	 */	params->hdr.tag = ATAG_VIDEOLFB;	params->hdr.size = tag_size (tag_videolfb);	if(g_boot_mode == FACTORY_BOOT)	{	  	  params->u.videolfb.lfb_base = (u32) gd->fb_base - 0x9600000;	  	  memcpy((char *)(params->u.videolfb.lfb_base), (char *)gd->fb_base, mt65xx_disp_get_vram_size());	  printf("[UBOOT Factory]fb addr = %x/n", params->u.videolfb.lfb_base);	}	else	{  	params->u.videolfb.lfb_base = (u32) gd->fb_base;	}	/* Fb size is calculated according to parameters for our panel	 */	//params->u.videolfb.lfb_size = calc_fbsize();	params->u.videolfb.lfb_size = mt65xx_disp_get_vram_size();	params = tag_next (params);}

void *atag_build() {  struct memory_image image;  struct tag *tag = (struct tag*)ATAG_BASE_ADDR;  printf("building atags/n");	  tag->hdr.tag = ATAG_CORE;  tag->hdr.size = tag_size (tag_core);  tag->u.core.flags = 0;  tag->u.core.pagesize = 0x00001000;  tag->u.core.rootdev = 0x0000;  tag = tag_next(tag);  if (image_find(IMG_CMDLINE, &image) != NULL) {    char *atag_cmdline = tag->u.cmdline.cmdline;    tag->hdr.tag = ATAG_CMDLINE;    tag->hdr.size = (sizeof(struct tag_header) + image.size + 1 + 3) >> 2;    memcpy(atag_cmdline, image.data, image.size);    if (atag_cmdline[image.size-1] == '/xa') {      atag_cmdline[image.size-1] = '/0';    } else {      atag_cmdline[image.size] = '/0';    }   printf("cmdline found[%s]/n", atag_cmdline);    tag = tag_next(tag);  }

/* productid tag (alphanumeric strings) */void setup_productid_tag(struct tag **in_params){#ifdef CONFIG_ENABLE_IDME    char pid_buf[IDME_MAX_PRODUCT_ID_LEN+1];    unsigned long count = 0;    memset(pid_buf, 0, IDME_MAX_PRODUCT_ID_LEN+1);    if (idme_get_var("pid", pid_buf, sizeof(pid_buf))){            printf("Error, failed to get the pid/n");            return;    }    printf("pid: %s/n",pid_buf);    params->hdr.tag = ATAG_PRODUCTID;    params->hdr.size = tag_size (tag_productid);    memcpy (params->u.productid.pid,            pid_buf,            sizeof params->u.productid.pid);    params = tag_next (params);#endif}

static void *make_taglist(int initrd_size) {        void *taglist;        struct tag *t;        int i;        unsigned long mem_start = 0x30000000;        unsigned long mem_size = 0x01000000; //(unsigned long)__virt_to_phys(high_memory);        if (!(t = taglist = kmalloc(MIN_SEGMENT_SIZE, GFP_KERNEL)))                panic("make_taglist: Out of memory/n");        t->hdr.tag = ATAG_CORE;        t->hdr.size = tag_size(tag_core);        t->u.core.flags = 1;        t->u.core.pagesize = PAGE_SIZE;        t->u.core.rootdev = 0x0; //0x00010000lu;        printk("CMDLINE: %s/n", cmdline);        t = tag_next(t);        i = strlen(cmdline)+1;        t->hdr.size = (sizeof(struct tag_header) + i+3) >> 2;        t->hdr.tag = ATAG_CMDLINE;        strcpy(t->u.cmdline.cmdline, cmdline);        printk("MEM: start %08lx size %luMB/n", mem_start, mem_size >> 20);        t = tag_next(t);        t->hdr.size = tag_size(tag_mem32);        t->hdr.tag = ATAG_MEM;        t->u.mem.size = mem_size;        t->u.mem.start = mem_start;        if (initrd_size > 0) {                printk("INITRD: start %08lx size %d/n", 0x30400000lu, initrd_size);                t = tag_next(t);                t->hdr.size = tag_size(tag_initrd);                t->hdr.tag = ATAG_INITRD2;                t->u.initrd.start = 0x30400000;                t->u.initrd.size = initrd_size;        }        t = tag_next(t);        t->hdr.size = 0;        t->hdr.tag = ATAG_NONE;        return taglist;}

static void setup_modelid_tag(struct tag **in_params){	u32 modelid = get_modelid();	params->hdr.tag = ATAG_MODELID;	params->hdr.size = tag_size (tag_modelid);	params->u.modelid.id = modelid;	params = tag_next (params);}

unsigned *target_atag_boot(unsigned *ptr){  *ptr++ = tag_size(tag_boot);  *ptr++ = ATAG_BOOT;  *ptr++ = g_boot_mode;    return ptr;}

static void __initfixup_cep(struct machine_desc *desc, struct param_struct *params,	      char **cmdline, struct meminfo *mi){	struct tag *t = (struct tag *)params;	/*	 * Apparantly bootldr uses a param_struct.  Groan.	 */	if (t->hdr.tag != ATAG_CORE)		convert_to_tag_list(params, 1);	if (t->hdr.tag != ATAG_CORE) {		t->hdr.tag = ATAG_CORE;		t->hdr.size = tag_size(tag_core);		t->u.core.flags = 0;		t->u.core.pagesize = PAGE_SIZE;		t->u.core.rootdev = RAMDISK_MAJOR << 8 | 0;		t = tag_next(t);		t->hdr.tag = ATAG_MEM;		t->hdr.size = tag_size(tag_mem32);		t->u.mem.start = 0xc0000000;		t->u.mem.size  = 32 * 1024 * 1024;		t = tag_next(t);		t->hdr.tag = ATAG_RAMDISK;		t->hdr.size = tag_size(tag_ramdisk);		t->u.ramdisk.flags = 1;		t->u.ramdisk.size = 8192;		t->u.ramdisk.start = 0;		t = tag_next(t);		t->hdr.tag = ATAG_INITRD;		t->hdr.size = tag_size(tag_initrd);		t->u.initrd.start = 0xc0800000;		t->u.initrd.size = 3 * 1024 * 1024;		t = tag_next(t);		t->hdr.tag = ATAG_NONE;		t->hdr.size = 0;	}}

static void setup_modelid_tag(struct tag **in_params){	u32 modelid = 99;	params->hdr.tag = ATAG_MODELID;	SEC_ENTRY_Std_Ppa_Call ( PPA_SERV_HAL_BN_MODELID , 1 , &modelid );	params->hdr.size = tag_size (tag_modelid);	params->u.modelid.id = modelid;	params = tag_next (params);}

void setup_boot_tag (BOOTMODE boot_mode){	params->hdr.tag = ATAG_BOOT;	params->hdr.size = tag_size (tag_boot);	params->u.boot.bootmode = boot_mode;	params = tag_next (params);	printf("boot mode = %d/n",boot_mode);}

static struct tag *setup_boardinfo_tag(struct tag *params){	params->hdr.tag = ATAG_BOARDINFO;	params->hdr.size = tag_size(tag_boardinfo);	params->u.boardinfo.board_number = gd->bd->bi_board_number;	return tag_next(params);}

static void setup_tag_revision(u32 rev){	params->hdr.tag = ATAG_REVISION;	params->hdr.size = tag_size(tag_revision);	params->u.revision.rev = rev;	params = tag_next(params);}

static struct tag * __init memtag(struct tag *tag, unsigned long start, unsigned long size){	tag = tag_next(tag);	tag->hdr.tag = ATAG_MEM;	tag->hdr.size = tag_size(tag_mem32);	tag->u.mem.size = size;	tag->u.mem.start = start;	return tag;}

void EAX_Encryption::finish(secure_vector<byte>& buffer, size_t offset){    update(buffer, offset);    secure_vector<byte> data_mac = m_cmac->final();    xor_buf(data_mac, m_nonce_mac, data_mac.size());    xor_buf(data_mac, m_ad_mac, data_mac.size());    buffer += std::make_pair(data_mac.data(), tag_size());}

void setup_memory_tags(void){    params->hdr.tag = ATAG_MEM;    params->hdr.size = tag_size(tag_mem32);    params->u.mem.start = 0x30000000;    params->u.mem.size = 64*1024*1024;    params = tag_next(params);}

static void setup_serialnr_tag(u32 hdrtag, u32 low, u32 high){	params->hdr.tag = hdrtag;	params->hdr.size = tag_size(tag_serialnr);	params->u.serialnr.low = low;	params->u.serialnr.high = high;	params = tag_next(params);}

static void setup_initrd_tag(u32 start, u32 size){	params->hdr.tag = ATAG_INITRD2;	params->hdr.size = tag_size(tag_initrd);	params->u.initrd.start = start;	params->u.initrd.size = size;	params = tag_next(params);}

static void setup_mem_tag(u32 hdrtag, u32 start, u32 len){	params->hdr.tag = hdrtag;	params->hdr.size = tag_size(tag_mem32);	params->u.mem.start = start;	params->u.mem.size = len;	params = tag_next(params);}

unsigned *target_atag_meta(unsigned *ptr){  *ptr++ = tag_size(tag_meta_com);  *ptr++ = ATAG_META_COM;  *ptr++ = g_boot_arg->meta_com_type;  *ptr++ = g_boot_arg->meta_com_id;  printf("meta com type = %d/n", g_boot_arg->meta_com_type);  printf("meta com id = %d/n", g_boot_arg->meta_com_id);  return ptr;}

void setup_mem_tag(){     pCurTag->hdr.tag = ATAG_MEM;     pCurTag->hdr.size = tag_size(tag_mem32);           pCurTag->u.mem.start = SDRAM_ADDR_START;     pCurTag->u.mem.size = SDRAM_TOTAL_SIZE;          pCurTag = tag_next(pCurTag);}

static void setup_marvell_tag (void){	params->hdr.tag = ATAG_MARVELL;	params->hdr.size = tag_size (tag_mv_uboot);	params->u.mv_uboot.uboot_version = VER_NUM;	memcpy(&(params->u.mv_uboot.mv_dram_init), &mv_dram_init, sizeof(MV_DRAM_INIT));	params = tag_next (params);}	

static void setup_mem_tag(uint32 start, uint32 len){    params->hdr.tag = ATAG_MEM;             /* Memory tag */    params->hdr.size = tag_size(atag_mem);  /* size tag */    params->u.mem.start = start;            /* Start of memory area (physical address) */    params->u.mem.size = len;               /* Length of area */    params = tag_next(params);              /* move pointer to next tag */}

void setup_mem_tag(){	params->hdr.size = tag_size(tag_mem32);	params->hdr.tag = ATAG_MEM;	//表示内存	params->u.mem.start = 0x20000000;	//内存起始地址	params->u.mem.size = 1024*1024*1024;	params = tag_next(params);}