#define _SPL_LIST_H
#include <sys/types.h>
+#include <linux/list.h>
-typedef struct list_node {
- struct list_node *list_next;
- struct list_node *list_prev;
-} list_node_t;
+/* NOTE: We have implemented the Solaris list API in terms of the native
+ * linux API. This has certain advantages in terms of leveraging the linux
+ * list debugging infrastructure, but it also means that the internals of a
+ * list differ slightly than on Solaris. This is not a problem as long as
+ * all callers stick to the published API. The two major differences are:
+ *
+ * 1) A list_node_t is mapped to a linux list_head struct which changes
+ * the name of the list_next/list_prev pointers to next/prev respectively.
+ *
+ * 2) A list_node_t which is not attached to a list on Solaris is denoted
+ * by having its list_next/list_prev pointers set to NULL. Under linux
+ * the next/prev pointers are set to LIST_POISON1 and LIST_POISON2
+ * respectively. At this moment this only impacts the implementation
+ * of the list_link_init() and list_link_active() functions.
+ */
+
+typedef struct list_head list_node_t;
typedef struct list {
- size_t list_size;
- size_t list_offset;
- struct list_node list_head;
+ size_t list_size;
+ size_t list_offset;
+ list_node_t list_head;
} list_t;
-void list_create(list_t *, size_t, size_t);
-void list_destroy(list_t *);
+#define list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset))
+#define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset))
+
+static inline int
+list_is_empty(list_t *list)
+{
+ return list_empty(&list->list_head);
+}
+
+static inline void
+list_link_init(list_node_t *node)
+{
+ node->next = LIST_POISON1;
+ node->prev = LIST_POISON2;
+}
+
+static inline void
+list_create(list_t *list, size_t size, size_t offset)
+{
+ ASSERT(list);
+ ASSERT(size > 0);
+ ASSERT(size >= offset + sizeof(list_node_t));
+
+ list->list_size = size;
+ list->list_offset = offset;
+ INIT_LIST_HEAD(&list->list_head);
+}
+
+static inline void
+list_destroy(list_t *list)
+{
+ ASSERT(list);
+ ASSERT(list_is_empty(list));
+
+ list_del(&list->list_head);
+}
+
+static inline void
+list_insert_head(list_t *list, void *object)
+{
+ list_add(list_d2l(list, object), &list->list_head);
+}
+
+static inline void
+list_insert_tail(list_t *list, void *object)
+{
+ list_add_tail(list_d2l(list, object), &list->list_head);
+}
+
+static inline void
+list_insert_after(list_t *list, void *object, void *nobject)
+{
+ if (object == NULL)
+ list_insert_head(list, nobject);
+ else
+ list_add(list_d2l(list, nobject), list_d2l(list, object));
+}
+
+static inline void
+list_insert_before(list_t *list, void *object, void *nobject)
+{
+ if (object == NULL)
+ list_insert_tail(list, nobject);
+ else
+ list_add_tail(list_d2l(list, nobject), list_d2l(list, object));
+}
+
+static inline void
+list_remove(list_t *list, void *object)
+{
+ ASSERT(!list_is_empty(list));
+ list_del(list_d2l(list, object));
+}
+
+static inline void *
+list_remove_head(list_t *list)
+{
+ list_node_t *head = list->list_head.next;
+ if (head == &list->list_head)
+ return NULL;
+
+ list_del(head);
+ return list_object(list, head);
+}
+
+static inline void *
+list_remove_tail(list_t *list)
+{
+ list_node_t *tail = list->list_head.prev;
+ if (tail == &list->list_head)
+ return NULL;
+
+ list_del(tail);
+ return list_object(list, tail);
+}
+
+static inline void *
+list_head(list_t *list)
+{
+ if (list_is_empty(list))
+ return NULL;
+
+ return list_object(list, list->list_head.next);
+}
+
+static inline void *
+list_tail(list_t *list)
+{
+ if (list_is_empty(list))
+ return NULL;
+
+ return list_object(list, list->list_head.prev);
+}
+
+static inline void *
+list_next(list_t *list, void *object)
+{
+ list_node_t *node = list_d2l(list, object);
+
+ if (node->next != &list->list_head)
+ return list_object(list, node->next);
+
+ return NULL;
+}
-void list_insert_after(list_t *, void *, void *);
-void list_insert_before(list_t *, void *, void *);
-void list_insert_head(list_t *, void *);
-void list_insert_tail(list_t *, void *);
-void list_remove(list_t *, void *);
-void *list_remove_head(list_t *);
-void *list_remove_tail(list_t *);
+static inline void *
+list_prev(list_t *list, void *object)
+{
+ list_node_t *node = list_d2l(list, object);
-void *list_head(list_t *);
-void *list_tail(list_t *);
-void *list_next(list_t *, void *);
-void *list_prev(list_t *, void *);
-int list_is_empty(list_t *);
+ if (node->prev != &list->list_head)
+ return list_object(list, node->prev);
-void list_link_init(list_node_t *);
-void list_link_replace(list_node_t *, list_node_t *);
+ return NULL;
+}
-int list_link_active(list_node_t *);
+static inline int
+list_link_active(list_node_t *node)
+{
+ return (node->next != LIST_POISON1) && (node->prev != LIST_POISON2);
+}
#endif /* SPL_LIST_H */
--- /dev/null
+/*
+ * This file is part of the SPL: Solaris Porting Layer.
+ *
+ * Copyright (c) 2008 Lawrence Livermore National Security, LLC.
+ * Produced at Lawrence Livermore National Laboratory
+ * Written by:
+ * Brian Behlendorf <behlendorf1@llnl.gov>,
+ * Herb Wartens <wartens2@llnl.gov>,
+ * Jim Garlick <garlick@llnl.gov>
+ * UCRL-CODE-235197
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "splat-internal.h"
+
+#define SPLAT_SUBSYSTEM_LIST 0x0c00
+#define SPLAT_LIST_NAME "list"
+#define SPLAT_LIST_DESC "Kernel List Tests"
+
+#define SPLAT_LIST_TEST1_ID 0x0c01
+#define SPLAT_LIST_TEST1_NAME "create/destroy"
+#define SPLAT_LIST_TEST1_DESC "Create/destroy Test"
+
+#define SPLAT_LIST_TEST2_ID 0x0c02
+#define SPLAT_LIST_TEST2_NAME "insert/remove head"
+#define SPLAT_LIST_TEST2_DESC "Insert/remove head Test"
+
+#define SPLAT_LIST_TEST3_ID 0x0c03
+#define SPLAT_LIST_TEST3_NAME "insert/remove tail"
+#define SPLAT_LIST_TEST3_DESC "Insert/remove tail Test"
+
+#define SPLAT_LIST_TEST4_ID 0x0c04
+#define SPLAT_LIST_TEST4_NAME "insert_after"
+#define SPLAT_LIST_TEST4_DESC "Insert_after Test"
+
+#define SPLAT_LIST_TEST5_ID 0x0c05
+#define SPLAT_LIST_TEST5_NAME "insert_before"
+#define SPLAT_LIST_TEST5_DESC "Insert_before Test"
+
+#define SPLAT_LIST_TEST6_ID 0x0c06
+#define SPLAT_LIST_TEST6_NAME "remove"
+#define SPLAT_LIST_TEST6_DESC "Remove Test"
+
+
+/* It is important that li_node is not the first element, this
+ * ensures the list_d2l/list_object macros are working correctly. */
+typedef struct list_item {
+ int li_data;
+ list_node_t li_node;
+} list_item_t;
+
+#define LIST_ORDER_STACK 0
+#define LIST_ORDER_QUEUE 1
+
+static int
+splat_list_test1(struct file *file, void *arg)
+{
+ list_t list;
+
+ splat_vprint(file, SPLAT_LIST_TEST1_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ if (!list_is_empty(&list)) {
+ splat_vprint(file, SPLAT_LIST_TEST1_NAME,
+ "New list NOT empty%s\n", "");
+ /* list_destroy() intentionally skipped to avoid assert */
+ return -EEXIST;
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST1_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ /* Validate the list has been destroyed */
+ if (list_link_active(&list.list_head)) {
+ splat_vprint(file, SPLAT_LIST_TEST1_NAME,
+ "Destroyed list still active%s", "");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static int
+splat_list_validate(list_t *list, int size, int order, int mult)
+{
+ list_item_t *li;
+ int i;
+
+ /* Walk all items in list from head to verify stack or queue
+ * ordering. We bound the for loop by size+1 to ensure that
+ * we still terminate if there is list corruption. We also
+ * intentionally make things a little more complex than they
+ * need to be by using list_head/list_next for queues, and
+ * list_tail/list_prev for stacks. This is simply done for
+ * coverage and to ensure these function are working right.
+ */
+ for (i = 0, li = (order ? list_head(list) : list_tail(list));
+ i < size + 1 && li != NULL;
+ i++, li = (order ? list_next(list, li) : list_prev(list, li)))
+ if (li->li_data != i * mult)
+ return -EIDRM;
+
+ if (i != size)
+ return -E2BIG;
+
+ return 0;
+}
+
+static int
+splat_list_test2(struct file *file, void *arg)
+{
+ list_t list;
+ list_item_t *li;
+ int i, list_size = 8, rc = 0;
+
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ /* Insert all items at the list head to form a stack */
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME,
+ "Adding %d items to list head\n", list_size);
+ for (i = 0; i < list_size; i++) {
+ li = kmem_alloc(sizeof(list_item_t), KM_SLEEP);
+ if (li == NULL) {
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ list_link_init(&li->li_node);
+ li->li_data = i;
+ list_insert_head(&list, li);
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME,
+ "Validating %d item list is a stack\n", list_size);
+ rc = splat_list_validate(&list, list_size, LIST_ORDER_STACK, 1);
+ if (rc)
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME,
+ "List validation failed, %d\n", rc);
+out:
+ /* Remove all items */
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME,
+ "Removing %d items from list head\n", list_size);
+ while ((li = list_remove_head(&list)))
+ kmem_free(li, sizeof(list_item_t));
+
+ splat_vprint(file, SPLAT_LIST_TEST2_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ return rc;
+}
+
+static int
+splat_list_test3(struct file *file, void *arg)
+{
+ list_t list;
+ list_item_t *li;
+ int i, list_size = 8, rc = 0;
+
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ /* Insert all items at the list tail to form a queue */
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME,
+ "Adding %d items to list tail\n", list_size);
+ for (i = 0; i < list_size; i++) {
+ li = kmem_alloc(sizeof(list_item_t), KM_SLEEP);
+ if (li == NULL) {
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ list_link_init(&li->li_node);
+ li->li_data = i;
+ list_insert_tail(&list, li);
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME,
+ "Validating %d item list is a queue\n", list_size);
+ rc = splat_list_validate(&list, list_size, LIST_ORDER_QUEUE, 1);
+ if (rc)
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME,
+ "List validation failed, %d\n", rc);
+out:
+ /* Remove all items */
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME,
+ "Removing %d items from list tail\n", list_size);
+ while ((li = list_remove_tail(&list)))
+ kmem_free(li, sizeof(list_item_t));
+
+ splat_vprint(file, SPLAT_LIST_TEST3_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ return rc;
+}
+
+static int
+splat_list_test4(struct file *file, void *arg)
+{
+ list_t list;
+ list_item_t *li_new, *li_last = NULL;
+ int i, list_size = 8, rc = 0;
+
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ /* Insert all items after the last item to form a queue */
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME,
+ "Adding %d items each after the last item\n", list_size);
+ for (i = 0; i < list_size; i++) {
+ li_new = kmem_alloc(sizeof(list_item_t), KM_SLEEP);
+ if (li_new == NULL) {
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ list_link_init(&li_new->li_node);
+ li_new->li_data = i;
+ list_insert_after(&list, li_last, li_new);
+ li_last = li_new;
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME,
+ "Validating %d item list is a queue\n", list_size);
+ rc = splat_list_validate(&list, list_size, LIST_ORDER_QUEUE, 1);
+ if (rc)
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME,
+ "List validation failed, %d\n", rc);
+out:
+ /* Remove all items */
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME,
+ "Removing %d items from list tail\n", list_size);
+ while ((li_new = list_remove_head(&list)))
+ kmem_free(li_new, sizeof(list_item_t));
+
+ splat_vprint(file, SPLAT_LIST_TEST4_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ return rc;
+}
+
+static int
+splat_list_test5(struct file *file, void *arg)
+{
+ list_t list;
+ list_item_t *li_new, *li_last = NULL;
+ int i, list_size = 8, rc = 0;
+
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ /* Insert all items before the last item to form a stack */
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME,
+ "Adding %d items each before the last item\n", list_size);
+ for (i = 0; i < list_size; i++) {
+ li_new = kmem_alloc(sizeof(list_item_t), KM_SLEEP);
+ if (li_new == NULL) {
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ list_link_init(&li_new->li_node);
+ li_new->li_data = i;
+ list_insert_before(&list, li_last, li_new);
+ li_last = li_new;
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME,
+ "Validating %d item list is a queue\n", list_size);
+ rc = splat_list_validate(&list, list_size, LIST_ORDER_STACK, 1);
+ if (rc)
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME,
+ "List validation failed, %d\n", rc);
+out:
+ /* Remove all items */
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME,
+ "Removing %d items from list tail\n", list_size);
+ while ((li_new = list_remove_tail(&list)))
+ kmem_free(li_new, sizeof(list_item_t));
+
+ splat_vprint(file, SPLAT_LIST_TEST5_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ return rc;
+}
+
+static int
+splat_list_test6(struct file *file, void *arg)
+{
+ list_t list;
+ list_item_t *li, *li_prev;
+ int i, list_size = 8, rc = 0;
+
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME, "Creating list\n%s", "");
+ list_create(&list, sizeof(list_item_t), offsetof(list_item_t, li_node));
+
+ /* Insert all items at the list tail to form a queue */
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME,
+ "Adding %d items to list tail\n", list_size);
+ for (i = 0; i < list_size; i++) {
+ li = kmem_alloc(sizeof(list_item_t), KM_SLEEP);
+ if (li == NULL) {
+ rc = -ENOMEM;
+ goto out;
+ }
+
+ list_link_init(&li->li_node);
+ li->li_data = i;
+ list_insert_tail(&list, li);
+ }
+
+ /* Remove all odd items from the queue */
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME,
+ "Removing %d odd items from the list\n", list_size / 2);
+ for (li = list_head(&list); li != NULL; li = list_next(&list, li)) {
+ if (li->li_data % 2 == 1) {
+ li_prev = list_prev(&list, li);
+ list_remove(&list, li);
+ li = li_prev;
+ }
+ }
+
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME, "Validating %d item "
+ "list is a queue of only even elements\n", list_size / 2);
+ rc = splat_list_validate(&list, list_size / 2, LIST_ORDER_QUEUE, 2);
+ if (rc)
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME,
+ "List validation failed, %d\n", rc);
+out:
+ /* Remove all items */
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME,
+ "Removing %d items from list tail\n", list_size / 2);
+ while ((li = list_remove_tail(&list)))
+ kmem_free(li, sizeof(list_item_t));
+
+ splat_vprint(file, SPLAT_LIST_TEST6_NAME, "Destroying list\n%s", "");
+ list_destroy(&list);
+
+ return rc;
+}
+
+splat_subsystem_t *
+splat_list_init(void)
+{
+ splat_subsystem_t *sub;
+
+ sub = kmalloc(sizeof(*sub), GFP_KERNEL);
+ if (sub == NULL)
+ return NULL;
+
+ memset(sub, 0, sizeof(*sub));
+ strncpy(sub->desc.name, SPLAT_LIST_NAME, SPLAT_NAME_SIZE);
+ strncpy(sub->desc.desc, SPLAT_LIST_DESC, SPLAT_DESC_SIZE);
+ INIT_LIST_HEAD(&sub->subsystem_list);
+ INIT_LIST_HEAD(&sub->test_list);
+ spin_lock_init(&sub->test_lock);
+ sub->desc.id = SPLAT_SUBSYSTEM_LIST;
+
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST1_NAME, SPLAT_LIST_TEST1_DESC,
+ SPLAT_LIST_TEST1_ID, splat_list_test1);
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST2_NAME, SPLAT_LIST_TEST2_DESC,
+ SPLAT_LIST_TEST2_ID, splat_list_test2);
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST3_NAME, SPLAT_LIST_TEST3_DESC,
+ SPLAT_LIST_TEST3_ID, splat_list_test3);
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST4_NAME, SPLAT_LIST_TEST4_DESC,
+ SPLAT_LIST_TEST4_ID, splat_list_test4);
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST5_NAME, SPLAT_LIST_TEST5_DESC,
+ SPLAT_LIST_TEST5_ID, splat_list_test5);
+ SPLAT_TEST_INIT(sub, SPLAT_LIST_TEST6_NAME, SPLAT_LIST_TEST6_DESC,
+ SPLAT_LIST_TEST6_ID, splat_list_test6);
+
+ return sub;
+}
+
+void
+splat_list_fini(splat_subsystem_t *sub)
+{
+ ASSERT(sub);
+
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST6_ID);
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST5_ID);
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST4_ID);
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST3_ID);
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST2_ID);
+ SPLAT_TEST_FINI(sub, SPLAT_LIST_TEST1_ID);
+
+ kfree(sub);
+}
+
+int
+splat_list_id(void)
+{
+ return SPLAT_SUBSYSTEM_LIST;
+}
projects / spl / commitdiff