int send_and_recv_header(const char *ip, mode_t mode, char **header, char *txt) { char *hdr = malloc(2000 * sizeof(char)); if ( hdr == NULL ) { return -1; } socket_client_t *client = malloc(sizeof(socket_client_t)); if ( client == NULL ) { fprintf(stderr, "malloc failed\n"); free(hdr); return -1; } if ( socket_client_new(client, ip) == -1 ) { free(hdr); socket_client_free(client); return -1; } if ( socket_client_connect(client) == -1 ) { free(hdr); socket_client_free(client); return -1; } if ( mode ) hdr = build_header(mode, txt); else hdr = build_header(mode, "None"); if ( socket_client_send(client->socket_cli, hdr) == -1 ) { free(hdr); socket_client_free(client); return -1; } if ( socket_client_recv(client->socket_cli, &hdr) == -1 ) { free(hdr); socket_client_free(client); return -1; } *header = strdup(hdr); socket_client_free(client); free(hdr); return 0; }
bool mail_attach::save_to(mime_code* coder, string& out) { if (coder) build_header(coder->get_encoding_type(), out); else build_header(NULL, out); string buf; if (ifstream::load(filepath_.c_str(), &buf) == false) { logger_error("load %s error %s", filepath_.c_str(), last_serror()); return false; } if (coder) { coder->reset(); coder->encode_update(buf.c_str(), (int) buf.size(), &out); coder->encode_finish(&out); } else out.append(buf); return true; }
/* FADT */ static void build_fadt(GArray *table_data, GArray *linker, AcpiPmInfo *pm, unsigned facs, unsigned dsdt) { AcpiFadtDescriptorRev1 *fadt = acpi_data_push(table_data, sizeof(*fadt)); fadt->firmware_ctrl = cpu_to_le32(facs); /* FACS address to be filled by Guest linker */ bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, ACPI_BUILD_TABLE_FILE, table_data, &fadt->firmware_ctrl, sizeof fadt->firmware_ctrl); fadt->dsdt = cpu_to_le32(dsdt); /* DSDT address to be filled by Guest linker */ bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, ACPI_BUILD_TABLE_FILE, table_data, &fadt->dsdt, sizeof fadt->dsdt); fadt_setup(fadt, pm); build_header(linker, table_data, (void *)fadt, ACPI_FACP_SIGNATURE, sizeof(*fadt), 1); }
/* size and flags are useful only for setxattr. for getxattr they can * be just set to 0 */ unsigned int build_xattr(corefs_packet * packet, unsigned int type, const char * name, const char *path, int size, int flags){ unsigned int pathlen; unsigned int namelen; build_header(packet, COREFS_REQUEST); packet->payload.request.type = COREFS_REQUEST_XATTR; corefs_xattr * xattr = (corefs_xattr*)&(packet->payload.request.op.xattr); xattr->type = type; xattr->flags = flags; pathlen = size; xattr->sizeofvalue = pathlen; pathlen = strlen(path); xattr->pathlen = pathlen; if(name) namelen = strlen(name); else namelen = 0; xattr->namelen = namelen; strcpy((char*)xattr->params,path); if(name) strcpy((char*)xattr->params+pathlen+1,name); // format: path || attribute name packet->header.payload_size = REQUEST_BASE_SIZE(packet->payload.request) + SIZEOF_XATTR((*xattr)); dprintf(stderr, "build_xattr payload_size %u pathlen %u , namelen%u\n", packet->header.payload_size, pathlen, namelen); dprintf(stderr, "build_xattr header_size %u\n", header_size); return packet->header.payload_size + SIZEOF_HEADER(packet->header); }
/* Build rsdt table */ void build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, const char *oem_id, const char *oem_table_id) { int i; unsigned rsdt_entries_offset; AcpiRsdtDescriptorRev1 *rsdt; const unsigned table_data_len = (sizeof(uint32_t) * table_offsets->len); const unsigned rsdt_entry_size = sizeof(rsdt->table_offset_entry[0]); const size_t rsdt_len = sizeof(*rsdt) + table_data_len; rsdt = acpi_data_push(table_data, rsdt_len); rsdt_entries_offset = (char *)rsdt->table_offset_entry - table_data->data; for (i = 0; i < table_offsets->len; ++i) { uint32_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i); uint32_t rsdt_entry_offset = rsdt_entries_offset + rsdt_entry_size * i; /* rsdt->table_offset_entry to be filled by Guest linker */ bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, rsdt_entry_offset, rsdt_entry_size, ACPI_BUILD_TABLE_FILE, ref_tbl_offset); } build_header(linker, table_data, (void *)rsdt, "RSDT", rsdt_len, 1, oem_id, oem_table_id); }
bool Th105DataArchiveExtractor::write_header(std::vector<FileInfo> &file_list, FILE *fp) { if(fp == NULL) { return false; } const unsigned short file_count = file_list.size(); unsigned int header_size; if(!calc_header_size(header_size, file_list)) { return false; } fseek(fp, 0, SEEK_SET); if(fwrite(&file_count, 2, 1, fp) != 1) { return false; } if(fwrite(&header_size, 4, 1, fp) != 1) { return false; } if(file_list.empty()) { return true; } std::vector<unsigned char> header(header_size); if(!build_header(header, file_list)) { return false; } if(!header_encrypt(header, 6 + header_size, 0xC5, 0x83, 0x53)) { return false; } if(fwrite(&header.front(), 1, header_size, fp) != header_size) { return false; } return true; }
/* * Send an Amanda dump header to the output file and set file->blocksize */ static ssize_t write_header( XferDestHolding *self, int fd) { char *buffer; size_t written; self->chunk_header->blocksize = HEADER_BLOCK_BYTES; if (debug_chunker > 1) dump_dumpfile_t((dumpfile_t *)self->chunk_header); buffer = build_header((dumpfile_t *)self->chunk_header, NULL, HEADER_BLOCK_BYTES); if (!buffer) /* this shouldn't happen */ error(_("header does not fit in %zd bytes"), (size_t)HEADER_BLOCK_BYTES); written = db_full_write(fd, buffer, HEADER_BLOCK_BYTES); g_free(buffer); if(written == HEADER_BLOCK_BYTES) return HEADER_BLOCK_BYTES; /* fake ENOSPC when we get a short write without errno set */ if(errno == 0) errno = ENOSPC; return (ssize_t)-1; }
/* * Send an Amanda dump header to the output file and set file->blocksize */ static ssize_t write_tapeheader( int outfd, dumpfile_t *file) { char *buffer; size_t written; file->blocksize = DISK_BLOCK_BYTES; if (debug_chunker > 1) dump_dumpfile_t(file); buffer = build_header(file, NULL, DISK_BLOCK_BYTES); if (!buffer) /* this shouldn't happen */ error(_("header does not fit in %zd bytes"), (size_t)DISK_BLOCK_BYTES); written = full_write(outfd, buffer, DISK_BLOCK_BYTES); amfree(buffer); if(written == DISK_BLOCK_BYTES) return 0; /* fake ENOSPC when we get a short write without errno set */ if(errno == 0) errno = ENOSPC; return (ssize_t)-1; }
static void build_spcr(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info) { AcpiSerialPortConsoleRedirection *spcr; const MemMapEntry *uart_memmap = &guest_info->memmap[VIRT_UART]; int irq = guest_info->irqmap[VIRT_UART] + ARM_SPI_BASE; spcr = acpi_data_push(table_data, sizeof(*spcr)); spcr->interface_type = 0x3; /* ARM PL011 UART */ spcr->base_address.space_id = AML_SYSTEM_MEMORY; spcr->base_address.bit_width = 8; spcr->base_address.bit_offset = 0; spcr->base_address.access_width = 1; spcr->base_address.address = cpu_to_le64(uart_memmap->base); spcr->interrupt_types = (1 << 3); /* Bit[3] ARMH GIC interrupt */ spcr->gsi = cpu_to_le32(irq); /* Global System Interrupt */ spcr->baud = 3; /* Baud Rate: 3 = 9600 */ spcr->parity = 0; /* No Parity */ spcr->stopbits = 1; /* 1 Stop bit */ spcr->flowctrl = (1 << 1); /* Bit[1] = RTS/CTS hardware flow control */ spcr->term_type = 0; /* Terminal Type: 0 = VT100 */ spcr->pci_device_id = 0xffff; /* PCI Device ID: not a PCI device */ spcr->pci_vendor_id = 0xffff; /* PCI Vendor ID: not a PCI device */ build_header(linker, table_data, (void *)spcr, "SPCR", sizeof(*spcr), 2, NULL, NULL); }
static void build_mcfg_q35(GArray *table_data, GArray *linker, AcpiMcfgInfo *info) { AcpiTableMcfg *mcfg; uint32_t sig; int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]); mcfg = acpi_data_push(table_data, len); mcfg->allocation[0].address = cpu_to_le64(info->mcfg_base); /* Only a single allocation so no need to play with segments */ mcfg->allocation[0].pci_segment = cpu_to_le16(0); mcfg->allocation[0].start_bus_number = 0; mcfg->allocation[0].end_bus_number = PCIE_MMCFG_BUS(info->mcfg_size - 1); /* MCFG is used for ECAM which can be enabled or disabled by guest. * To avoid table size changes (which create migration issues), * always create the table even if there are no allocations, * but set the signature to a reserved value in this case. * ACPI spec requires OSPMs to ignore such tables. */ if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) { sig = ACPI_RSRV_SIGNATURE; } else { sig = ACPI_MCFG_SIGNATURE; } build_header(linker, table_data, (void *)mcfg, sig, len, 1); }
unsigned int build_status(corefs_packet* packet, unsigned int status, unsigned int type) { build_header(packet, COREFS_RESPONSE); packet->header.payload_size=SIZEOF_STATUS(packet->payload.response.rop.status) + RESPONSE_BASE_SIZE(packet->payload.response); packet->payload.response.type = type; packet->payload.response.rop.status.bits=status; return header_size + SIZEOF_STATUS(packet->payload.response.rop.status) + RESPONSE_BASE_SIZE(packet->payload.response); }
// returns total packet size unsigned int build_request_data(corefs_packet* packet, const char* data, size_t size) { build_header(packet, COREFS_REQUEST); packet->header.payload_size = size + REQUEST_BASE_SIZE(packet->payload.request); packet->payload.request.type = COREFS_REQUEST_DATA; memmove(packet->payload.request.op.raw, data, size); return SIZEOF_HEADER(packet->header) + packet->header.payload_size; }
char * add_header(char * header_type, char * header_content, char * content){ char * header = build_header(header_type, header_content); char * new_str = (char * ) malloc((int)strlen(header) + (int)strlen(content) + 1); sprintf(new_str, "%s%s", header, content); free(header); return new_str; }
char * add_header(const char * header_type, const char * header_content, char * content){ char * header = build_header(header_type, header_content); char * new_str = malloc(strlen(header) + strlen(content) + 4); sprintf(new_str, "%s%s", header, content); //printf("Size of header: %d, sizeof content, %d, sizeof new_str: %d\n", (int)strlen(header),(int)strlen(content),(int)strlen(new_str)); free(header); return new_str; }
unsigned int build_response_with_moredata(corefs_packet* packet, const char* data, size_t size, unsigned int offset) { build_header(packet, COREFS_RESPONSE); packet->header.payload_size = size + RESPONSE_BASE_SIZE(packet->payload.response); packet->payload.response.type = COREFS_RESPONSE_MOREDATA; packet->payload.response.more_offset = offset; memcpy(packet->payload.response.rop.raw, data, size); return SIZEOF_HEADER(packet->header) + packet->header.payload_size; }
/* MADT */ static void build_madt(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info) { int madt_start = table_data->len; const MemMapEntry *memmap = guest_info->memmap; const int *irqmap = guest_info->irqmap; AcpiMultipleApicTable *madt; AcpiMadtGenericDistributor *gicd; AcpiMadtGenericMsiFrame *gic_msi; int i; madt = acpi_data_push(table_data, sizeof *madt); gicd = acpi_data_push(table_data, sizeof *gicd); gicd->type = ACPI_APIC_GENERIC_DISTRIBUTOR; gicd->length = sizeof(*gicd); gicd->base_address = memmap[VIRT_GIC_DIST].base; for (i = 0; i < guest_info->smp_cpus; i++) { AcpiMadtGenericInterrupt *gicc = acpi_data_push(table_data, sizeof *gicc); ARMCPU *armcpu = ARM_CPU(qemu_get_cpu(i)); gicc->type = ACPI_APIC_GENERIC_INTERRUPT; gicc->length = sizeof(*gicc); if (guest_info->gic_version == 2) { gicc->base_address = memmap[VIRT_GIC_CPU].base; } gicc->cpu_interface_number = i; gicc->arm_mpidr = armcpu->mp_affinity; gicc->uid = i; gicc->flags = cpu_to_le32(ACPI_GICC_ENABLED); } if (guest_info->gic_version == 3) { AcpiMadtGenericRedistributor *gicr = acpi_data_push(table_data, sizeof *gicr); gicr->type = ACPI_APIC_GENERIC_REDISTRIBUTOR; gicr->length = sizeof(*gicr); gicr->base_address = cpu_to_le64(memmap[VIRT_GIC_REDIST].base); gicr->range_length = cpu_to_le32(memmap[VIRT_GIC_REDIST].size); } else { gic_msi = acpi_data_push(table_data, sizeof *gic_msi); gic_msi->type = ACPI_APIC_GENERIC_MSI_FRAME; gic_msi->length = sizeof(*gic_msi); gic_msi->gic_msi_frame_id = 0; gic_msi->base_address = cpu_to_le64(memmap[VIRT_GIC_V2M].base); gic_msi->flags = cpu_to_le32(1); gic_msi->spi_count = cpu_to_le16(NUM_GICV2M_SPIS); gic_msi->spi_base = cpu_to_le16(irqmap[VIRT_GIC_V2M] + ARM_SPI_BASE); } build_header(linker, table_data, (void *)(table_data->data + madt_start), "APIC", table_data->len - madt_start, 3, NULL, NULL); }
clientWindowSeg* createWindowSeg() { clientWindowSeg* currentSegment = (clientWindowSeg*)malloc(sizeof(clientWindowSeg)); currentSegment->isReceived=0; currentSegment->header=build_header(0,0,0,0,0,0); memset(currentSegment->data,0,488); currentSegment->serverSeqNo=0; currentSegment->next=NULL; return currentSegment; }
hdr populateClientBuffer(int previousAckNo,int slidingWindowSize,char *Message,hdr recvHeader, sharedBuf *buffer, int *isDone){ hdr replyHeader; int diff,i,currentWindowSize,currentServerSeqNo,ack; currentServerSeqNo = ntohs(recvHeader.seq); //printf("\nThe current Server sequence number is %d\n",ntohs(recvHeader.seq)); pthread_mutex_lock(&buffer->mutex); if(buffer->head == NULL) { buffer->head =createWindowSeg(); buffer->tail = buffer->head ; buffer->head ->serverSeqNo = previousAckNo; } if(buffer->head->serverSeqNo > currentServerSeqNo) { currentWindowSize = findWindowSize(slidingWindowSize, buffer); replyHeader = build_header(0,buffer->head->serverSeqNo,0,0,currentWindowSize,0); pthread_mutex_unlock(&buffer->mutex); return replyHeader; } diff = currentServerSeqNo-buffer->head ->serverSeqNo; if(diff > slidingWindowSize) { printf("diff and SlidingWindowSizes are %d %d \n",diff, slidingWindowSize); printf("Sever is Malfunctioning, sent packets more than the window size \n"); exit(3); } currentWindowSize = buffer->tail->serverSeqNo - buffer->head ->serverSeqNo; if(diff<currentWindowSize ) { fillInTheMiddle(recvHeader, Message, diff, buffer); } else { extendWindow(recvHeader, Message, buffer); } currentWindowSize = findWindowSize(slidingWindowSize, buffer); ack = findACK(slidingWindowSize, buffer); replyHeader = build_header(0,ack,0,0,currentWindowSize,0); buffer->currentSize = slidingWindowSize-currentWindowSize; (*isDone) = isFinSetForLastPacket(buffer); printCurrentBuffer(buffer); pthread_mutex_unlock(&buffer->mutex); return replyHeader; }
void handler_page(const ByteString_t & _path_info) { ByteString_t name(_path_info.array() + 1, _path_info.length() - 1); name.append('\0'); ByteString_t wiki; wiki_storage->get(name.array(), &wiki); build_header(_path_info); build_wiki(wiki); build_footer(); }
static void build_dsdt(GArray *table_data, GArray *linker, AcpiMiscInfo *misc) { AcpiTableHeader *dsdt; assert(misc->dsdt_code && misc->dsdt_size); dsdt = acpi_data_push(table_data, misc->dsdt_size); memcpy(dsdt, misc->dsdt_code, misc->dsdt_size); memset(dsdt, 0, sizeof *dsdt); build_header(linker, table_data, dsdt, ACPI_DSDT_SIGNATURE, misc->dsdt_size, 1); }
static void build_hpet(GArray *table_data, GArray *linker) { Acpi20Hpet *hpet; hpet = acpi_data_push(table_data, sizeof(*hpet)); /* Note timer_block_id value must be kept in sync with value advertised by * emulated hpet */ hpet->timer_block_id = cpu_to_le32(0x8086a201); hpet->addr.address = cpu_to_le64(HPET_BASE); build_header(linker, table_data, (void *)hpet, ACPI_HPET_SIGNATURE, sizeof(*hpet), 1); }
static void __gre_xmit(struct sk_buff *skb, struct net_device *dev, const struct iphdr *tnl_params, __be16 proto) { struct ip_tunnel *tunnel = netdev_priv(dev); if (tunnel->parms.o_flags & TUNNEL_SEQ) tunnel->o_seqno++; /* Push GRE header. */ build_header(skb, tunnel->tun_hlen, tunnel->parms.o_flags, proto, tunnel->parms.o_key, htonl(tunnel->o_seqno)); skb_set_inner_protocol(skb, proto); ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol); }
BONFIRE_MAIN() { //uart_puts("Node 2 started.\n") int test = 0; BONFIRE_LOOP() { bonfire_send(build_header(0,3)); test++; bonfire_send(test); test++; bonfire_send(test); } BONFIRE_RET(); }
/** * Allocate message and store data there */ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t length ) { if ( !session ) { LOGGER_WARNING("No session!"); return NULL; } uint8_t *from_pos; RTPMessage *retu = calloc(1, sizeof (RTPMessage)); if ( !retu ) { LOGGER_WARNING("Alloc failed! Program might misbehave!"); return NULL; } /* Sets header values and copies the extension header in retu */ retu->header = build_header ( session ); /* It allocates memory and all */ retu->ext_header = session->ext_header; uint32_t total_length = length + retu->header->length + 1; retu->data[0] = session->prefix; if ( retu->ext_header ) { total_length += ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 ); from_pos = add_header ( retu->header, retu->data + 1 ); from_pos = add_ext_header ( retu->ext_header, from_pos + 1 ); } else { from_pos = add_header ( retu->header, retu->data + 1 ); } /* * Parses the extension header into the message * Of course if any */ /* Appends data on to retu->data */ memcpy ( from_pos, data, length ); retu->length = total_length; retu->next = NULL; return retu; }
int main(int argc, char const *argv[]) { unsigned destination = 0; unsigned flit_number = 0; unsigned flit; unsigned packet_counter = 0; setup_uart(CPU_SPEED, UART_BAUDRATE); uart_puts("UART TEST: If you can read this, then UART output works!\n"); while(1){ if ((ni_read_flags() & NI_READ_MASK) == 0) { flit = ni_read(); }else if((ni_read_flags() & NI_WRITE_MASK) == 0 && packet_counter < 100) { flit_number ++; if (flit_number == 1){ ni_write(build_header(destination, 3)); destination ++; if (destination == MY_ADDR){ destination ++; } if (destination == 4){ destination = 0; } }else if (flit_number == 3){ ni_write(0); flit_number = 0; packet_counter ++; }else{ ni_write(0b1111111111111111111111111111); } } if (packet_counter >= 100){ while ((ni_read_flags() & NI_READ_MASK) == 0){ flit = ni_read(); } uart_puts("finished sending packets!\n"); break; } } /* Run CPU test */ test_plasma_funcitons(); return 0; }
static void nvdimm_build_nfit(GSList *device_list, GArray *table_offsets, GArray *table_data, GArray *linker) { GArray *structures = nvdimm_build_device_structure(device_list); void *header; acpi_add_table(table_offsets, table_data); /* NFIT header. */ header = acpi_data_push(table_data, sizeof(NvdimmNfitHeader)); /* NVDIMM device structures. */ g_array_append_vals(table_data, structures->data, structures->len); build_header(linker, table_data, header, "NFIT", sizeof(NvdimmNfitHeader) + structures->len, 1, NULL); g_array_free(structures, true); }
static void build_mcfg(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info) { AcpiTableMcfg *mcfg; const MemMapEntry *memmap = guest_info->memmap; int len = sizeof(*mcfg) + sizeof(mcfg->allocation[0]); mcfg = acpi_data_push(table_data, len); mcfg->allocation[0].address = cpu_to_le64(memmap[VIRT_PCIE_ECAM].base); /* Only a single allocation so no need to play with segments */ mcfg->allocation[0].pci_segment = cpu_to_le16(0); mcfg->allocation[0].start_bus_number = 0; mcfg->allocation[0].end_bus_number = (memmap[VIRT_PCIE_ECAM].size / PCIE_MMCFG_SIZE_MIN) - 1; build_header(linker, table_data, (void *)mcfg, "MCFG", len, 1, NULL, NULL); }
static void nvdimm_build_nfit(AcpiNVDIMMState *state, GArray *table_offsets, GArray *table_data, BIOSLinker *linker) { NvdimmFitBuffer *fit_buf = &state->fit_buf; unsigned int header; acpi_add_table(table_offsets, table_data); /* NFIT header. */ header = table_data->len; acpi_data_push(table_data, sizeof(NvdimmNfitHeader)); /* NVDIMM device structures. */ g_array_append_vals(table_data, fit_buf->fit->data, fit_buf->fit->len); build_header(linker, table_data, (void *)(table_data->data + header), "NFIT", sizeof(NvdimmNfitHeader) + fit_buf->fit->len, 1, NULL, NULL); }
/* Assumes that the user info is already intialized before calling * this function. Returns total packet size. */ unsigned int build_fileop(corefs_packet* packet, unsigned int type, unsigned int offset, unsigned int size, const char* path) { unsigned int pathlen; build_header(packet,COREFS_REQUEST); packet->payload.request.type = COREFS_REQUEST_FILEOP; packet->payload.request.op.fileop.type = type; packet->payload.request.op.fileop.offset=offset; packet->payload.request.op.fileop.size=size; pathlen=strlen(path); packet->payload.request.op.fileop.pathlen = pathlen; strcpy((char*)packet->payload.request.op.fileop.path, path); packet->header.payload_size = REQUEST_BASE_SIZE(packet->payload.request) + SIZEOF_FILEOP_NOPATH(packet->payload.request.op.fileop) + pathlen; return packet->header.payload_size + SIZEOF_HEADER(packet->header); }
static void build_srat(GArray *table_data, BIOSLinker *linker, VirtGuestInfo *guest_info) { AcpiSystemResourceAffinityTable *srat; AcpiSratProcessorGiccAffinity *core; AcpiSratMemoryAffinity *numamem; int i, j, srat_start; uint64_t mem_base; uint32_t *cpu_node = g_malloc0(guest_info->smp_cpus * sizeof(uint32_t)); for (i = 0; i < guest_info->smp_cpus; i++) { j = numa_get_node_for_cpu(i); if (j < nb_numa_nodes) { cpu_node[i] = j; } } srat_start = table_data->len; srat = acpi_data_push(table_data, sizeof(*srat)); srat->reserved1 = cpu_to_le32(1); for (i = 0; i < guest_info->smp_cpus; ++i) { core = acpi_data_push(table_data, sizeof(*core)); core->type = ACPI_SRAT_PROCESSOR_GICC; core->length = sizeof(*core); core->proximity = cpu_to_le32(cpu_node[i]); core->acpi_processor_uid = cpu_to_le32(i); core->flags = cpu_to_le32(1); } g_free(cpu_node); mem_base = guest_info->memmap[VIRT_MEM].base; for (i = 0; i < nb_numa_nodes; ++i) { numamem = acpi_data_push(table_data, sizeof(*numamem)); build_srat_memory(numamem, mem_base, numa_info[i].node_mem, i, MEM_AFFINITY_ENABLED); mem_base += numa_info[i].node_mem; } build_header(linker, table_data, (void *)srat, "SRAT", table_data->len - srat_start, 3, NULL, NULL); }