/*
* Remove an entry from the device configuration linked list.
*/
static struct virtio_net_config_ll *
rm_config_ll_entry(struct virtio_net_config_ll *ll_dev,
struct virtio_net_config_ll *ll_dev_last)
{
/* First remove the device and then clean it up. */
if (ll_dev == ll_root) {
ll_root = ll_dev->next;
cleanup_device(&ll_dev->dev);
free_device(ll_dev);
return ll_root;
} else {
if (likely(ll_dev_last != NULL)) {
ll_dev_last->next = ll_dev->next;
cleanup_device(&ll_dev->dev);
free_device(ll_dev);
return ll_dev_last->next;
} else {
cleanup_device(&ll_dev->dev);
free_device(ll_dev);
RTE_LOG(ERR, VHOST_CONFIG,
"Remove entry from config_ll failed\n");
return NULL;
}
}
}
static void sdev_free(struct device *dev)
{
struct safe_device *sdev = dev_sdev(dev);
if (sdev->sb_n > 0) {
char *first_block = align_512(sdev->saved_blocks);
char *block = first_block +
((sdev->sb_n - 1) <<
dev_get_block_order(sdev->shadow_dev));
uint64_t *poffset = &sdev->sb_offsets[sdev->sb_n - 1];
int block_size = dev_get_block_size(sdev->shadow_dev);
/* Restore blocks in reverse order to cope with
* wraparound and chain drives.
*/
do {
int rc = sdev->shadow_dev->write_block(
sdev->shadow_dev, block, block_size, *poffset);
if (rc) {
/* Do not abort, try to recover all bocks. */
warn("Failed to recover block at offset 0x%"
PRIx64 " due to a write error",
*poffset);
}
block -= block_size;
poffset--;
} while (block >= first_block);
}
free(sdev->sb_bitmap);
free(sdev->sb_offsets);
free(sdev->saved_blocks);
free_device(sdev->shadow_dev);
}
static void
deinit(void)
{
struct device_t *iter, *tmp;
if (hal_ctx) {
libhal_ctx_shutdown(hal_ctx, (DBusError *)NULL);
libhal_ctx_free(hal_ctx);
}
dbus_connection_unref(dbus_conn);
iter = head;
while (iter) {
tmp = iter;
if (!is_mounted(iter))
/* don't care to check the return values */
do_umount(iter);
rmdir(iter->mountp);
if (iter->should_remove_entry)
remove_fstab_entry(iter);
iter = iter->next;
free_device(tmp);
}
if (pid_fd >= 0)
if (close(pid_fd) < 0) /* releases lock */
syslog(LOG_ERR, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
closelog();
}
void del_all_devices()
{
for(int j=0;j<number_of_devices;j++)
{
free_device(j);
}
number_of_devices=0;
};
struct device *pdev_detach_and_free(struct device *dev)
{
struct perf_device *pdev = dev_pdev(dev);
struct device *shadow_dev = pdev->shadow_dev;
pdev->shadow_dev = NULL;
pdev->dev.free = NULL;
free_device(&pdev->dev);
return shadow_dev;
}
void free_device(struct device **dev)
{
if (*dev == NULL)
return;
struct device *next = (*dev)->next;
struct device *child = (*dev)->child;
struct info_tuple *info = (*dev)->info;
free_device(&next);
free_device(&child);
free_info_tuple(&info);
free_device_fields(*dev);
free(*dev);
*dev = NULL;
}
int main(void) {
struct device *dev = new_device("Plugin");
get_info(dev);
print_device_list(dev);
free_device(&dev);
return 0;
}
void del_device(uint8_t idx)
{
// handle index out of bounds?
free_device(idx);
number_of_devices--;
for(int i = idx;i< number_of_devices;i++)
{
devices[i]=devices[i+1];
}
}
static void ensure_ws(const int ws_size)
{
//printf("ws_size %i\n", ws_size);
if(ws_size > fft_ws_size)
{
fft_ws_size = ws_size;
if(fft_ws)
free_device(fft_ws);
malloc_device(&fft_ws, ws_size);
}
}
static int
usbhub_device_disconnect(struct usb_host *usbhc, u8 devadr, u64 port)
{
struct usb_device *dev;
dprintft(3, "HUB(%02x): HUB PORT(%d) status disconnect.\n",
devadr, (int)(port & USB_PORT_MASK));
dev = get_device_by_port (usbhc, port);
if (dev)
free_device (usbhc, dev);
return USB_HOOK_PASS;
}
void iio_context_destroy(struct iio_context *ctx)
{
unsigned int i;
if (ctx->ops->shutdown)
ctx->ops->shutdown(ctx);
for (i = 0; i < ctx->nb_devices; i++)
free_device(ctx->devices[i]);
if (ctx->nb_devices)
free(ctx->devices);
if (ctx->xml)
free(ctx->xml);
if (ctx->description)
free(ctx->description);
free(ctx);
}
/*
* Function is called from the CUSE release function. This function will
* cleanup the device and remove it from device configuration linked list.
*/
void
vhost_destroy_device(struct vhost_device_ctx ctx)
{
struct virtio_net *dev = get_device(ctx);
if (dev == NULL)
return;
if (dev->flags & VIRTIO_DEV_RUNNING)
notify_ops->destroy_device(dev);
cleanup_device(dev, 1);
free_device(dev);
vhost_devices[ctx.fh] = NULL;
}
/*
* Invoked when there is the vhost-user connection is broken (when
* the virtio device is being detached).
*/
void
vhost_destroy_device(int vid)
{
struct virtio_net *dev = get_device(vid);
if (dev == NULL)
return;
if (dev->flags & VIRTIO_DEV_RUNNING) {
dev->flags &= ~VIRTIO_DEV_RUNNING;
dev->notify_ops->destroy_device(vid);
}
cleanup_device(dev, 1);
free_device(dev);
vhost_devices[vid] = NULL;
}
static void
usbhub_clean_list (struct usb_device *hubdev)
{
struct usb_device *dev;
struct usb_host *usbhc;
usbhc = hubdev->host;
if (!usbhc) {
dprintft (1, "hubdev->host NULL.\n");
return;
}
again:
for (dev = usbhc->device; dev; dev = dev->next) {
if (dev->parent == hubdev) {
/* if dev is hub, dev->next may be freed
* during free_device() */
free_device (usbhc, dev);
goto again;
}
}
}
int main()
{
data_t data;
printf("\n\tGestIC %s - Console Demo\n\n", gestic_version_str());
/* Initialize data and the device */
init_data(&data);
init_device(&data);
/* Update device and menu until quit */
while(data.running)
{
update_device(&data);
update_menu(&data);
Sleep(10);
}
/* Do the cleanup work */
free_device(&data);
return 0;
}
static struct iio_context * iio_create_xml_context_helper(xmlDoc *doc)
{
unsigned int i;
xmlNode *root, *n;
xmlAttr *attr;
int err = ENOMEM;
struct iio_context *ctx = calloc(1, sizeof(*ctx));
if (!ctx)
goto err_set_errno;
ctx->name = "xml";
ctx->ops = &xml_ops;
root = xmlDocGetRootElement(doc);
if (strcmp((char *) root->name, "context")) {
ERROR("Unrecognized XML file\n");
err = EINVAL;
goto err_free_ctx;
}
for (attr = root->properties; attr; attr = attr->next) {
if (!strcmp((char *) attr->name, "description"))
ctx->description = _strdup(
(char *) attr->children->content);
else if (strcmp((char *) attr->name, "name"))
WARNING("Unknown parameter \'%s\' in <context>\n",
(char *) attr->children->content);
}
for (n = root->children; n; n = n->next) {
struct iio_device **devs, *dev;
if (strcmp((char *) n->name, "device")) {
if (strcmp((char *) n->name, "text"))
WARNING("Unknown children \'%s\' in "
"<context>\n", n->name);
continue;
}
dev = create_device(ctx, n);
if (!dev) {
ERROR("Unable to create device\n");
goto err_free_devices;
}
devs = realloc(ctx->devices, (1 + ctx->nb_devices) *
sizeof(struct iio_device *));
if (!devs) {
ERROR("Unable to allocate memory\n");
free(dev);
goto err_free_devices;
}
devs[ctx->nb_devices++] = dev;
ctx->devices = devs;
}
err = iio_context_init(ctx);
if (err)
goto err_free_devices;
return ctx;
err_free_devices:
for (i = 0; i < ctx->nb_devices; i++)
free_device(ctx->devices[i]);
if (ctx->nb_devices)
free(ctx->devices);
err_free_ctx:
free(ctx);
err_set_errno:
errno = err;
return NULL;
}
static struct iio_device * create_device(struct iio_context *ctx, xmlNode *n)
{
xmlAttr *attr;
struct iio_device *dev = calloc(1, sizeof(*dev));
if (!dev)
return NULL;
dev->ctx = ctx;
for (attr = n->properties; attr; attr = attr->next) {
if (!strcmp((char *) attr->name, "name")) {
dev->name = _strdup((char *) attr->children->content);
} else if (!strcmp((char *) attr->name, "id")) {
dev->id = _strdup((char *) attr->children->content);
} else {
WARNING("Unknown attribute \'%s\' in <device>\n",
attr->name);
}
}
if (!dev->id) {
ERROR("Unable to read device ID\n");
goto err_free_device;
}
for (n = n->children; n; n = n->next) {
if (!strcmp((char *) n->name, "channel")) {
struct iio_channel **chns,
*chn = create_channel(dev, n);
if (!chn) {
ERROR("Unable to create channel\n");
goto err_free_device;
}
chns = realloc(dev->channels, (1 + dev->nb_channels) *
sizeof(struct iio_channel *));
if (!chns) {
ERROR("Unable to allocate memory\n");
free(chn);
goto err_free_device;
}
chns[dev->nb_channels++] = chn;
dev->channels = chns;
} else if (!strcmp((char *) n->name, "attribute")) {
if (add_attr_to_device(dev, n, false) < 0)
goto err_free_device;
} else if (!strcmp((char *) n->name, "debug-attribute")) {
if (add_attr_to_device(dev, n, true) < 0)
goto err_free_device;
} else if (strcmp((char *) n->name, "text")) {
WARNING("Unknown children \'%s\' in <device>\n",
n->name);
continue;
}
}
dev->words = (dev->nb_channels + 31) / 32;
if (dev->words) {
dev->mask = calloc(dev->words, sizeof(*dev->mask));
if (!dev->mask) {
errno = ENOMEM;
goto err_free_device;
}
}
return dev;
err_free_device:
free_device(dev);
return NULL;
}
static void pdev_free(struct device *dev)
{
struct perf_device *pdev = dev_pdev(dev);
free_device(pdev->shadow_dev);
}
/* Callback function, called when a new device has been inserted. */
static void
device_added(LibHalContext *context, const char *did)
{
const char *dudi, *fstype;
char *dev, *mountp, *mountable, *label, *locked_reason;
LibHalVolume *volume;
LibHalDrive *drive;
struct device_t *device;
if (libhal_device_property_exists(context, did, "info.locked",
(DBusError *)NULL)
&& libhal_device_get_property_bool(context, did, "info.locked",
(DBusError *)NULL)) {
if (debug_mode_flag) {
locked_reason = libhal_device_get_property_string(
context, did, "info.locked.reason",
(DBusError *)NULL);
if (locked_reason) {
if (debug_mode_flag)
printf("%s%d: %s\n", __FILE__, __LINE__, locked_reason);
libhal_free_string(locked_reason);
}
}
return;
}
if (!libhal_device_query_capability(context, did, "volume",
(DBusError *)NULL))
return;
label = libhal_device_get_property_string(context, did, "volume.label",
(DBusError *)NULL);
if (!(mountable = libhal_device_get_property_string(
context, did, "volume.fsusage", (DBusError *)NULL))
|| strcmp(mountable, "filesystem"))
goto out;
if (!(volume = libhal_volume_from_udi(context, did)))
goto out;
if (!(dudi = libhal_volume_get_storage_device_udi(volume)))
goto out;
if (!(drive = libhal_drive_from_udi(context, dudi)))
goto out;
if (!libhal_drive_is_hotpluggable(drive)
&& !libhal_drive_uses_removable_media(drive))
goto out;
if (!(fstype = libhal_volume_get_fstype(volume)))
goto out;
if (!(dev = libhal_device_get_property_string(context, did, "block.device",
(DBusError *)NULL)))
goto out;
mountp = get_mount_point(dev, label);
if (!mountp)
goto out;
device = get_device(mountp, did, dev, label, fstype, volume, drive);
if(!is_mounted(device)) {
free_device(device);
goto out;
}
if (!device)
goto out;
consider_fstab(device);
device->hook = malloc(2*sizeof(char*));
if(!file_exists(HOOK_PATH)) {
device->hook[0] = get_hook(device, "mount");
device->hook[1] = get_hook(device, "umount");
}
else {
device->hook[0] = NULL;
device->hook[1] = NULL;
}
if (file_exists(device->mountp) < 0)
mkdir(device->mountp, 0750);
do_mount(device) < 0 ? free_device(device) : add_to_device_list(device);
if (device) {
if (!add_fstab_entry(device))
device->should_remove_entry = 1;
if (debug_mode_flag)
debug_dump_device(device);
}
if (device->hook[0]) run_hook(0, device);
out:
if (mountable)
libhal_free_string(mountable);
if (label)
libhal_free_string(label);
}
API_EXPORTED int usb_find_devices(void)
{
struct usb_bus *bus;
libusb_device **dev_list;
int dev_list_len;
int r;
int changes = 0;
/* libusb-1.0 initialization might have failed, but we can't indicate
* this with libusb-0.1, so trap that situation here */
if (!ctx)
return 0;
usbi_dbg("");
dev_list_len = libusb_get_device_list(ctx, &dev_list);
if (dev_list_len < 0)
return compat_err(dev_list_len);
for (bus = usb_busses; bus; bus = bus->next) {
struct usb_device *new_devices = NULL;
struct usb_device *dev;
r = find_devices(dev_list, dev_list_len, bus, &new_devices);
if (r < 0) {
libusb_free_device_list(dev_list, 1);
return r;
}
/* walk through the devices we already know about, removing duplicates
* from the new list. if we do not find it in the new list, the device
* has been removed. */
dev = bus->devices;
while (dev) {
int found = 0;
struct usb_device *tdev = dev->next;
struct usb_device *ndev = new_devices;
while (ndev) {
if (ndev->devnum == dev->devnum) {
LIST_DEL(new_devices, ndev);
free(ndev);
found = 1;
break;
}
ndev = ndev->next;
}
if (!found) {
usbi_dbg("device %d.%d removed",
dev->bus->location, dev->devnum);
LIST_DEL(bus->devices, dev);
free_device(dev);
changes++;
}
dev = tdev;
}
/* anything left in new_devices is a new device */
dev = new_devices;
while (dev) {
struct usb_device *tdev = dev->next;
r = initialize_device(dev);
if (r < 0) {
usbi_err("couldn't initialize device %d.%d (error %d)",
dev->bus->location, dev->devnum, r);
dev = tdev;
continue;
}
usbi_dbg("device %d.%d added", dev->bus->location, dev->devnum);
LIST_DEL(new_devices, dev);
LIST_ADD(bus->devices, dev);
changes++;
dev = tdev;
}
}
libusb_free_device_list(dev_list, 1);
return changes;
}
