void sys_timer_set( SysTimer timer, SysTime when, SysCallback _callback, void* opaque ) { QEMUTimerCB* callback = (QEMUTimerCB*)_callback; if (callback == NULL) { /* unsetting the timer */ if (timer->timer) { qemu_del_timer( timer->timer ); qemu_free_timer( timer->timer ); timer->timer = NULL; } timer->callback = callback; timer->opaque = NULL; return; } if ( timer->timer ) { if ( timer->callback == callback && timer->opaque == opaque ) goto ReuseTimer; /* need to replace the timer */ qemu_free_timer( timer->timer ); } timer->timer = qemu_new_timer( rt_clock, callback, opaque ); timer->callback = callback; timer->opaque = opaque; ReuseTimer: qemu_mod_timer( timer->timer, when ); }
static void qemu_announce_self_once(void *opaque) { int i, len; VLANState *vlan; VLANClientState *vc; uint8_t buf[256]; static int count = SELF_ANNOUNCE_ROUNDS; QEMUTimer *timer = *(QEMUTimer **)opaque; for (i = 0; i < MAX_NICS; i++) { if (!nd_table[i].used) continue; len = announce_self_create(buf, nd_table[i].macaddr); vlan = nd_table[i].vlan; for(vc = vlan->first_client; vc != NULL; vc = vc->next) { vc->receive(vc, buf, len); } } if (count--) { qemu_mod_timer(timer, qemu_get_clock(rt_clock) + 100); } else { qemu_del_timer(timer); qemu_free_timer(timer); } }
static void _hwSensorClient_free( HwSensorClient* cl ) { /* remove from sensors's list */ if (cl->sensors) { HwSensorClient** pnode = &cl->sensors->clients; for (;;) { HwSensorClient* node = *pnode; if (node == NULL) break; if (node == cl) { *pnode = cl->next; break; } pnode = &node->next; } cl->next = NULL; cl->sensors = NULL; } /* close QEMUD client, if any */ if (cl->client) { qemud_client_close(cl->client); cl->client = NULL; } /* remove timer, if any */ if (cl->timer) { qemu_del_timer(cl->timer); qemu_free_timer(cl->timer); cl->timer = NULL; } AFREE(cl); }
static int usb_host_auto_del(const char *spec) { struct USBAutoFilter *pf = usb_auto_filter; struct USBAutoFilter **prev = &usb_auto_filter; struct USBAutoFilter filter; if (parse_filter(spec, &filter) < 0) return -1; while (pf) { if (match_filter(pf, &filter)) { dprintf("husb: removed auto filter: bus_num %d addr %d vid %d pid %d\n", pf->bus_num, pf->addr, pf->vendor_id, pf->product_id); *prev = pf->next; if (!usb_auto_filter) { /* No more filters. Stop scanning. */ qemu_del_timer(usb_auto_timer); qemu_free_timer(usb_auto_timer); } return 0; } prev = &pf->next; pf = pf->next; } return -1; }
static int buffered_close(void *opaque) { QEMUFileBuffered *s = opaque; ssize_t ret = 0; int ret2; DPRINTF("closing\n"); s->xfer_limit = INT_MAX; while (!qemu_file_get_error(s->file) && s->buffer_size) { ret = buffered_flush(s); if (ret < 0) { break; } if (s->freeze_output) { ret = migrate_fd_wait_for_unfreeze(s->migration_state); if (ret < 0) { break; } } } ret2 = migrate_fd_close(s->migration_state); if (ret >= 0) { ret = ret2; } qemu_del_timer(s->timer); qemu_free_timer(s->timer); g_free(s->buffer); g_free(s); return ret; }
static void balloon_stats_destroy_timer(VirtIOBalloon *s) { if (balloon_stats_enabled(s)) { qemu_del_timer(s->stats_timer); qemu_free_timer(s->stats_timer); s->stats_timer = NULL; s->stats_poll_interval = 0; } }
static void throttlePipe_close( void* opaque ) { ThrottlePipe* pipe = opaque; qemu_del_timer(pipe->timer); qemu_free_timer(pipe->timer); pingPongPipe_close(&pipe->pingpong); }
static void tnetw1130_cleanup(VLANClientState *vc) { pci_tnetw1130_t *d = vc->opaque; unregister_savevm("tnetw1130", d); #if 0 qemu_del_timer(d->poll_timer); qemu_free_timer(d->poll_timer); #endif }
static int pci_pcnet_uninit(PCIDevice *dev) { PCIPCNetState *d = DO_UPCAST(PCIPCNetState, pci_dev, dev); cpu_unregister_io_memory(d->state.mmio_index); qemu_del_timer(d->state.poll_timer); qemu_free_timer(d->state.poll_timer); qemu_del_vlan_client(&d->state.nic->nc); return 0; }
static void nic_cleanup(VLANClientState *nc) { dp8393xState *s = DO_UPCAST(NICState, nc, nc)->opaque; cpu_unregister_io_memory(s->mmio_index); qemu_del_timer(s->watchdog); qemu_free_timer(s->watchdog); qemu_free(s); }
static void baum_close(struct CharDriverState *chr) { BaumDriverState *baum = chr->opaque; qemu_free_timer(baum->cellCount_timer); if (baum->brlapi) { brlapi__closeConnection(baum->brlapi); g_free(baum->brlapi); } g_free(baum); }
static int pci_pcnet_uninit(PCIDevice *dev) { PCIPCNetState *d = DO_UPCAST(PCIPCNetState, pci_dev, dev); memory_region_destroy(&d->state.mmio); memory_region_destroy(&d->io_bar); qemu_del_timer(d->state.poll_timer); qemu_free_timer(d->state.poll_timer); qemu_del_vlan_client(&d->state.nic->nc); return 0; }
static void sys_timer_free( SysTimer timer ) { if (timer->timer) { qemu_del_timer( timer->timer ); qemu_free_timer( timer->timer ); timer->timer = NULL; } timer->next = _s_free_timers; _s_free_timers = timer; }
static void nic_cleanup(VLANClientState *nc) { dp8393xState *s = DO_UPCAST(NICState, nc, nc)->opaque; memory_region_del_subregion(s->address_space, &s->mmio); memory_region_destroy(&s->mmio); qemu_del_timer(s->watchdog); qemu_free_timer(s->watchdog); g_free(s); }
static void iscsi_close(BlockDriverState *bs) { IscsiLun *iscsilun = bs->opaque; struct iscsi_context *iscsi = iscsilun->iscsi; if (iscsilun->nop_timer) { qemu_del_timer(iscsilun->nop_timer); qemu_free_timer(iscsilun->nop_timer); } qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL); iscsi_destroy_context(iscsi); memset(iscsilun, 0, sizeof(IscsiLun)); }
static int iscsi_create(const char *filename, QEMUOptionParameter *options) { int ret = 0; int64_t total_size = 0; BlockDriverState bs; IscsiLun *iscsilun = NULL; QDict *bs_options; memset(&bs, 0, sizeof(BlockDriverState)); /* Read out options */ while (options && options->name) { if (!strcmp(options->name, "size")) { total_size = options->value.n / BDRV_SECTOR_SIZE; } options++; } bs.opaque = g_malloc0(sizeof(struct IscsiLun)); iscsilun = bs.opaque; bs_options = qdict_new(); qdict_put(bs_options, "filename", qstring_from_str(filename)); ret = iscsi_open(&bs, bs_options, 0); QDECREF(bs_options); if (ret != 0) { goto out; } if (iscsilun->nop_timer) { qemu_del_timer(iscsilun->nop_timer); qemu_free_timer(iscsilun->nop_timer); } if (iscsilun->type != TYPE_DISK) { ret = -ENODEV; goto out; } if (bs.total_sectors < total_size) { ret = -ENOSPC; goto out; } ret = 0; out: if (iscsilun->iscsi != NULL) { iscsi_destroy_context(iscsilun->iscsi); } g_free(bs.opaque); return ret; }
static void qemu_announce_self_once(void *opaque) { static int count = SELF_ANNOUNCE_ROUNDS; QEMUTimer *timer = *(QEMUTimer **)opaque; qemu_foreach_nic(qemu_announce_self_iter, NULL); if (--count) { /* delay 50ms, 150ms, 250ms, ... */ qemu_mod_timer(timer, qemu_get_clock(rt_clock) + 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100); } else { qemu_del_timer(timer); qemu_free_timer(timer); } }
static void bdrv_qed_close(BlockDriverState *bs) { BDRVQEDState *s = bs->opaque; qed_cancel_need_check_timer(s); qemu_free_timer(s->need_check_timer); /* Ensure writes reach stable storage */ bdrv_flush(bs->file); /* Clean shutdown, no check required on next open */ if (s->header.features & QED_F_NEED_CHECK) { s->header.features &= ~QED_F_NEED_CHECK; qed_write_header_sync(s); } qed_free_l2_cache(&s->l2_cache); qemu_vfree(s->l1_table); }
static int buffered_close(void *opaque) { QEMUFileBuffered *s = opaque; int ret; DPRINTF("closing\n"); while (!s->has_error && s->buffer_size) { buffered_flush(s); if (s->freeze_output) s->wait_for_unfreeze(s); } ret = s->close(s->opaque); qemu_del_timer(s->timer); qemu_free_timer(s->timer); qemu_free(s->buffer); qemu_free(s); return ret; }
CharDriverState *chr_baum_init(QemuOpts *opts) { BaumDriverState *baum; CharDriverState *chr; brlapi_handle_t *handle; #ifdef CONFIG_SDL SDL_SysWMinfo info; #endif int tty; baum = qemu_mallocz(sizeof(BaumDriverState)); baum->chr = chr = qemu_mallocz(sizeof(CharDriverState)); chr->opaque = baum; chr->chr_write = baum_write; chr->chr_send_event = baum_send_event; chr->chr_accept_input = baum_accept_input; handle = qemu_mallocz(brlapi_getHandleSize()); baum->brlapi = handle; baum->brlapi_fd = brlapi__openConnection(handle, NULL, NULL); if (baum->brlapi_fd == -1) { brlapi_perror("baum_init: brlapi_openConnection"); goto fail_handle; } baum->cellCount_timer = qemu_new_timer(vm_clock, baum_cellCount_timer_cb, baum); if (brlapi__getDisplaySize(handle, &baum->x, &baum->y) == -1) { brlapi_perror("baum_init: brlapi_getDisplaySize"); goto fail; } #ifdef CONFIG_SDL memset(&info, 0, sizeof(info)); SDL_VERSION(&info.version); if (SDL_GetWMInfo(&info)) tty = info.info.x11.wmwindow; else #endif tty = BRLAPI_TTY_DEFAULT; if (brlapi__enterTtyMode(handle, tty, NULL) == -1) { brlapi_perror("baum_init: brlapi_enterTtyMode"); goto fail; } qemu_set_fd_handler(baum->brlapi_fd, baum_chr_read, NULL, baum); qemu_chr_reset(chr); return chr; fail: qemu_free_timer(baum->cellCount_timer); brlapi__closeConnection(handle); fail_handle: free(handle); free(chr); free(baum); return NULL; }
static void qlooptimer_free(void* impl) { QEMUTimer* tt = impl; qemu_free_timer(tt); }