Lines Matching defs:requests
90 * ring space for all requests to be XBB_MAX_REQUEST_SIZE'd.
207 * Number of child requests in the list.
212 * Number of I/O requests still pending on the backend.
217 * Total number of segments for requests in the list.
260 * Linked list of contiguous requests with the same operation type.
265 * Linked list links used to aggregate idle requests in the
267 * requests waiting for execution (xbb->reqlist_pending_stailq).
279 * Linked list links used to aggregate requests into a reqlist
295 * The number of 512 byte sectors comprising this requests.
305 * Storage used for non-native ring requests.
386 * Front-end requests exist in the ring and are waiting for
496 * Task-queue used to process I/O requests.
515 /** The number of requests outstanding on the backend device/file. */
522 struct xbb_xen_req *requests;
575 * \brief The maximum number of requests and request lists allowed
675 * conversion of blkif ring requests to internal xbb_xen_req
703 * coalesced requests, and we start them right before execution.
708 * I/O statistics coming into BlockBack. These are the requests as
717 /** Send a real flush for every N flush requests */
720 /** Count of flush requests in the interval */
723 /** Don't coalesce requests if this is set */
726 /** Number of requests we have received */
729 /** Number of requests we have completed*/
732 /** Number of requests we queued but not pushed*/
735 /** Number of requests we completed with an error status*/
808 * \param req_list The list of requests to free.
893 * Get Kernel Virtual Address space for mapping requests.
1267 * Send queued responses to blkif requests.
1292 * Tail check for pending requests. Allows frontend to avoid
1293 * notifications if requests are already in flight (lower
1329 * to protect the request list, because all requests have
1388 * Completion handler for buffer I/O requests issued by the device
1407 * request list can contain multiple front-end requests and
1417 * but not on the individual requests, since we don't currently
1439 * done with the requests, send status back for all of them.
1458 * list and any secondary ring requests in which they may reside, and
1524 * flush support. So we just complete the requests
1533 * for every N flush requests. So keep count, and either
1717 * Process incoming requests from the shared communication ring in response
1743 * additional requests that have come in while we were dispatching
1747 * many requests blockfront is queueing to us at any given time.
1755 * requests to that request list, if we have room.
1773 /* Ensure we see queued requests up to 'rp'. */
1780 * @note There's a 1 to 1 relationship between requests and
2631 * for all currently active requests to drain.
2661 if (xbb->requests != NULL) {
2662 free(xbb->requests, M_XENBLOCKBACK);
2663 xbb->requests = NULL;
2816 * values for the size and number of I/O requests, and the size of our
2842 * pages ("real memory") during the lifetime of front-end requests
3006 xbb->requests = malloc(xbb->max_requests * sizeof(*xbb->requests),
3008 if (xbb->requests == NULL) {
3014 req = xbb->requests;
3015 last_req = &xbb->requests[xbb->max_requests - 1];
3031 * If no requests can be merged, we need 1 request list per
3370 "send a real flush for N flush requests");
3374 "Don't coalesce contiguous requests");
3378 "how many I/O requests we have received");
3382 "how many I/O requests have been completed");
3387 "how many I/O requests queued but not yet pushed");
3392 "how many I/O requests completed with error status");
3413 "how many times we have run out of requests");
3417 "maximum outstanding requests (negotiated)");
3422 "maximum number of pages per requests (negotiated)");
3714 /* Prevent new requests being issued until we fix things up. */