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

int vmm_vcpu_irq_deinit(struct vmm_vcpu *vcpu){	/* Sanity Checks */	if (!vcpu) {		return VMM_EFAIL;	}	/* For Orphan VCPU just return */	if (!vcpu->is_normal) {		return VMM_OK;	}	/* Stop wfi_timeout event */	vmm_timer_event_stop(vcpu->irqs.wfi.priv);	/* Free wfi_timeout event */	vmm_free(vcpu->irqs.wfi.priv);	vcpu->irqs.wfi.priv = NULL;	/* Free flags */	vmm_free(vcpu->irqs.irq);	vcpu->irqs.irq = NULL;	return VMM_OK;}

int vmm_fb_unregister(struct vmm_fb_info *info){	int rc;	struct vmm_fb_event event;	struct vmm_classdev *cd;	if (info == NULL) {		return VMM_EFAIL;	}	if (info->dev == NULL) {		return VMM_EFAIL;	}	cd = vmm_devdrv_find_classdev(VMM_FB_CLASS_NAME, info->dev->node->name);	if (!cd) {		return VMM_EFAIL;	}	rc = vmm_devdrv_unregister_classdev(VMM_FB_CLASS_NAME, cd);	if (!rc) {		vmm_free(cd);	}	if (info->pixmap.addr &&	    (info->pixmap.flags & FB_PIXMAP_DEFAULT)) {		vmm_free(info->pixmap.addr);	}	vmm_fb_destroy_modelist(&info->modelist);	event.info = info;	vmm_fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event);	return rc;}

int mempool_destroy(struct mempool *mp){	int rc = VMM_OK;	if (!mp) {		return VMM_EFAIL;	}	switch (mp->type) {	case MEMPOOL_TYPE_RAW:		rc = vmm_host_memunmap(mp->entity_base);		break;	case MEMPOOL_TYPE_RAM:		rc = vmm_host_free_pages(mp->entity_base,					 mp->d.ram.page_count);		break;	case MEMPOOL_TYPE_HEAP:		vmm_free((void *)mp->entity_base);		break;	default:		return VMM_EINVALID;	};	fifo_free(mp->f);	vmm_free(mp);	return rc;}

int vmm_ringbuf_free(struct vmm_ringbuf *rb){	vmm_free(rb->keys);	vmm_free(rb);	return VMM_OK;}

static void virtio_blk_req_done(struct virtio_blk_dev_req *req, u8 status){	struct virtio_device *dev = req->bdev->vdev;	int queueid = req->vq - req->bdev->vqs;	if (req->read_iov && req->len && req->r.data &&	    (status == VIRTIO_BLK_S_OK) &&	    (req->r.type == VMM_REQUEST_READ)) {		virtio_buf_to_iovec_write(dev, 					  req->read_iov, 					  req->read_iov_cnt, 					  req->r.data, 					  req->len);	}	if (req->read_iov) {		vmm_free(req->read_iov);		req->read_iov = NULL;		req->read_iov_cnt = 0;	}	if (req->r.data) {		vmm_free(req->r.data);		req->r.data = NULL;	}	virtio_buf_to_iovec_write(dev, &req->status_iov, 1, &status, 1);	virtio_queue_set_used_elem(req->vq, req->head, req->len);	if (virtio_queue_should_signal(req->vq)) {		dev->tra->notify(dev, queueid);	}}

int vmm_host_irqext_dispose_mapping(u32 hirq){	int rc = VMM_OK;	irq_flags_t flags;	struct vmm_host_irq *irq = NULL;	if (hirq < CONFIG_HOST_IRQ_COUNT) {		return vmm_host_irq_set_hwirq(hirq, hirq);	}	vmm_write_lock_irqsave_lite(&iectrl.lock, flags);	if (iectrl.count <= (hirq - CONFIG_HOST_IRQ_COUNT)) {		rc = VMM_EINVALID;		goto done;	}	irq = iectrl.irqs[hirq - CONFIG_HOST_IRQ_COUNT];	iectrl.irqs[hirq - CONFIG_HOST_IRQ_COUNT] = NULL;	if (irq) {		if (irq->name) {			vmm_free((void *)irq->name);		}		vmm_free(irq);	}done:	vmm_write_unlock_irqrestore_lite(&iectrl.lock, flags);	return rc;}

static void __blockdev_free(struct vmm_blockdev *bdev, bool free_rq){	if (free_rq) {		vmm_free(bdev->rq);	}	vmm_free(bdev);}

static int ne2k_driver_probe(struct vmm_driver *dev, const struct vmm_devid *devid){	int rc;	struct vmm_netdev *ndev;	struct nic_priv_data *priv_data;		ndev = vmm_malloc(sizeof(struct vmm_netdev));	if(!ndev) {		rc = VMM_EFAIL;		goto free_nothing;	}	vmm_memset(ndev,0, sizeof(struct vmm_netdev));	priv_data = vmm_malloc(sizeof(struct nic_priv_data));	if(!priv_data) {		rc = VMM_EFAIL;		goto free_chardev;	}	vmm_memset(priv_data,0, sizeof(struct nic_priv_data));	if (ne2k_init(priv_data)) {		rc = VMM_EFAIL;		goto free_chardev;	}	priv_data->txrx_thread = vmm_hyperthread_create("ne2k-isa-driver", dp83902a_poll, priv_data);	if (priv_data == NULL) {		rc = VMM_EFAIL;		goto free_chardev;	}	vmm_hyperthread_run(priv_data->txrx_thread);	vmm_strcpy(ndev->name, dev->node->name);	ndev->dev = dev;	ndev->ioctl = NULL;	ndev->read = ne2k_read;	ndev->write = ne2k_write;	ndev->priv = (void *)priv_data;	rc = vmm_netdev_register(ndev);	if(rc) {		goto free_port;	}	dev->priv = (void *)ndev;	return VMM_OK;free_port:	vmm_free(priv_data);free_chardev:	vmm_free(ndev);free_nothing:	return rc;}

void vmm_fb_release(struct vmm_fb_info *info){	if (!info)		return;	if (info->apertures) {		vmm_free(info->apertures);	}	vmm_free(info);}

static int iso9660fs_unmount(struct mount *m){	struct iso9660_mount_data *mdata = m->m_data;	if (mdata) {		if (mdata->root_dir) vmm_free(mdata->root_dir);		vmm_free(mdata);	}	m->m_data = NULL;	return VMM_OK;}

static int uart_driver_remove(struct vmm_device *dev){	int rc = VMM_OK;	struct vmm_chardev *cd =(struct vmm_chardev*)dev->priv;	if (cd) {		rc = vmm_chardev_unregister(cd);		vmm_free(cd->priv);		vmm_free(cd);		dev->priv = NULL;	}	return rc;}

void m_ext_free(struct vmm_mbuf *m){	if (!(--(m->m_extref))) {		/* dropping the last reference */		if (m->m_extfree) {			(*m->m_extfree)(m, m->m_extbuf, m->m_extlen, m->m_extarg);		} else {			vmm_free(m->m_extbuf);		}	}	if (!(--(m->m_ref))) {		vmm_free(m);	}}

int arch_guest_init(struct vmm_guest *guest){	if (!guest->reset_count) {		guest->arch_priv = vmm_malloc(sizeof(struct arm_guest_priv));		if (!guest->arch_priv) {			return VMM_ENOMEM;		}		arm_guest_priv(guest)->ttbl = mmu_lpae_ttbl_alloc(TTBL_STAGE2);		if (!arm_guest_priv(guest)->ttbl) {			vmm_free(guest->arch_priv);			guest->arch_priv = NULL;			return VMM_ENOMEM;		}		if (vmm_devtree_read_u32(guest->node,				"psci_version",				&arm_guest_priv(guest)->psci_version)) {			/* By default, assume PSCI v0.1 */			arm_guest_priv(guest)->psci_version = 1;		}	}	return VMM_OK;}

int vmm_rtcdev_register(struct vmm_rtcdev *rdev){	int rc;	struct vmm_classdev *cd;	if (!(rdev && rdev->set_time && rdev->get_time)) {		return VMM_EFAIL;	}	cd = vmm_zalloc(sizeof(struct vmm_classdev));	if (!cd) {		return VMM_EFAIL;	}	INIT_LIST_HEAD(&cd->head);	strcpy(cd->name, rdev->name);	cd->dev = rdev->dev;	cd->priv = rdev;	rc = vmm_devdrv_register_classdev(VMM_RTCDEV_CLASS_NAME, cd);	if (rc != VMM_OK) {		vmm_free(cd);	}	return rc;}

void* unpack_elf(void* elf) {	struct elf_header* header = elf;    struct elf_program_header* ph;    /* Ist es ueberhaupt eine ELF-Datei? */    if (header->magic != ELF_MAGIC) {    	show_cod(0, "No ELF");        return 0;    }    void* elf_mod_entry = (void*) (header->entry);    ph = (struct elf_program_header*) (((char*) header) + header->ph_offset);    for (uint32_t n = 0; n < header->ph_entry_count; n++, ph++) {        void* dest = (void*) ph->virt_addr;        void* src = ((char*) header) + ph->offset;        /* Nur Program Header vom Typ LOAD laden */        if (ph->type != 1) {            continue;        }        for (uint32_t offset = 0; offset < ph->mem_size; offset += 0x1000) {            vmm_free(dest + offset);            vmm_alloc_addr(dest + offset, 0);        }        memcpy(dest, src, ph->file_size);    }    return elf_mod_entry;}

struct vmm_ringbuf *vmm_ringbuf_alloc(u32 key_size, u32 key_count){	struct vmm_ringbuf *rb;	rb = vmm_malloc(sizeof(struct vmm_ringbuf));	if (!rb) {		return NULL;	}	INIT_SPIN_LOCK(&rb->lock);	rb->keys = vmm_malloc(key_size * key_count);	if (!rb->keys) {		goto rb_init_fail;	}	rb->key_size = key_size;	rb->key_count = key_count;	rb->read_pos = 0;	rb->write_pos = 0;	rb->avail_count = 0;	return rb;rb_init_fail:	vmm_free(rb);	return NULL;}

int netstack_socket_accept(struct netstack_socket *sk, 			   struct netstack_socket **new_sk){	err_t err;	struct netconn *newconn;	struct netstack_socket *tsk;	if (!sk || !sk->priv || !new_sk) {		return VMM_EINVALID;	}	tsk = vmm_zalloc(sizeof(struct netstack_socket));	if (!tsk) {		return VMM_ENOMEM;	}		memcpy(tsk, sk, sizeof(struct netstack_socket));	tsk->priv = NULL;	err = netconn_accept(sk->priv, &newconn);	if (err != ERR_OK) {		vmm_free(tsk);		return VMM_EFAIL;	}	tsk->priv = newconn;	*new_sk = tsk;	return VMM_OK;}

int arch_guest_init(struct vmm_guest *guest){	struct riscv_guest_priv *priv;	if (!guest->reset_count) {		guest->arch_priv = vmm_malloc(sizeof(struct riscv_guest_priv));		if (!guest->arch_priv) {			return VMM_ENOMEM;		}		priv = riscv_guest_priv(guest);		priv->time_offset = vmm_manager_guest_reset_timestamp(guest);		priv->time_offset =			priv->time_offset * vmm_timer_clocksource_frequency();		priv->time_offset = udiv64(priv->time_offset, 1000000000ULL);		priv->pgtbl = cpu_mmu_pgtbl_alloc(PGTBL_STAGE2);		if (!priv->pgtbl) {			vmm_free(guest->arch_priv);			guest->arch_priv = NULL;			return VMM_ENOMEM;		}	}	return VMM_OK;}

static int __init vmm_blockdev_init(void){	int rc;	struct vmm_class *c;	vmm_printf("Initialize Block Device Framework/n");	c = vmm_malloc(sizeof(struct vmm_class));	if (!c) {		rc = VMM_ENOMEM;		goto fail;	}	INIT_LIST_HEAD(&c->head);	if (strlcpy(c->name, VMM_BLOCKDEV_CLASS_NAME, sizeof(c->name)) >=	    sizeof(c->name)) {		rc = VMM_EOVERFLOW;		goto free_class;	}	INIT_LIST_HEAD(&c->classdev_list);	rc = vmm_devdrv_register_class(c);	if (rc) {		goto free_class;	}	return VMM_OK;free_class:	vmm_free(c);fail:	return rc;}

static int virtio_pci_bar_probe(struct vmm_guest *guest,				struct vmm_emudev *edev,				const struct vmm_devtree_nodeid *eid){	int rc = VMM_OK;	struct virtio_pci_dev *vdev;	vdev = vmm_zalloc(sizeof(struct virtio_pci_dev));	if (!vdev) {		rc = VMM_ENOMEM;		goto virtio_pci_probe_done;	}	vdev->guest = guest;	vmm_snprintf(vdev->dev.name, VMM_VIRTIO_DEVICE_MAX_NAME_LEN,		     "%s/%s", guest->name, edev->node->name);	vdev->dev.edev = edev;	vdev->dev.tra = &pci_tra;	vdev->dev.tra_data = vdev;	vdev->dev.guest = guest;	vdev->config = (struct vmm_virtio_pci_config) {		.queue_num  = 256,	};	rc = vmm_devtree_read_u32(edev->node, "virtio_type",				  &vdev->dev.id.type);	if (rc) {		goto virtio_pci_probe_freestate_fail;	}	rc = vmm_devtree_read_u32_atindex(edev->node,					  VMM_DEVTREE_INTERRUPTS_ATTR_NAME,					  &vdev->irq, 0);	if (rc) {		goto virtio_pci_probe_freestate_fail;	}	if ((rc = vmm_virtio_register_device(&vdev->dev))) {		goto virtio_pci_probe_freestate_fail;	}	edev->priv = vdev;	goto virtio_pci_probe_done;virtio_pci_probe_freestate_fail:	vmm_free(vdev);virtio_pci_probe_done:	return rc;}static struct vmm_devtree_nodeid virtio_pci_emuid_table[] = {	{		.type = "virtio",		.compatible = "virtio,pci",	},	{ /* end of list */ },};

static struct vmm_blockdev *__blockdev_alloc(bool alloc_rq){	struct vmm_blockdev *bdev;	bdev = vmm_zalloc(sizeof(struct vmm_blockdev));	if (!bdev) {		return NULL;	}	INIT_LIST_HEAD(&bdev->head);	INIT_MUTEX(&bdev->child_lock);	bdev->child_count = 0;	INIT_LIST_HEAD(&bdev->child_list);	if (alloc_rq) {		bdev->rq = vmm_zalloc(sizeof(struct vmm_request_queue));		if (!bdev->rq) {			vmm_free(bdev);			return NULL;		}		INIT_SPIN_LOCK(&bdev->rq->lock);	} else {		bdev->rq = NULL;	}	return bdev;}

static int _irqext_expand(void){	unsigned int old_size = iectrl.count;	unsigned int new_size = iectrl.count + HOST_IRQEXT_CHUNK;	struct vmm_host_irq **irqs = NULL;	unsigned long *bitmap = NULL;	irqs = realloc(iectrl.irqs,		       old_size * sizeof (struct vmm_host_irq *),		       new_size * sizeof (struct vmm_host_irq *));	if (!irqs) {		vmm_printf("%s: Failed to reallocate extended IRQ array from "			   "%d to %d bytes/n", __func__, old_size, new_size);		return VMM_ENOMEM;	}	old_size = BITMAP_SIZE(old_size);	new_size = BITMAP_SIZE(new_size);	bitmap = realloc(iectrl.bitmap, old_size, new_size);	if (!bitmap) {		vmm_printf("%s: Failed to reallocate extended IRQ bitmap from "			   "%d to %d bytes/n", __func__, old_size, new_size);		vmm_free(irqs);		return VMM_ENOMEM;	}	iectrl.irqs = irqs;	iectrl.bitmap = bitmap;	iectrl.count += HOST_IRQEXT_CHUNK;	return VMM_OK;}

int vmm_chardev_register(struct vmm_chardev * cdev){	int rc;	struct vmm_classdev *cd;	if (!(cdev && cdev->read && cdev->write)) {		return VMM_EFAIL;	}	cd = vmm_malloc(sizeof(struct vmm_classdev));	if (!cd) {		return VMM_EFAIL;	}	vmm_memset(cd, 0, sizeof(struct vmm_classdev));	INIT_LIST_HEAD(&cd->head);	vmm_strcpy(cd->name, cdev->name);	cd->dev = cdev->dev;	cd->priv = cdev;	rc = vmm_devdrv_register_classdev(VMM_CHARDEV_CLASS_NAME, cd);	if (rc != VMM_OK) {		vmm_free(cd);	}	return rc;}

static void virtio_blk_disconnect(struct virtio_device *dev){	struct virtio_blk_dev *bdev = dev->emu_data;	vmm_blockdev_unregister_client(&bdev->blk_client);	vmm_free(bdev);}

int vmm_blockdev_register(struct vmm_blockdev * bdev){	int rc;	struct vmm_classdev *cd;	if (bdev == NULL) {		return VMM_EFAIL;	}	if (bdev->readblk == NULL || bdev->writeblk == NULL) {		return VMM_EFAIL;	}	cd = vmm_malloc(sizeof(struct vmm_classdev));	if (!cd) {		return VMM_EFAIL;	}	INIT_LIST_HEAD(&cd->head);	strcpy(cd->name, bdev->name);	cd->dev = bdev->dev;	cd->priv = bdev;	rc = vmm_devdrv_register_classdev(VMM_BLOCKDEV_CLASS_NAME, cd);	if (rc) {		cd->dev = NULL;		cd->priv = NULL;		vmm_free(cd);		return rc;	}	return VMM_OK;}

int vmm_netport_init(void){	int rc;	struct vmm_class *c;	vmm_printf("Initialize Network Port Framework/n");	c = vmm_malloc(sizeof(struct vmm_class));	if (!c)		return VMM_EFAIL;	INIT_LIST_HEAD(&c->head);	strcpy(c->name, VMM_NETPORT_CLASS_NAME);	INIT_LIST_HEAD(&c->classdev_list);	rc = vmm_devdrv_register_class(c);	if (rc) {		vmm_printf("Failed to register %s class/n",			VMM_NETPORT_CLASS_NAME);		vmm_free(c);		return rc;	}	return VMM_OK;}

void rbd_destroy(struct rbd *d){	vmm_host_ram_reserve(d->addr, d->size);	vmm_blockdev_unregister(d->bdev);	vmm_blockdev_free(d->bdev);	vmm_free(d);}

/** * clk_register_fixed_rate - register fixed-rate clock with the clock framework * @dev: device that is registering this clock * @name: name of this clock * @parent_name: name of clock's parent * @flags: framework-specific flags * @fixed_rate: non-adjustable clock rate */struct clk *clk_register_fixed_rate(struct vmm_device *dev, const char *name,		const char *parent_name, unsigned long flags,		unsigned long fixed_rate){	struct clk_fixed_rate *fixed;	struct clk *clk;	struct clk_init_data init;	/* allocate fixed-rate clock */	fixed = vmm_zalloc(sizeof(struct clk_fixed_rate));	if (!fixed) {		vmm_printf("%s: could not allocate fixed clk/n", __func__);		return NULL;	}	init.name = name;	init.ops = &clk_fixed_rate_ops;	init.flags = flags | CLK_IS_BASIC;	init.parent_names = (parent_name ? &parent_name: NULL);	init.num_parents = (parent_name ? 1 : 0);	/* struct clk_fixed_rate assignments */	fixed->fixed_rate = fixed_rate;	fixed->hw.init = &init;	/* register the clock */	clk = clk_register(dev, &fixed->hw);	if (!clk)		vmm_free(fixed);	return clk;}

int vmm_netport_unregister(struct vmm_netport *port){	int rc;	struct vmm_classdev *cd;	if (!port) {		return VMM_EFAIL;	}	rc = vmm_netswitch_port_remove(port);	if (rc) {		return rc;	}	cd = vmm_devdrv_find_classdev(VMM_NETPORT_CLASS_NAME, port->name);	if (!cd) {		return VMM_EFAIL;	}	rc = vmm_devdrv_unregister_classdev(VMM_NETPORT_CLASS_NAME, cd);	if (!rc) {		vmm_free(cd);	}	return rc;}

struct netstack_socket *netstack_socket_alloc(enum netstack_socket_type type){	struct netstack_socket *sk;	struct netconn *conn;	sk = vmm_zalloc(sizeof(struct netstack_socket));	if (!sk) {		return NULL;	}	switch (type) {	case NETSTACK_SOCKET_TCP:		conn = netconn_new(NETCONN_TCP);		break;	case NETSTACK_SOCKET_UDP:		conn = netconn_new(NETCONN_UDP);		break;	default:		conn = NULL;		break;	};	if (!conn) {		vmm_free(sk);		return NULL;	}	sk->priv = conn;	return sk;}