|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH] fs-backend fixes and improvements
Hi all,
at the moment fs-backend has quite a few problems, among which:
- it is multi-threaded, one thread per connection, but it never deletes
any thread when a connection closes;
- it uses aio but it doesn't properly initialize aio requests.
Since we are already using aio, we don't really need to create a new
thread per connection, so my first change is to make fs-backend
single-threaded, using signals to get notified by aio when a request is
completed.
I am also adding a watch on xenstore per connection to detect when a
connection closes and properly cancel outstanding aio requests and
free any related resources.
Finally this patch replaces all the printf with a compile time
conditional FS_DEBUG, so we are not forced to have all those debugging
messages on production systems.
Signed-off-by: Stefano Stabellini <stefano.stabellini@xxxxxxxxxxxxx>
---
diff -r cff29d694a89 tools/fs-back/Makefile
--- a/tools/fs-back/Makefile Thu Mar 05 17:50:05 2009 +0000
+++ b/tools/fs-back/Makefile Wed Mar 11 18:13:15 2009 +0000
@@ -16,7 +16,7 @@
LIBS := -L. -L.. -L../lib
LIBS += $(LDFLAGS_libxenctrl)
LIBS += $(LDFLAGS_libxenstore)
-LIBS += -lpthread -lrt
+LIBS += -lrt
OBJS := fs-xenbus.o fs-ops.o
diff -r cff29d694a89 tools/fs-back/fs-backend.c
--- a/tools/fs-back/fs-backend.c Thu Mar 05 17:50:05 2009 +0000
+++ b/tools/fs-back/fs-backend.c Wed Mar 11 18:13:15 2009 +0000
@@ -3,105 +3,68 @@
#include <string.h>
#include <assert.h>
#include <malloc.h>
-#include <pthread.h>
#include <xenctrl.h>
#include <aio.h>
#include <sys/mman.h>
#include <sys/select.h>
#include <xen/io/ring.h>
+#include "sys-queue.h"
#include "fs-backend.h"
+#include "fs-debug.h"
struct xs_handle *xsh = NULL;
static struct fs_export *fs_exports = NULL;
static int export_id = 0;
static int mount_id = 0;
+static LIST_HEAD(mount_requests_head, fs_mount) mount_requests_head;
-static void dispatch_response(struct fs_mount *mount, int priv_req_id)
+static void free_mount_request(struct fs_mount *mount);
+
+static void dispatch_response(struct fs_request *request)
{
int i;
struct fs_op *op;
- struct fs_request *req = &mount->requests[priv_req_id];
for(i=0;;i++)
{
op = fsops[i];
/* We should dispatch a response before reaching the end of the array
*/
assert(op != NULL);
- if(op->type == req->req_shadow.type)
+ if(op->type == request->req_shadow.type)
{
- printf("Found op for type=%d\n", op->type);
+ FS_DEBUG("Found op for type=%d\n", op->type);
/* There needs to be a response handler */
assert(op->response_handler != NULL);
- op->response_handler(mount, req);
+ op->response_handler(request->mount, request);
break;
}
}
- req->active = 0;
- add_id_to_freelist(priv_req_id, mount->freelist);
+ request->active = 0;
+ add_id_to_freelist(request->id, request->mount->freelist);
}
-static void handle_aio_events(struct fs_mount *mount)
+static void handle_aio_event(struct fs_request *request)
{
- int fd, ret, count, i, notify;
- evtchn_port_t port;
- /* AIO control block for the evtchn file destriptor */
- struct aiocb evtchn_cb;
- const struct aiocb * cb_list[mount->nr_entries];
- int request_ids[mount->nr_entries];
+ int ret, notify;
- /* Prepare the AIO control block for evtchn */
- fd = xc_evtchn_fd(mount->evth);
- bzero(&evtchn_cb, sizeof(struct aiocb));
- evtchn_cb.aio_fildes = fd;
- evtchn_cb.aio_nbytes = sizeof(port);
- evtchn_cb.aio_buf = &port;
- assert(aio_read(&evtchn_cb) == 0);
+ FS_DEBUG("handle_aio_event: mount %s request %d\n",
request->mount->frontend, request->id);
+ if (request->active < 0) {
+ request->mount->nr_entries++;
+ if (!request->mount->nr_entries)
+ free_mount_request(request->mount);
+ return;
+ }
-wait_again:
- /* Create list of active AIO requests */
- count = 0;
- for(i=0; i<mount->nr_entries; i++)
- if(mount->requests[i].active)
- {
- cb_list[count] = &mount->requests[i].aiocb;
- request_ids[count] = i;
- count++;
- }
- /* Add the event channel at the end of the list. Event channel needs to be
- * handled last as it exits this function. */
- cb_list[count] = &evtchn_cb;
- request_ids[count] = -1;
- count++;
+ ret = aio_error(&request->aiocb);
+ if(ret != EINPROGRESS && ret != ECANCELED)
+ dispatch_response(request);
- /* Block till an AIO requset finishes, or we get an event */
- while(1) {
- int ret = aio_suspend(cb_list, count, NULL);
- if (!ret)
- break;
- assert(errno == EINTR);
- }
- for(i=0; i<count; i++)
- if(aio_error(cb_list[i]) != EINPROGRESS)
- {
- if(request_ids[i] >= 0)
- dispatch_response(mount, request_ids[i]);
- else
- goto read_event_channel;
- }
-
- RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&mount->ring, notify);
- printf("Pushed responces and notify=%d\n", notify);
+ RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&request->mount->ring, notify);
+ FS_DEBUG("Pushed responces and notify=%d\n", notify);
if(notify)
- xc_evtchn_notify(mount->evth, mount->local_evtchn);
-
- goto wait_again;
-
-read_event_channel:
- assert(aio_return(&evtchn_cb) == sizeof(evtchn_port_t));
- assert(xc_evtchn_unmask(mount->evth, mount->local_evtchn) >= 0);
+ xc_evtchn_notify(request->mount->evth, request->mount->local_evtchn);
}
-
static void allocate_request_array(struct fs_mount *mount)
{
@@ -116,6 +79,7 @@
for(i=0; i< nr_entries; i++)
{
requests[i].active = 0;
+ requests[i].mount = mount;
add_id_to_freelist(i, freelist);
}
mount->requests = requests;
@@ -123,73 +87,91 @@
}
-static void *handle_mount(void *data)
+static void handle_mount(struct fs_mount *mount)
{
int more, notify;
- struct fs_mount *mount = (struct fs_mount *)data;
-
- printf("Starting a thread for mount: %d\n", mount->mount_id);
- allocate_request_array(mount);
+ int nr_consumed=0;
+ RING_IDX cons, rp;
+ struct fsif_request *req;
- for(;;)
+moretodo:
+ rp = mount->ring.sring->req_prod;
+ xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
+
+ while ((cons = mount->ring.req_cons) != rp)
{
- int nr_consumed=0;
- RING_IDX cons, rp;
- struct fsif_request *req;
+ int i;
+ struct fs_op *op;
- handle_aio_events(mount);
-moretodo:
- rp = mount->ring.sring->req_prod;
- xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
+ FS_DEBUG("Got a request at %d (of %d)\n",
+ cons, RING_SIZE(&mount->ring));
+ req = RING_GET_REQUEST(&mount->ring, cons);
+ FS_DEBUG("Request type=%d\n", req->type);
+ for(i=0;;i++)
+ {
+ op = fsops[i];
+ if(op == NULL)
+ {
+ /* We've reached the end of the array, no appropirate
+ * handler found. Warn, ignore and continue. */
+ FS_DEBUG("WARN: Unknown request type: %d\n", req->type);
+ mount->ring.req_cons++;
+ break;
+ }
+ if(op->type == req->type)
+ {
+ /* There needs to be a dispatch handler */
+ assert(op->dispatch_handler != NULL);
+ op->dispatch_handler(mount, req);
+ break;
+ }
+ }
- while ((cons = mount->ring.req_cons) != rp)
- {
- int i;
- struct fs_op *op;
+ nr_consumed++;
+ }
+ FS_DEBUG("Backend consumed: %d requests\n", nr_consumed);
+ RING_FINAL_CHECK_FOR_REQUESTS(&mount->ring, more);
+ if(more) goto moretodo;
- printf("Got a request at %d (of %d)\n",
- cons, RING_SIZE(&mount->ring));
- req = RING_GET_REQUEST(&mount->ring, cons);
- printf("Request type=%d\n", req->type);
- for(i=0;;i++)
- {
- op = fsops[i];
- if(op == NULL)
- {
- /* We've reached the end of the array, no appropirate
- * handler found. Warn, ignore and continue. */
- printf("WARN: Unknown request type: %d\n", req->type);
- mount->ring.req_cons++;
- break;
- }
- if(op->type == req->type)
- {
- /* There needs to be a dispatch handler */
- assert(op->dispatch_handler != NULL);
- op->dispatch_handler(mount, req);
- break;
- }
- }
+ RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&mount->ring, notify);
+ FS_DEBUG("Pushed responces and notify=%d\n", notify);
+ if(notify)
+ xc_evtchn_notify(mount->evth, mount->local_evtchn);
+}
- nr_consumed++;
+static void terminate_mount_request(struct fs_mount *mount) {
+ int count = 0, i;
+
+ FS_DEBUG("terminate_mount_request %s\n", mount->frontend);
+ xenbus_write_backend_state(mount, STATE_CLOSING);
+
+ for(i=0; i<mount->nr_entries; i++)
+ if(mount->requests[i].active) {
+ mount->requests[i].active = -1;
+ aio_cancel(mount->requests[i].aiocb.aio_fildes,
&mount->requests[i].aiocb);
+ count--;
}
- printf("Backend consumed: %d requests\n", nr_consumed);
- RING_FINAL_CHECK_FOR_REQUESTS(&mount->ring, more);
- if(more) goto moretodo;
+ mount->nr_entries = count;
- RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&mount->ring, notify);
- printf("Pushed responces and notify=%d\n", notify);
- if(notify)
- xc_evtchn_notify(mount->evth, mount->local_evtchn);
- }
-
- printf("Destroying thread for mount: %d\n", mount->mount_id);
+ while (!xenbus_frontend_state_changed(mount, STATE_CLOSING));
+ xenbus_write_backend_state(mount, STATE_CLOSED);
+
xc_gnttab_munmap(mount->gnth, mount->ring.sring, 1);
xc_gnttab_close(mount->gnth);
xc_evtchn_unbind(mount->evth, mount->local_evtchn);
xc_evtchn_close(mount->evth);
+
+ if (!count)
+ free_mount_request(mount);
+}
+
+static void free_mount_request(struct fs_mount *mount) {
+ FS_DEBUG("free_mount_request %s\n", mount->frontend);
free(mount->frontend);
- pthread_exit(NULL);
+ free(mount->requests);
+ free(mount->freelist);
+ LIST_REMOVE (mount, entries);
+ free(mount);
}
static void handle_connection(int frontend_dom_id, int export_id, char
*frontend)
@@ -197,12 +179,11 @@
struct fs_mount *mount;
struct fs_export *export;
int evt_port;
- pthread_t handling_thread;
struct fsif_sring *sring;
uint32_t dom_ids[MAX_RING_SIZE];
int i;
- printf("Handling connection from dom=%d, for export=%d\n",
+ FS_DEBUG("Handling connection from dom=%d, for export=%d\n",
frontend_dom_id, export_id);
/* Try to find the export on the list */
export = fs_exports;
@@ -214,7 +195,7 @@
}
if(!export)
{
- printf("Could not find the export (the id is unknown).\n");
+ FS_DEBUG("Could not find the export (the id is unknown).\n");
return;
}
@@ -223,7 +204,7 @@
mount->export = export;
mount->mount_id = mount_id++;
xenbus_read_mount_request(mount, frontend);
- printf("Frontend found at: %s (gref=%d, evtchn=%d)\n",
+ FS_DEBUG("Frontend found at: %s (gref=%d, evtchn=%d)\n",
mount->frontend, mount->grefs[0], mount->remote_evtchn);
xenbus_write_backend_node(mount);
mount->evth = -1;
@@ -249,18 +230,29 @@
mount->nr_entries = mount->ring.nr_ents;
for (i = 0; i < MAX_FDS; i++)
mount->fds[i] = -1;
- xenbus_write_backend_ready(mount);
- pthread_create(&handling_thread, NULL, &handle_mount, mount);
+ LIST_INSERT_HEAD(&mount_requests_head, mount, entries);
+ xenbus_watch_frontend_state(mount);
+ xenbus_write_backend_state(mount, STATE_READY);
+
+ allocate_request_array(mount);
}
static void await_connections(void)
{
- int fd, ret, dom_id, export_id;
+ int fd, max_fd, ret, dom_id, export_id;
fd_set fds;
char **watch_paths;
unsigned int len;
char d;
+ struct fs_mount *pointer;
+ sigset_t enable;
+
+ sigemptyset(&enable);
+ sigaddset(&enable, SIGUSR2);
+ pthread_sigmask(SIG_BLOCK, &enable, NULL);
+
+ LIST_INIT (&mount_requests_head);
assert(xsh != NULL);
fd = xenbus_get_watch_fd();
@@ -268,28 +260,61 @@
do {
FD_ZERO(&fds);
FD_SET(fd, &fds);
- ret = select(fd+1, &fds, NULL, NULL, NULL);
- assert(ret == 1);
- watch_paths = xs_read_watch(xsh, &len);
- assert(len == 2);
- assert(strcmp(watch_paths[1], "conn-watch") == 0);
- dom_id = -1;
- export_id = -1;
- d = 0;
- printf("Path changed %s\n", watch_paths[0]);
- sscanf(watch_paths[0], WATCH_NODE"/%d/%d/fronten%c",
- &dom_id, &export_id, &d);
- if((dom_id >= 0) && (export_id >= 0) && d == 'd') {
- char *frontend = xs_read(xsh, XBT_NULL, watch_paths[0], NULL);
- if (frontend) {
- handle_connection(dom_id, export_id, frontend);
- xs_rm(xsh, XBT_NULL, watch_paths[0]);
- }
- }
-next_select:
- printf("Awaiting next connection.\n");
- /* TODO - we need to figure out what to free */
- free(watch_paths);
+ max_fd = fd;
+ LIST_FOREACH(pointer, &mount_requests_head, entries) {
+ int tfd = xc_evtchn_fd(pointer->evth);
+ FD_SET(tfd, &fds);
+ if (tfd > max_fd) max_fd = tfd;
+ }
+ pthread_sigmask(SIG_UNBLOCK, &enable, NULL);
+ ret = select(max_fd+1, &fds, NULL, NULL, NULL);
+ pthread_sigmask(SIG_BLOCK, &enable, NULL);
+ if (ret < 0 || errno == EINTR) continue;
+ if (FD_ISSET(fd, &fds)) {
+ watch_paths = xs_read_watch(xsh, &len);
+ if (!strcmp(watch_paths[XS_WATCH_TOKEN], "conn-watch")) {
+ dom_id = -1;
+ export_id = -1;
+ d = 0;
+ FS_DEBUG("Path changed %s\n", watch_paths[0]);
+ sscanf(watch_paths[XS_WATCH_PATH],
WATCH_NODE"/%d/%d/fronten%c",
+ &dom_id, &export_id, &d);
+ if((dom_id >= 0) && (export_id >= 0) && d == 'd') {
+ char *frontend = xs_read(xsh, XBT_NULL,
watch_paths[XS_WATCH_PATH], NULL);
+ if (frontend) {
+ handle_connection(dom_id, export_id, frontend);
+ xs_rm(xsh, XBT_NULL, watch_paths[XS_WATCH_PATH]);
+ }
+ }
+ } else if (!strcmp(watch_paths[XS_WATCH_TOKEN], "frontend-state"))
{
+ LIST_FOREACH(pointer, &mount_requests_head, entries) {
+ if (!strncmp(pointer->frontend,
watch_paths[XS_WATCH_PATH], strlen(pointer->frontend))) {
+ char *state = xenbus_read_frontend_state(pointer);
+ if (!state || strcmp(state, STATE_READY)) {
+ xenbus_unwatch_frontend_state(pointer);
+ terminate_mount_request(pointer);
+ }
+ free(state);
+ break;
+ }
+ }
+ } else {
+ FS_DEBUG("xenstore watch event unrecognized\n");
+ }
+ FS_DEBUG("Awaiting next connection.\n");
+ /* TODO - we need to figure out what to free */
+ free(watch_paths);
+ }
+ LIST_FOREACH(pointer, &mount_requests_head, entries) {
+ if (FD_ISSET(xc_evtchn_fd(pointer->evth), &fds)) {
+ evtchn_port_t port;
+ port = xc_evtchn_pending(pointer->evth);
+ if (port != -1) {
+ handle_mount(pointer);
+ xc_evtchn_unmask(pointer->evth, port);
+ }
+ }
+ }
} while (1);
}
@@ -312,10 +337,23 @@
return curr_export;
}
+static void aio_signal_handler(int signo, siginfo_t *info, void *context)
+{
+ struct fs_request *request = (struct fs_request*) info->si_value.sival_ptr;
+ int saved_errno = errno;
+ handle_aio_event(request);
+ errno = saved_errno;
+}
int main(void)
{
struct fs_export *export;
+ struct sigaction act;
+
+ sigfillset(&act.sa_mask);
+ act.sa_flags = SA_SIGINFO; /* do not restart syscalls to interrupt
select(); use sa_sigaction */
+ act.sa_sigaction = aio_signal_handler;
+ sigaction(SIGUSR2, &act, NULL);
/* Open the connection to XenStore first */
xsh = xs_domain_open();
diff -r cff29d694a89 tools/fs-back/fs-backend.h
--- a/tools/fs-back/fs-backend.h Thu Mar 05 17:50:05 2009 +0000
+++ b/tools/fs-back/fs-backend.h Wed Mar 11 18:13:15 2009 +0000
@@ -7,6 +7,7 @@
#include <xen/event_channel.h>
#include <xen/io/ring.h>
#include <xen/io/fsif.h>
+#include "sys-queue.h"
#define ROOT_NODE "backend/vfs"
#define EXPORTS_SUBNODE "exports"
@@ -25,6 +26,8 @@
struct fs_request
{
+ struct fs_mount *mount;
+ int id;
int active;
void *page; /* Pointer to mapped grant */
int count;
@@ -50,6 +53,7 @@
struct fs_request *requests;
unsigned short *freelist;
int fds[MAX_FDS];
+ LIST_ENTRY(fs_mount) entries;
};
@@ -61,7 +65,11 @@
int xenbus_get_watch_fd(void);
void xenbus_read_mount_request(struct fs_mount *mount, char *frontend);
void xenbus_write_backend_node(struct fs_mount *mount);
-void xenbus_write_backend_ready(struct fs_mount *mount);
+void xenbus_write_backend_state(struct fs_mount *mount, const char *state);
+int xenbus_frontend_state_changed(struct fs_mount *mount, const char
*oldstate);
+void xenbus_watch_frontend_state(struct fs_mount *mount);
+void xenbus_unwatch_frontend_state(struct fs_mount *mount);
+char* xenbus_read_frontend_state(struct fs_mount *mount);
/* File operations, implemented in fs-ops.c */
struct fs_op
diff -r cff29d694a89 tools/fs-back/fs-debug.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/fs-back/fs-debug.h Wed Mar 11 18:13:15 2009 +0000
@@ -0,0 +1,12 @@
+#ifndef __FS_DEBUG__
+#define __FS_DEBUG__
+
+// #define DEBUG 1
+
+#ifdef DEBUG
+#define FS_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while
(0)
+#else
+#define FS_DEBUG(fmt, ...) do { } while (0)
+#endif
+
+#endif /*__FS_DEBUG__*/
diff -r cff29d694a89 tools/fs-back/fs-ops.c
--- a/tools/fs-back/fs-ops.c Thu Mar 05 17:50:05 2009 +0000
+++ b/tools/fs-back/fs-ops.c Wed Mar 11 18:13:15 2009 +0000
@@ -14,6 +14,7 @@
#include <sys/mount.h>
#include <unistd.h>
#include "fs-backend.h"
+#include "fs-debug.h"
/* For debugging only */
#include <sys/time.h>
@@ -22,12 +23,11 @@
#define BUFFER_SIZE 1024
-
static unsigned short get_request(struct fs_mount *mount, struct fsif_request
*req)
{
unsigned short id = get_id_from_freelist(mount->freelist);
- printf("Private Request id: %d\n", id);
+ FS_DEBUG("Private Request id: %d\n", id);
memcpy(&mount->requests[id].req_shadow, req, sizeof(struct fsif_request));
mount->requests[id].active = 1;
@@ -54,7 +54,7 @@
fsif_response_t *rsp;
uint16_t req_id;
- printf("Dispatching file open operation (gref=%d).\n", req->u.fopen.gref);
+ FS_DEBUG("Dispatching file open operation (gref=%d).\n",
req->u.fopen.gref);
/* Read the request, and open file */
file_name = xc_gnttab_map_grant_ref(mount->gnth,
mount->dom_id,
@@ -62,13 +62,13 @@
PROT_READ);
req_id = req->id;
- printf("File open issued for %s\n", file_name);
+ FS_DEBUG("File open issued for %s\n", file_name);
assert(BUFFER_SIZE >
strlen(file_name) + strlen(mount->export->export_path) + 1);
snprintf(full_path, sizeof(full_path), "%s/%s",
mount->export->export_path, file_name);
assert(xc_gnttab_munmap(mount->gnth, file_name, 1) == 0);
- printf("Issuing open for %s\n", full_path);
+ FS_DEBUG("Issuing open for %s\n", full_path);
fd = get_fd(mount);
if (fd >= 0) {
int real_fd = open(full_path, O_RDWR);
@@ -77,7 +77,7 @@
else
{
mount->fds[fd] = real_fd;
- printf("Got FD: %d for real %d\n", fd, real_fd);
+ FS_DEBUG("Got FD: %d for real %d\n", fd, real_fd);
}
}
/* We can advance the request consumer index, from here on, the request
@@ -87,7 +87,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)fd;
@@ -100,7 +100,7 @@
fsif_response_t *rsp;
uint16_t req_id;
- printf("Dispatching file close operation (fd=%d).\n", req->u.fclose.fd);
+ FS_DEBUG("Dispatching file close operation (fd=%d).\n", req->u.fclose.fd);
req_id = req->id;
if (req->u.fclose.fd < MAX_FDS) {
@@ -109,7 +109,7 @@
mount->fds[req->u.fclose.fd] = -1;
} else
ret = -1;
- printf("Got ret: %d\n", ret);
+ FS_DEBUG("Got ret: %d\n", ret);
/* We can advance the request consumer index, from here on, the request
* should not be used (it may be overrinden by a response) */
mount->ring.req_cons++;
@@ -117,7 +117,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -143,7 +143,7 @@
PROT_WRITE);
req_id = req->id;
- printf("File read issued for FD=%d (len=%"PRIu64", offest=%"PRIu64")\n",
+ FS_DEBUG("File read issued for FD=%d (len=%"PRIu64", offest=%"PRIu64")\n",
req->u.fread.fd, req->u.fread.len, req->u.fread.offset);
if (req->u.fread.fd < MAX_FDS)
@@ -152,10 +152,11 @@
fd = -1;
priv_id = get_request(mount, req);
- printf("Private id is: %d\n", priv_id);
+ FS_DEBUG("Private id is: %d\n", priv_id);
priv_req = &mount->requests[priv_id];
priv_req->page = buf;
priv_req->count = count;
+ priv_req->id = priv_id;
/* Dispatch AIO read request */
bzero(&priv_req->aiocb, sizeof(struct aiocb));
@@ -163,6 +164,9 @@
priv_req->aiocb.aio_nbytes = req->u.fread.len;
priv_req->aiocb.aio_offset = req->u.fread.offset;
priv_req->aiocb.aio_buf = buf;
+ priv_req->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+ priv_req->aiocb.aio_sigevent.sigev_signo = SIGUSR2;
+ priv_req->aiocb.aio_sigevent.sigev_value.sival_ptr = priv_req;
assert(aio_read(&priv_req->aiocb) >= 0);
out:
@@ -185,7 +189,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
req_id = priv_req->req_shadow.id;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)aio_return(&priv_req->aiocb);
@@ -210,7 +214,7 @@
PROT_READ);
req_id = req->id;
- printf("File write issued for FD=%d (len=%"PRIu64", offest=%"PRIu64")\n",
+ FS_DEBUG("File write issued for FD=%d (len=%"PRIu64",
offest=%"PRIu64")\n",
req->u.fwrite.fd, req->u.fwrite.len, req->u.fwrite.offset);
if (req->u.fwrite.fd < MAX_FDS)
@@ -219,10 +223,11 @@
fd = -1;
priv_id = get_request(mount, req);
- printf("Private id is: %d\n", priv_id);
+ FS_DEBUG("Private id is: %d\n", priv_id);
priv_req = &mount->requests[priv_id];
priv_req->page = buf;
priv_req->count = count;
+ priv_req->id = priv_id;
/* Dispatch AIO write request */
bzero(&priv_req->aiocb, sizeof(struct aiocb));
@@ -230,6 +235,9 @@
priv_req->aiocb.aio_nbytes = req->u.fwrite.len;
priv_req->aiocb.aio_offset = req->u.fwrite.offset;
priv_req->aiocb.aio_buf = buf;
+ priv_req->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+ priv_req->aiocb.aio_sigevent.sigev_signo = SIGUSR2;
+ priv_req->aiocb.aio_sigevent.sigev_value.sival_ptr = priv_req;
assert(aio_write(&priv_req->aiocb) >= 0);
@@ -252,7 +260,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
req_id = priv_req->req_shadow.id;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)aio_return(&priv_req->aiocb);
@@ -273,7 +281,7 @@
else
fd = -1;
- printf("File stat issued for FD=%d\n", req->u.fstat.fd);
+ FS_DEBUG("File stat issued for FD=%d\n", req->u.fstat.fd);
/* We can advance the request consumer index, from here on, the request
* should not be used (it may be overrinden by a response) */
@@ -281,12 +289,12 @@
/* Stat, and create the response */
ret = fstat(fd, &stat);
- printf("Mode=%o, uid=%d, a_time=%ld\n",
+ FS_DEBUG("Mode=%o, uid=%d, a_time=%ld\n",
stat.st_mode, stat.st_uid, (long)stat.st_atime);
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->fstat.stat_ret = (uint32_t)ret;
@@ -320,7 +328,7 @@
req_id = req->id;
length = req->u.ftruncate.length;
- printf("File truncate issued for FD=%d, length=%"PRId64"\n",
req->u.ftruncate.fd, length);
+ FS_DEBUG("File truncate issued for FD=%d, length=%"PRId64"\n",
req->u.ftruncate.fd, length);
if (req->u.ftruncate.fd < MAX_FDS)
fd = mount->fds[req->u.ftruncate.fd];
@@ -336,7 +344,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -350,7 +358,7 @@
fsif_response_t *rsp;
uint16_t req_id;
- printf("Dispatching remove operation (gref=%d).\n", req->u.fremove.gref);
+ FS_DEBUG("Dispatching remove operation (gref=%d).\n", req->u.fremove.gref);
/* Read the request, and open file */
file_name = xc_gnttab_map_grant_ref(mount->gnth,
mount->dom_id,
@@ -358,15 +366,15 @@
PROT_READ);
req_id = req->id;
- printf("File remove issued for %s\n", file_name);
+ FS_DEBUG("File remove issued for %s\n", file_name);
assert(BUFFER_SIZE >
strlen(file_name) + strlen(mount->export->export_path) + 1);
snprintf(full_path, sizeof(full_path), "%s/%s",
mount->export->export_path, file_name);
assert(xc_gnttab_munmap(mount->gnth, file_name, 1) == 0);
- printf("Issuing remove for %s\n", full_path);
+ FS_DEBUG("Issuing remove for %s\n", full_path);
ret = remove(full_path);
- printf("Got ret: %d\n", ret);
+ FS_DEBUG("Got ret: %d\n", ret);
/* We can advance the request consumer index, from here on, the request
* should not be used (it may be overrinden by a response) */
mount->ring.req_cons++;
@@ -374,7 +382,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -390,7 +398,7 @@
fsif_response_t *rsp;
uint16_t req_id;
- printf("Dispatching rename operation (gref=%d).\n", req->u.fremove.gref);
+ FS_DEBUG("Dispatching rename operation (gref=%d).\n", req->u.fremove.gref);
/* Read the request, and open file */
buf = xc_gnttab_map_grant_ref(mount->gnth,
mount->dom_id,
@@ -400,7 +408,7 @@
req_id = req->id;
old_file_name = buf + req->u.frename.old_name_offset;
new_file_name = buf + req->u.frename.new_name_offset;
- printf("File rename issued for %s -> %s (buf=%s)\n",
+ FS_DEBUG("File rename issued for %s -> %s (buf=%s)\n",
old_file_name, new_file_name, buf);
assert(BUFFER_SIZE >
strlen(old_file_name) + strlen(mount->export->export_path) + 1);
@@ -411,9 +419,9 @@
snprintf(new_full_path, sizeof(new_full_path), "%s/%s",
mount->export->export_path, new_file_name);
assert(xc_gnttab_munmap(mount->gnth, buf, 1) == 0);
- printf("Issuing rename for %s -> %s\n", old_full_path, new_full_path);
+ FS_DEBUG("Issuing rename for %s -> %s\n", old_full_path, new_full_path);
ret = rename(old_full_path, new_full_path);
- printf("Got ret: %d\n", ret);
+ FS_DEBUG("Got ret: %d\n", ret);
/* We can advance the request consumer index, from here on, the request
* should not be used (it may be overrinden by a response) */
mount->ring.req_cons++;
@@ -421,7 +429,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -438,7 +446,7 @@
fsif_response_t *rsp;
uint16_t req_id;
- printf("Dispatching file create operation (gref=%d).\n",
req->u.fcreate.gref);
+ FS_DEBUG("Dispatching file create operation (gref=%d).\n",
req->u.fcreate.gref);
/* Read the request, and create file/directory */
mode = req->u.fcreate.mode;
directory = req->u.fcreate.directory;
@@ -448,7 +456,7 @@
PROT_READ);
req_id = req->id;
- printf("File create issued for %s\n", file_name);
+ FS_DEBUG("File create issued for %s\n", file_name);
assert(BUFFER_SIZE >
strlen(file_name) + strlen(mount->export->export_path) + 1);
snprintf(full_path, sizeof(full_path), "%s/%s",
@@ -460,12 +468,12 @@
if(directory)
{
- printf("Issuing create for directory: %s\n", full_path);
+ FS_DEBUG("Issuing create for directory: %s\n", full_path);
ret = mkdir(full_path, mode);
}
else
{
- printf("Issuing create for file: %s\n", full_path);
+ FS_DEBUG("Issuing create for file: %s\n", full_path);
ret = get_fd(mount);
if (ret >= 0) {
int real_fd = creat(full_path, mode);
@@ -474,15 +482,15 @@
else
{
mount->fds[ret] = real_fd;
- printf("Got FD: %d for real %d\n", ret, real_fd);
+ FS_DEBUG("Got FD: %d for real %d\n", ret, real_fd);
}
}
}
- printf("Got ret %d (errno=%d)\n", ret, errno);
+ FS_DEBUG("Got ret %d (errno=%d)\n", ret, errno);
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -499,7 +507,7 @@
DIR *dir;
struct dirent *dirent = NULL;
- printf("Dispatching list operation (gref=%d).\n", req->u.flist.gref);
+ FS_DEBUG("Dispatching list operation (gref=%d).\n", req->u.flist.gref);
/* Read the request, and list directory */
offset = req->u.flist.offset;
buf = file_name = xc_gnttab_map_grant_ref(mount->gnth,
@@ -508,7 +516,7 @@
PROT_READ | PROT_WRITE);
req_id = req->id;
- printf("Dir list issued for %s\n", file_name);
+ FS_DEBUG("Dir list issued for %s\n", file_name);
assert(BUFFER_SIZE >
strlen(file_name) + strlen(mount->export->export_path) + 1);
snprintf(full_path, sizeof(full_path), "%s/%s",
@@ -552,7 +560,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = ret_val;
@@ -566,7 +574,7 @@
uint16_t req_id;
int32_t mode;
- printf("Dispatching file chmod operation (fd=%d, mode=%o).\n",
+ FS_DEBUG("Dispatching file chmod operation (fd=%d, mode=%o).\n",
req->u.fchmod.fd, req->u.fchmod.mode);
req_id = req->id;
if (req->u.fchmod.fd < MAX_FDS)
@@ -583,7 +591,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -598,7 +606,7 @@
struct statvfs stat;
int64_t ret;
- printf("Dispatching fs space operation (gref=%d).\n", req->u.fspace.gref);
+ FS_DEBUG("Dispatching fs space operation (gref=%d).\n",
req->u.fspace.gref);
/* Read the request, and open file */
file_name = xc_gnttab_map_grant_ref(mount->gnth,
mount->dom_id,
@@ -606,13 +614,13 @@
PROT_READ);
req_id = req->id;
- printf("Fs space issued for %s\n", file_name);
+ FS_DEBUG("Fs space issued for %s\n", file_name);
assert(BUFFER_SIZE >
strlen(file_name) + strlen(mount->export->export_path) + 1);
snprintf(full_path, sizeof(full_path), "%s/%s",
mount->export->export_path, file_name);
assert(xc_gnttab_munmap(mount->gnth, file_name, 1) == 0);
- printf("Issuing fs space for %s\n", full_path);
+ FS_DEBUG("Issuing fs space for %s\n", full_path);
ret = statvfs(full_path, &stat);
if(ret >= 0)
ret = stat.f_bsize * stat.f_bfree;
@@ -624,7 +632,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)ret;
@@ -643,15 +651,19 @@
else
fd = -1;
- printf("File sync issued for FD=%d\n", req->u.fsync.fd);
+ FS_DEBUG("File sync issued for FD=%d\n", req->u.fsync.fd);
priv_id = get_request(mount, req);
- printf("Private id is: %d\n", priv_id);
+ FS_DEBUG("Private id is: %d\n", priv_id);
priv_req = &mount->requests[priv_id];
+ priv_req->id = priv_id;
/* Dispatch AIO read request */
bzero(&priv_req->aiocb, sizeof(struct aiocb));
priv_req->aiocb.aio_fildes = fd;
+ priv_req->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+ priv_req->aiocb.aio_sigevent.sigev_signo = SIGUSR2;
+ priv_req->aiocb.aio_sigevent.sigev_value.sival_ptr = priv_req;
assert(aio_fsync(O_SYNC, &priv_req->aiocb) >= 0);
@@ -669,7 +681,7 @@
/* Get a response from the ring */
rsp_idx = mount->ring.rsp_prod_pvt++;
req_id = priv_req->req_shadow.id;
- printf("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
+ FS_DEBUG("Writing response at: idx=%d, id=%d\n", rsp_idx, req_id);
rsp = RING_GET_RESPONSE(&mount->ring, rsp_idx);
rsp->id = req_id;
rsp->ret_val = (uint64_t)aio_return(&priv_req->aiocb);
diff -r cff29d694a89 tools/fs-back/fs-xenbus.c
--- a/tools/fs-back/fs-xenbus.c Thu Mar 05 17:50:05 2009 +0000
+++ b/tools/fs-back/fs-xenbus.c Wed Mar 11 18:13:15 2009 +0000
@@ -4,10 +4,12 @@
#include <stdarg.h>
#include <string.h>
#include <assert.h>
+#include <sys/select.h>
#include <xenctrl.h>
#include <xs.h>
#include <xen/io/fsif.h>
#include "fs-backend.h"
+#include "fs-debug.h"
static bool xenbus_printf(struct xs_handle *xsh,
@@ -25,7 +27,7 @@
snprintf(fullpath, sizeof(fullpath), "%s/%s", node, path);
vsnprintf(val, sizeof(val), fmt, args);
va_end(args);
- printf("xenbus_printf (%s) <= %s.\n", fullpath, val);
+ FS_DEBUG("xenbus_printf (%s) <= %s.\n", fullpath, val);
return xs_write(xsh, xbt, fullpath, val, strlen(val));
}
@@ -57,19 +59,19 @@
assert(xsh != NULL);
if(xsh == NULL)
{
- printf("Could not open connection to xenbus deamon.\n");
+ FS_DEBUG("Could not open connection to xenbus deamon.\n");
goto error_exit;
}
- printf("Connection to the xenbus deamon opened successfully.\n");
+ FS_DEBUG("Connection to the xenbus deamon opened successfully.\n");
/* Start transaction */
xst = xs_transaction_start(xsh);
if(xst == 0)
{
- printf("Could not start a transaction.\n");
+ FS_DEBUG("Could not start a transaction.\n");
goto error_exit;
}
- printf("XS transaction is %d\n", xst);
+ FS_DEBUG("XS transaction is %d\n", xst);
/* Create node string */
snprintf(node, sizeof(node), "%s/%d", EXPORTS_NODE, export->export_id);
@@ -78,7 +80,7 @@
if(!xenbus_printf(xsh, xst, node, "name", "%s", export->name))
{
- printf("Could not write the export node.\n");
+ FS_DEBUG("Could not write the export node.\n");
goto error_exit;
}
@@ -87,7 +89,7 @@
perms.perms = XS_PERM_READ;
if(!xs_set_permissions(xsh, xst, EXPORTS_NODE, &perms, 1))
{
- printf("Could not set permissions on the export node.\n");
+ FS_DEBUG("Could not set permissions on the export node.\n");
goto error_exit;
}
@@ -166,7 +168,7 @@
assert(xsh != NULL);
self_id = get_self_id();
- printf("Our own dom_id=%d\n", self_id);
+ FS_DEBUG("Our own dom_id=%d\n", self_id);
snprintf(node, sizeof(node), "%s/backend", mount->frontend);
snprintf(backend_node, sizeof(backend_node),
"/local/domain/%d/"ROOT_NODE"/%d",
self_id, mount->mount_id);
@@ -176,7 +178,7 @@
xs_write(xsh, XBT_NULL, node, STATE_INITIALISED,
strlen(STATE_INITIALISED));
}
-void xenbus_write_backend_ready(struct fs_mount *mount)
+void xenbus_write_backend_state(struct fs_mount *mount, const char *state)
{
char node[1024];
int self_id;
@@ -184,6 +186,59 @@
assert(xsh != NULL);
self_id = get_self_id();
snprintf(node, sizeof(node), ROOT_NODE"/%d/state", mount->mount_id);
- xs_write(xsh, XBT_NULL, node, STATE_READY, strlen(STATE_READY));
+ xs_write(xsh, XBT_NULL, node, state, strlen(state));
}
+void xenbus_watch_frontend_state(struct fs_mount *mount)
+{
+ int res;
+ char statepath[1024];
+
+ assert(xsh != NULL);
+ snprintf(statepath, sizeof(statepath), "%s/state", mount->frontend);
+ res = xs_watch(xsh, statepath, "frontend-state");
+ assert(res);
+}
+
+void xenbus_unwatch_frontend_state(struct fs_mount *mount)
+{
+ int res;
+ char statepath[1024];
+
+ assert(xsh != NULL);
+ snprintf(statepath, sizeof(statepath), "%s/state", mount->frontend);
+ res = xs_unwatch(xsh, statepath, "frontend-state");
+ assert(res);
+}
+
+int xenbus_frontend_state_changed(struct fs_mount *mount, const char *oldstate)
+{
+ unsigned int len;
+ char statepath[1024];
+ char *state = NULL;
+
+ assert(xsh != NULL);
+ snprintf(statepath, sizeof(statepath), "%s/state", mount->frontend);
+ state = xs_read(xsh, XBT_NULL, statepath, &len);
+ if (state && len > 0) {
+ if (strcmp(state, oldstate)) {
+ free(state);
+ return 1;
+ } else {
+ free(state);
+ return 0;
+ }
+ } else
+ return 1;
+}
+
+char* xenbus_read_frontend_state(struct fs_mount *mount)
+{
+ unsigned int len;
+ char statepath[1024];
+
+ assert(xsh != NULL);
+ snprintf(statepath, sizeof(statepath), "%s/state", mount->frontend);
+ return xs_read(xsh, XBT_NULL, statepath, &len);
+}
+
diff -r cff29d694a89 tools/fs-back/sys-queue.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/fs-back/sys-queue.h Wed Mar 11 18:13:15 2009 +0000
@@ -0,0 +1,338 @@
+/* $NetBSD: queue.h,v 1.45.14.1 2007/07/18 20:13:24 liamjfoy Exp $ */
+
+/*
+ * Qemu version: Copy from netbsd, removed debug code, removed some of
+ * the implementations. Left in lists, tail queues and circular queues.
+ */
+
+/*
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)queue.h 8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define _SYS_QUEUE_H_
+
+/*
+ * This file defines three types of data structures:
+ * lists, tail queues, and circular queues.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * A circle queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the list.
+ * A circle queue may be traversed in either direction, but has a more
+ * complex end of list detection.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+/*
+ * List definitions.
+ */
+#define LIST_HEAD(name, type) \
+struct name { \
+ struct type *lh_first; /* first element */ \
+}
+
+#define LIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define LIST_ENTRY(type) \
+struct { \
+ struct type *le_next; /* next element */ \
+ struct type **le_prev; /* address of previous next element */ \
+}
+
+/*
+ * List functions.
+ */
+#define LIST_INIT(head) do { \
+ (head)->lh_first = NULL; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do { \
+ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
+ (listelm)->field.le_next->field.le_prev = \
+ &(elm)->field.le_next; \
+ (listelm)->field.le_next = (elm); \
+ (elm)->field.le_prev = &(listelm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.le_prev = (listelm)->field.le_prev; \
+ (elm)->field.le_next = (listelm); \
+ *(listelm)->field.le_prev = (elm); \
+ (listelm)->field.le_prev = &(elm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.le_next = (head)->lh_first) != NULL) \
+ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
+ (head)->lh_first = (elm); \
+ (elm)->field.le_prev = &(head)->lh_first; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_REMOVE(elm, field) do { \
+ if ((elm)->field.le_next != NULL) \
+ (elm)->field.le_next->field.le_prev = \
+ (elm)->field.le_prev; \
+ *(elm)->field.le_prev = (elm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#define LIST_FOREACH(var, head, field) \
+ for ((var) = ((head)->lh_first); \
+ (var); \
+ (var) = ((var)->field.le_next))
+
+/*
+ * List access methods.
+ */
+#define LIST_EMPTY(head) ((head)->lh_first == NULL)
+#define LIST_FIRST(head) ((head)->lh_first)
+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+
+
+/*
+ * Tail queue definitions.
+ */
+#define _TAILQ_HEAD(name, type, qual) \
+struct name { \
+ qual type *tqh_first; /* first element */ \
+ qual type *qual *tqh_last; /* addr of last next element */ \
+}
+#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
+
+#define TAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).tqh_first }
+
+#define _TAILQ_ENTRY(type, qual) \
+struct { \
+ qual type *tqe_next; /* next element */ \
+ qual type *qual *tqe_prev; /* address of previous next element */\
+}
+#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
+
+/*
+ * Tail queue functions.
+ */
+#define TAILQ_INIT(head) do { \
+ (head)->tqh_first = NULL; \
+ (head)->tqh_last = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
+ (head)->tqh_first->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (head)->tqh_first = (elm); \
+ (elm)->field.tqe_prev = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.tqe_next = NULL; \
+ (elm)->field.tqe_prev = (head)->tqh_last; \
+ *(head)->tqh_last = (elm); \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
+ (elm)->field.tqe_next->field.tqe_prev = \
+ &(elm)->field.tqe_next; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (listelm)->field.tqe_next = (elm); \
+ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
+ (elm)->field.tqe_next = (listelm); \
+ *(listelm)->field.tqe_prev = (elm); \
+ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_REMOVE(head, elm, field) do { \
+ if (((elm)->field.tqe_next) != NULL) \
+ (elm)->field.tqe_next->field.tqe_prev = \
+ (elm)->field.tqe_prev; \
+ else \
+ (head)->tqh_last = (elm)->field.tqe_prev; \
+ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define TAILQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->tqh_first); \
+ (var); \
+ (var) = ((var)->field.tqe_next))
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
+ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));
\
+ (var); \
+ (var) = (*(((struct headname
*)((var)->field.tqe_prev))->tqh_last)))
+
+/*
+ * Tail queue access methods.
+ */
+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
+#define TAILQ_FIRST(head) ((head)->tqh_first)
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define TAILQ_LAST(head, headname) \
+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
+#define TAILQ_PREV(elm, headname, field) \
+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+
+/*
+ * Circular queue definitions.
+ */
+#define CIRCLEQ_HEAD(name, type) \
+struct name { \
+ struct type *cqh_first; /* first element */ \
+ struct type *cqh_last; /* last element */ \
+}
+
+#define CIRCLEQ_HEAD_INITIALIZER(head) \
+ { (void *)&head, (void *)&head }
+
+#define CIRCLEQ_ENTRY(type) \
+struct { \
+ struct type *cqe_next; /* next element */ \
+ struct type *cqe_prev; /* previous element */ \
+}
+
+/*
+ * Circular queue functions.
+ */
+#define CIRCLEQ_INIT(head) do { \
+ (head)->cqh_first = (void *)(head); \
+ (head)->cqh_last = (void *)(head); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm)->field.cqe_next; \
+ (elm)->field.cqe_prev = (listelm); \
+ if ((listelm)->field.cqe_next == (void *)(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (listelm)->field.cqe_next->field.cqe_prev = (elm); \
+ (listelm)->field.cqe_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
+ (elm)->field.cqe_next = (listelm); \
+ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
+ if ((listelm)->field.cqe_prev == (void *)(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (listelm)->field.cqe_prev->field.cqe_next = (elm); \
+ (listelm)->field.cqe_prev = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
+ (elm)->field.cqe_next = (head)->cqh_first; \
+ (elm)->field.cqe_prev = (void *)(head); \
+ if ((head)->cqh_last == (void *)(head)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (head)->cqh_first->field.cqe_prev = (elm); \
+ (head)->cqh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.cqe_next = (void *)(head); \
+ (elm)->field.cqe_prev = (head)->cqh_last; \
+ if ((head)->cqh_first == (void *)(head)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (head)->cqh_last->field.cqe_next = (elm); \
+ (head)->cqh_last = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_REMOVE(head, elm, field) do { \
+ if ((elm)->field.cqe_next == (void *)(head)) \
+ (head)->cqh_last = (elm)->field.cqe_prev; \
+ else \
+ (elm)->field.cqe_next->field.cqe_prev = \
+ (elm)->field.cqe_prev; \
+ if ((elm)->field.cqe_prev == (void *)(head)) \
+ (head)->cqh_first = (elm)->field.cqe_next; \
+ else \
+ (elm)->field.cqe_prev->field.cqe_next = \
+ (elm)->field.cqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define CIRCLEQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->cqh_first); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_next))
+
+#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
+ for ((var) = ((head)->cqh_last); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_prev))
+
+/*
+ * Circular queue access methods.
+ */
+#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
+#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
+#define CIRCLEQ_LAST(head) ((head)->cqh_last)
+#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
+#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
+
+#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
+ (((elm)->field.cqe_next == (void *)(head)) \
+ ? ((head)->cqh_first) \
+ : (elm->field.cqe_next))
+#define CIRCLEQ_LOOP_PREV(head, elm, field) \
+ (((elm)->field.cqe_prev == (void *)(head)) \
+ ? ((head)->cqh_last) \
+ : (elm->field.cqe_prev))
+
+#endif /* !_SYS_QUEUE_H_ */
diff -r cff29d694a89 xen/include/public/io/fsif.h
--- a/xen/include/public/io/fsif.h Thu Mar 05 17:50:05 2009 +0000
+++ b/xen/include/public/io/fsif.h Wed Mar 11 18:13:15 2009 +0000
@@ -185,7 +185,8 @@
#define STATE_INITIALISED "init"
#define STATE_READY "ready"
-
+#define STATE_CLOSING "closing"
+#define STATE_CLOSED "closed"
#endif
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |