Skip to contentSkip to conversation

fs-backend fixes and improvements

PATCH New Stefano Stabellini 1 participant 1 message Mar 11, 2009

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 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.

---

tools/fs-back/Makefile +1 -1
diff -r cff29d694a89 tools/fs-back/Makefile
@@ -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
 
tools/fs-back/fs-backend.c +182 -144

448 lines not on this page · raw message

tools/fs-back/fs-backend.h +9 -1
diff -r cff29d694a89 tools/fs-back/fs-backend.h
@@ -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
tools/fs-back/fs-debug.h new file +12 -0
diff -r cff29d694a89 tools/fs-back/fs-debug.h
@@ -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__*/
tools/fs-back/fs-ops.c +62 -50

412 lines not on this page · raw message

tools/fs-back/fs-xenbus.c +65 -10

135 lines not on this page · raw message

tools/fs-back/sys-queue.h new file +1 -0
diff -r cff29d694a89 tools/fs-back/sys-queue.h
@@ -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_ */

xen/include/public/io/fsif.h +2 -1
diff -r cff29d694a89 xen/include/public/io/fsif.h
@@ -185,7 +185,8 @@
 
 #define STATE_INITIALISED     "init"
 #define STATE_READY           "ready"
-
+#define STATE_CLOSING         "closing"
+#define STATE_CLOSED          "closed"
 
 
 #endif