static void test_qemu_opts_create(void) { QemuOptsList *list; QemuOpts *opts; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* now we've create the opts, must find it */ opts = qemu_opts_find(list, NULL); g_assert(opts != NULL); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static void test_qemu_opts_set(void) { QemuOptsList *list; QemuOpts *opts; int ret; const char *opt; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* implicitly create opts and set str3 value */ ret = qemu_opts_set(list, NULL, "str3", "value"); g_assert(ret == 0); g_assert(!QTAILQ_EMPTY(&list->head)); /* get the just created opts */ opts = qemu_opts_find(list, NULL); g_assert(opts != NULL); /* check the str3 value */ opt = qemu_opt_get(opts, "str3"); g_assert_cmpstr(opt, ==, "value"); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static void test_qemu_opt_get_size(void) { QemuOptsList *list; QemuOpts *opts; uint64_t opt; QDict *dict; list = qemu_find_opts("opts_list_02"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_02"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to size1 yet, so defval should be returned */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 5); dict = qdict_new(); g_assert(dict != NULL); qdict_put(dict, "size1", qstring_from_str("10")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* now we have set size1, should know about it */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 10); /* reset value */ qdict_put(dict, "size1", qstring_from_str("15")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* test the reset value */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 15); qdict_del(dict, "size1"); g_free(dict); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
/* Notify the controller that an async packet is complete. This should only be called for packets previously deferred by returning USB_RET_ASYNC from handle_packet. */ void usb_packet_complete(USBDevice *dev, USBPacket *p) { USBEndpoint *ep = p->ep; int ret; usb_packet_check_state(p, USB_PACKET_ASYNC); assert(QTAILQ_FIRST(&ep->queue) == p); usb_packet_set_state(p, USB_PACKET_COMPLETE); QTAILQ_REMOVE(&ep->queue, p, queue); dev->port->ops->complete(dev->port, p); while (!QTAILQ_EMPTY(&ep->queue)) { p = QTAILQ_FIRST(&ep->queue); if (p->state == USB_PACKET_ASYNC) { break; } usb_packet_check_state(p, USB_PACKET_QUEUED); ret = usb_process_one(p); if (ret == USB_RET_ASYNC) { usb_packet_set_state(p, USB_PACKET_ASYNC); break; } p->result = ret; usb_packet_set_state(p, USB_PACKET_COMPLETE); QTAILQ_REMOVE(&ep->queue, p, queue); dev->port->ops->complete(dev->port, p); } }
/* Hand over a packet to a device for processing. Return value USB_RET_ASYNC indicates the processing isn't finished yet, the driver will call usb_packet_complete() when done processing it. */ int usb_handle_packet(USBDevice *dev, USBPacket *p) { int ret; if (dev == NULL) { return USB_RET_NODEV; } assert(dev == p->ep->dev); assert(dev->state == USB_STATE_DEFAULT); usb_packet_check_state(p, USB_PACKET_SETUP); assert(p->ep != NULL); if (QTAILQ_EMPTY(&p->ep->queue) || p->ep->pipeline) { ret = usb_process_one(p); if (ret == USB_RET_ASYNC) { usb_packet_set_state(p, USB_PACKET_ASYNC); QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue); } else { p->result = ret; usb_packet_set_state(p, USB_PACKET_COMPLETE); } } else { ret = USB_RET_ASYNC; usb_packet_set_state(p, USB_PACKET_QUEUED); QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue); } return ret; }
/* Notify the controller that an async packet is complete. This should only be called for packets previously deferred by returning USB_RET_ASYNC from handle_packet. */ void usb_packet_complete(USBDevice *dev, USBPacket *p) { USBEndpoint *ep = p->ep; int ret; usb_packet_check_state(p, USB_PACKET_ASYNC); usb_packet_complete_one(dev, p); while (!QTAILQ_EMPTY(&ep->queue)) { p = QTAILQ_FIRST(&ep->queue); if (ep->halted) { /* Empty the queue on a halt */ p->result = USB_RET_REMOVE_FROM_QUEUE; dev->port->ops->complete(dev->port, p); continue; } if (p->state == USB_PACKET_ASYNC) { break; } usb_packet_check_state(p, USB_PACKET_QUEUED); ret = usb_process_one(p); if (ret == USB_RET_ASYNC) { usb_packet_set_state(p, USB_PACKET_ASYNC); break; } p->result = ret; usb_packet_complete_one(ep->dev, p); } }
/* Hand over a packet to a device for processing. Return value USB_RET_ASYNC indicates the processing isn't finished yet, the driver will call usb_packet_complete() when done processing it. */ int usb_handle_packet(USBDevice *dev, USBPacket *p) { int ret; if (dev == NULL) { return USB_RET_NODEV; } assert(dev == p->ep->dev); assert(dev->state == USB_STATE_DEFAULT); usb_packet_check_state(p, USB_PACKET_SETUP); assert(p->ep != NULL); /* Submitting a new packet clears halt */ if (p->ep->halted) { assert(QTAILQ_EMPTY(&p->ep->queue)); p->ep->halted = false; } if (QTAILQ_EMPTY(&p->ep->queue) || p->ep->pipeline) { ret = usb_process_one(p); if (ret == USB_RET_ASYNC) { assert(p->ep->type != USB_ENDPOINT_XFER_ISOC); usb_packet_set_state(p, USB_PACKET_ASYNC); QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue); } else if (ret == USB_RET_ADD_TO_QUEUE) { usb_packet_set_state(p, USB_PACKET_QUEUED); QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue); ret = USB_RET_ASYNC; } else { /* * When pipelining is enabled usb-devices must always return async, * otherwise packets can complete out of order! */ assert(!p->ep->pipeline || QTAILQ_EMPTY(&p->ep->queue)); if (ret != USB_RET_NAK) { p->result = ret; usb_packet_set_state(p, USB_PACKET_COMPLETE); } } } else { ret = USB_RET_ASYNC; usb_packet_set_state(p, USB_PACKET_QUEUED); QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue); } return ret; }
static void test_qemu_opt_get_number(void) { QemuOptsList *list; QemuOpts *opts; uint64_t opt; int ret; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to number1 yet, so defval should be returned */ opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 5); ret = qemu_opt_set_number(opts, "number1", 10); g_assert(ret == 0); /* now we have set number1, should know about it */ opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 10); /* having reset it, the returned should be the reset one not defval */ ret = qemu_opt_set_number(opts, "number1", 15); g_assert(ret == 0); opt = qemu_opt_get_number(opts, "number1", 5); g_assert(opt == 15); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static void test_qemu_opt_get_bool(void) { QemuOptsList *list; QemuOpts *opts; bool opt; int ret; list = qemu_find_opts("opts_list_02"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_02"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to bool1 yet, so defval should be returned */ opt = qemu_opt_get_bool(opts, "bool1", false); g_assert(opt == false); ret = qemu_opt_set_bool(opts, "bool1", true); g_assert(ret == 0); /* now we have set bool1, should know about it */ opt = qemu_opt_get_bool(opts, "bool1", false); g_assert(opt == true); /* having reset the value, opt should be the reset one not defval */ ret = qemu_opt_set_bool(opts, "bool1", false); g_assert(ret == 0); opt = qemu_opt_get_bool(opts, "bool1", true); g_assert(opt == false); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static void test_qemu_opt_get(void) { QemuOptsList *list; QemuOpts *opts; const char *opt = NULL; list = qemu_find_opts("opts_list_01"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_01"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to str2 yet */ opt = qemu_opt_get(opts, "str2"); g_assert(opt == NULL); qemu_opt_set(opts, "str2", "value"); /* now we have set str2, should know about it */ opt = qemu_opt_get(opts, "str2"); g_assert_cmpstr(opt, ==, "value"); qemu_opt_set(opts, "str2", "value2"); /* having reset the value, the returned should be the reset one */ opt = qemu_opt_get(opts, "str2"); g_assert_cmpstr(opt, ==, "value2"); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
/* Fetches the next PDU from the RE's xmit queue and returns the PDU's * length. 0 is returned if the queue is empty. */ static ssize_t fetch_pdu_from_re(struct llcp_pdu* llcp, struct nfc_re* re) { ssize_t len; assert(llcp); assert(re); if (QTAILQ_EMPTY(&re->xmit_q)) { return 0; } struct llcp_pdu_buf* buf; buf = QTAILQ_FIRST(&re->xmit_q); len = buf->len; memcpy(llcp, buf->pdu, len); QTAILQ_REMOVE(&re->xmit_q, buf, entry); llcp_free_pdu_buf(buf); return len; }
/* Notify the controller that an async packet is complete. This should only be called for packets previously deferred by returning USB_RET_ASYNC from handle_packet. */ void usb_packet_complete(USBDevice *dev, USBPacket *p) { USBEndpoint *ep = p->ep; int ret; usb_packet_check_state(p, USB_PACKET_ASYNC); assert(QTAILQ_FIRST(&ep->queue) == p); __usb_packet_complete(dev, p); while (!ep->halted && !QTAILQ_EMPTY(&ep->queue)) { p = QTAILQ_FIRST(&ep->queue); if (p->state == USB_PACKET_ASYNC) { break; } usb_packet_check_state(p, USB_PACKET_QUEUED); ret = usb_process_one(p); if (ret == USB_RET_ASYNC) { usb_packet_set_state(p, USB_PACKET_ASYNC); break; } p->result = ret; __usb_packet_complete(ep->dev, p); } }
static size_t process_ptype_cc(struct nfc_re* re, const struct llcp_pdu* llcp, size_t len, uint8_t* consumed, struct llcp_pdu* rsp) { struct llcp_data_link* dl; dl = llcp_clear_data_link(re->llcp_dl[llcp->ssap] + llcp->dsap); assert(dl->status == LLCP_DATA_LINK_CONNECTING); dl->status = LLCP_DATA_LINK_CONNECTED; /* move DL's pending PDUs to global xmit queue */ while (!QTAILQ_EMPTY(&dl->xmit_q)) { struct llcp_pdu_buf* buf = QTAILQ_FIRST(&dl->xmit_q); QTAILQ_REMOVE(&dl->xmit_q, buf, entry); QTAILQ_INSERT_TAIL(&re->xmit_q, buf, entry); } update_last_saps(re, llcp->ssap, llcp->dsap); *consumed = sizeof(*llcp) + 1; return 0; }