Add 5 splat tests for list handling
This commit is contained in:
Brian Behlendorf
parent
4c18c39ecb
commit
d702c04ff1
|
|
@ -2,38 +2,172 @@
|
|||
#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;
|
||||
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))
|
||||
|
||||
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 int
|
||||
list_is_empty(list_t *list)
|
||||
{
|
||||
return list_empty(&list->list_head);
|
||||
}
|
||||
|
||||
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 *);
|
||||
static inline void
|
||||
list_link_init(list_node_t *node)
|
||||
{
|
||||
node->next = LIST_POISON1;
|
||||
node->prev = LIST_POISON2;
|
||||
}
|
||||
|
||||
void list_link_init(list_node_t *);
|
||||
void list_link_replace(list_node_t *, list_node_t *);
|
||||
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));
|
||||
|
||||
int list_link_active(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;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
list_prev(list_t *list, void *object)
|
||||
{
|
||||
list_node_t *node = list_d2l(list, object);
|
||||
|
||||
if (node->prev != &list->list_head)
|
||||
return list_object(list, node->prev);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int
|
||||
list_link_active(list_node_t *node)
|
||||
{
|
||||
return (node->next != LIST_POISON1) && (node->prev != LIST_POISON2);
|
||||
}
|
||||
|
||||
#endif /* SPL_LIST_H */
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ splat-objs += splat-time.o
|
|||
splat-objs += splat-vnode.o
|
||||
splat-objs += splat-kobj.o
|
||||
splat-objs += splat-atomic.o
|
||||
splat-objs += splat-list.o
|
||||
|
||||
splatmodule := splat.ko
|
||||
splatmoduledir := @kmoduledir@/kernel/lib/
|
||||
|
|
|
|||
|
|
@ -607,6 +607,7 @@ splat_init(void)
|
|||
SPLAT_SUBSYSTEM_INIT(vnode);
|
||||
SPLAT_SUBSYSTEM_INIT(kobj);
|
||||
SPLAT_SUBSYSTEM_INIT(atomic);
|
||||
SPLAT_SUBSYSTEM_INIT(list);
|
||||
|
||||
dev = MKDEV(SPLAT_MAJOR, 0);
|
||||
if ((rc = register_chrdev_region(dev, SPLAT_MINORS, SPLAT_NAME)))
|
||||
|
|
@ -653,6 +654,7 @@ splat_fini(void)
|
|||
cdev_del(&splat_cdev);
|
||||
unregister_chrdev_region(dev, SPLAT_MINORS);
|
||||
|
||||
SPLAT_SUBSYSTEM_FINI(list);
|
||||
SPLAT_SUBSYSTEM_FINI(atomic);
|
||||
SPLAT_SUBSYSTEM_FINI(kobj);
|
||||
SPLAT_SUBSYSTEM_FINI(vnode);
|
||||
|
|
|
|||
|
|
@ -61,6 +61,7 @@
|
|||
#include <sys/types.h>
|
||||
#include <sys/kobj.h>
|
||||
#include <sys/atomic.h>
|
||||
#include <sys/list.h>
|
||||
#include <linux/cdev.h>
|
||||
|
||||
#include "spl-device.h"
|
||||
|
|
@ -203,6 +204,7 @@ splat_subsystem_t * splat_time_init(void);
|
|||
splat_subsystem_t *splat_vnode_init(void);
|
||||
splat_subsystem_t *splat_kobj_init(void);
|
||||
splat_subsystem_t *splat_atomic_init(void);
|
||||
splat_subsystem_t *splat_list_init(void);
|
||||
|
||||
void splat_condvar_fini(splat_subsystem_t *);
|
||||
void splat_kmem_fini(splat_subsystem_t *);
|
||||
|
|
@ -215,6 +217,7 @@ void splat_time_fini(splat_subsystem_t *);
|
|||
void splat_vnode_fini(splat_subsystem_t *);
|
||||
void splat_kobj_fini(splat_subsystem_t *);
|
||||
void splat_atomic_fini(splat_subsystem_t *);
|
||||
void splat_list_fini(splat_subsystem_t *);
|
||||
|
||||
int splat_condvar_id(void);
|
||||
int splat_kmem_id(void);
|
||||
|
|
@ -227,5 +230,6 @@ int splat_time_id(void);
|
|||
int splat_vnode_id(void);
|
||||
int splat_kobj_id(void);
|
||||
int splat_atomic_id(void);
|
||||
int splat_list_id(void);
|
||||
|
||||
#endif /* _SPLAT_INTERNAL_H */
|
||||
|
|
|
|||
|
|
@ -0,0 +1,407 @@
|
|||
/*
|
||||
* 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;
|
||||
}
|
||||
Loading…
Reference in New Issue