diff --git a/include/os/freebsd/spl/sys/list_impl.h b/include/os/freebsd/spl/sys/list_impl.h index 09b70232e8ee..06a5c6d1dbc6 100644 --- a/include/os/freebsd/spl/sys/list_impl.h +++ b/include/os/freebsd/spl/sys/list_impl.h @@ -1,51 +1,50 @@ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or https://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef _SYS_LIST_IMPL_H #define _SYS_LIST_IMPL_H #include #ifdef __cplusplus extern "C" { #endif struct list_node { struct list_node *list_next; struct list_node *list_prev; }; struct list { - size_t list_size; size_t list_offset; struct list_node list_head; }; #ifdef __cplusplus } #endif #endif /* _SYS_LIST_IMPL_H */ diff --git a/include/os/linux/spl/sys/list.h b/include/os/linux/spl/sys/list.h index 80300df15abe..046a75e19353 100644 --- a/include/os/linux/spl/sys/list.h +++ b/include/os/linux/spl/sys/list.h @@ -1,209 +1,209 @@ /* * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC. * Copyright (C) 2007 The Regents of the University of California. * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). * Written by Brian Behlendorf . * UCRL-CODE-235197 * * This file is part of the SPL, Solaris Porting Layer. * * The SPL 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. * * The SPL 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 the SPL. If not, see . */ #ifndef _SPL_LIST_H #define _SPL_LIST_H #include #include #include /* * NOTE: I 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; list_node_t list_head; } 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) { - list->list_size = size; + (void) size; + list->list_offset = offset; INIT_LIST_HEAD(&list->list_head); } static inline void list_destroy(list_t *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) { 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) { EQUIV(node->next == LIST_POISON1, node->prev == LIST_POISON2); return (node->next != LIST_POISON1); } static inline void spl_list_move_tail(list_t *dst, list_t *src) { list_splice_init(&src->list_head, dst->list_head.prev); } #define list_move_tail(dst, src) spl_list_move_tail(dst, src) static inline void list_link_replace(list_node_t *old_node, list_node_t *new_node) { new_node->next = old_node->next; new_node->prev = old_node->prev; old_node->prev->next = new_node; old_node->next->prev = new_node; list_link_init(old_node); } #endif /* SPL_LIST_H */ diff --git a/lib/libspl/include/sys/list_impl.h b/lib/libspl/include/sys/list_impl.h index 24c1ceb2a9fa..629db34da067 100644 --- a/lib/libspl/include/sys/list_impl.h +++ b/lib/libspl/include/sys/list_impl.h @@ -1,51 +1,50 @@ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or https://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef _SYS_LIST_IMPL_H #define _SYS_LIST_IMPL_H #include #ifdef __cplusplus extern "C" { #endif struct list_node { struct list_node *next; struct list_node *prev; }; struct list { - size_t list_size; size_t list_offset; struct list_node list_head; }; #ifdef __cplusplus } #endif #endif /* _SYS_LIST_IMPL_H */ diff --git a/lib/libspl/list.c b/lib/libspl/list.c index 24403698627c..aaa71dc73c98 100644 --- a/lib/libspl/list.c +++ b/lib/libspl/list.c @@ -1,243 +1,243 @@ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or https://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Generic doubly-linked list implementation */ #include #include #include #include #include #define list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset)) #define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset)) #define list_empty(a) ((a)->list_head.next == &(a)->list_head) #define list_insert_after_node(list, node, object) { \ list_node_t *lnew = list_d2l(list, object); \ lnew->prev = (node); \ lnew->next = (node)->next; \ (node)->next->prev = lnew; \ (node)->next = lnew; \ } #define list_insert_before_node(list, node, object) { \ list_node_t *lnew = list_d2l(list, object); \ lnew->next = (node); \ lnew->prev = (node)->prev; \ (node)->prev->next = lnew; \ (node)->prev = lnew; \ } #define list_remove_node(node) \ (node)->prev->next = (node)->next; \ (node)->next->prev = (node)->prev; \ (node)->next = (node)->prev = NULL 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; + (void) size; + list->list_offset = offset; list->list_head.next = list->list_head.prev = &list->list_head; } void list_destroy(list_t *list) { list_node_t *node = &list->list_head; ASSERT(list); ASSERT(list->list_head.next == node); ASSERT(list->list_head.prev == node); node->next = node->prev = NULL; } void list_insert_after(list_t *list, void *object, void *nobject) { if (object == NULL) { list_insert_head(list, nobject); } else { list_node_t *lold = list_d2l(list, object); list_insert_after_node(list, lold, nobject); } } void list_insert_before(list_t *list, void *object, void *nobject) { if (object == NULL) { list_insert_tail(list, nobject); } else { list_node_t *lold = list_d2l(list, object); list_insert_before_node(list, lold, nobject); } } void list_insert_head(list_t *list, void *object) { list_node_t *lold = &list->list_head; list_insert_after_node(list, lold, object); } void list_insert_tail(list_t *list, void *object) { list_node_t *lold = &list->list_head; list_insert_before_node(list, lold, object); } void list_remove(list_t *list, void *object) { list_node_t *lold = list_d2l(list, object); ASSERT(!list_empty(list)); ASSERT(lold->next != NULL); list_remove_node(lold); } void * list_remove_head(list_t *list) { list_node_t *head = list->list_head.next; if (head == &list->list_head) return (NULL); list_remove_node(head); return (list_object(list, head)); } void * list_remove_tail(list_t *list) { list_node_t *tail = list->list_head.prev; if (tail == &list->list_head) return (NULL); list_remove_node(tail); return (list_object(list, tail)); } void * list_head(list_t *list) { if (list_empty(list)) return (NULL); return (list_object(list, list->list_head.next)); } void * list_tail(list_t *list) { if (list_empty(list)) return (NULL); return (list_object(list, list->list_head.prev)); } 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_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); } /* * Insert src list after dst list. Empty src list thereafter. */ void list_move_tail(list_t *dst, list_t *src) { list_node_t *dstnode = &dst->list_head; list_node_t *srcnode = &src->list_head; - ASSERT(dst->list_size == src->list_size); ASSERT(dst->list_offset == src->list_offset); if (list_empty(src)) return; dstnode->prev->next = srcnode->next; srcnode->next->prev = dstnode->prev; dstnode->prev = srcnode->prev; srcnode->prev->next = dstnode; /* empty src list */ srcnode->next = srcnode->prev = srcnode; } void list_link_replace(list_node_t *lold, list_node_t *lnew) { ASSERT(list_link_active(lold)); ASSERT(!list_link_active(lnew)); lnew->next = lold->next; lnew->prev = lold->prev; lold->prev->next = lnew; lold->next->prev = lnew; lold->next = lold->prev = NULL; } void list_link_init(list_node_t *ln) { ln->next = NULL; ln->prev = NULL; } int list_link_active(list_node_t *ln) { EQUIV(ln->next == NULL, ln->prev == NULL); return (ln->next != NULL); } int list_is_empty(list_t *list) { return (list_empty(list)); } diff --git a/module/os/freebsd/spl/list.c b/module/os/freebsd/spl/list.c index ab6049cfbd43..56432050fdc6 100644 --- a/module/os/freebsd/spl/list.c +++ b/module/os/freebsd/spl/list.c @@ -1,243 +1,243 @@ /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or https://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Generic doubly-linked list implementation */ #include #include #include #include #include #define list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset)) #define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset)) #define list_empty(a) ((a)->list_head.list_next == &(a)->list_head) #define list_insert_after_node(list, node, object) { \ list_node_t *lnew = list_d2l(list, object); \ lnew->list_prev = (node); \ lnew->list_next = (node)->list_next; \ (node)->list_next->list_prev = lnew; \ (node)->list_next = lnew; \ } #define list_insert_before_node(list, node, object) { \ list_node_t *lnew = list_d2l(list, object); \ lnew->list_next = (node); \ lnew->list_prev = (node)->list_prev; \ (node)->list_prev->list_next = lnew; \ (node)->list_prev = lnew; \ } #define list_remove_node(node) \ (node)->list_prev->list_next = (node)->list_next; \ (node)->list_next->list_prev = (node)->list_prev; \ (node)->list_next = (node)->list_prev = NULL void list_create(list_t *list, size_t size, size_t offset) { ASSERT3P(list, !=, NULL); ASSERT3U(size, >=, offset + sizeof (list_node_t)); - list->list_size = size; + (void) size; + list->list_offset = offset; list->list_head.list_next = list->list_head.list_prev = &list->list_head; } void list_destroy(list_t *list) { list_node_t *node = &list->list_head; ASSERT3P(list, !=, NULL); ASSERT3P(list->list_head.list_next, ==, node); ASSERT3P(list->list_head.list_prev, ==, node); node->list_next = node->list_prev = NULL; } void list_insert_after(list_t *list, void *object, void *nobject) { if (object == NULL) { list_insert_head(list, nobject); } else { list_node_t *lold = list_d2l(list, object); list_insert_after_node(list, lold, nobject); } } void list_insert_before(list_t *list, void *object, void *nobject) { if (object == NULL) { list_insert_tail(list, nobject); } else { list_node_t *lold = list_d2l(list, object); list_insert_before_node(list, lold, nobject); } } void list_insert_head(list_t *list, void *object) { list_node_t *lold = &list->list_head; list_insert_after_node(list, lold, object); } void list_insert_tail(list_t *list, void *object) { list_node_t *lold = &list->list_head; list_insert_before_node(list, lold, object); } void list_remove(list_t *list, void *object) { list_node_t *lold = list_d2l(list, object); ASSERT(!list_empty(list)); ASSERT3P(lold->list_next, !=, NULL); list_remove_node(lold); } void * list_remove_head(list_t *list) { list_node_t *head = list->list_head.list_next; if (head == &list->list_head) return (NULL); list_remove_node(head); return (list_object(list, head)); } void * list_remove_tail(list_t *list) { list_node_t *tail = list->list_head.list_prev; if (tail == &list->list_head) return (NULL); list_remove_node(tail); return (list_object(list, tail)); } void * list_head(list_t *list) { if (list_empty(list)) return (NULL); return (list_object(list, list->list_head.list_next)); } void * list_tail(list_t *list) { if (list_empty(list)) return (NULL); return (list_object(list, list->list_head.list_prev)); } void * list_next(list_t *list, void *object) { list_node_t *node = list_d2l(list, object); if (node->list_next != &list->list_head) return (list_object(list, node->list_next)); return (NULL); } void * list_prev(list_t *list, void *object) { list_node_t *node = list_d2l(list, object); if (node->list_prev != &list->list_head) return (list_object(list, node->list_prev)); return (NULL); } /* * Insert src list after dst list. Empty src list thereafter. */ void list_move_tail(list_t *dst, list_t *src) { list_node_t *dstnode = &dst->list_head; list_node_t *srcnode = &src->list_head; - ASSERT3U(dst->list_size, ==, src->list_size); ASSERT3U(dst->list_offset, ==, src->list_offset); if (list_empty(src)) return; dstnode->list_prev->list_next = srcnode->list_next; srcnode->list_next->list_prev = dstnode->list_prev; dstnode->list_prev = srcnode->list_prev; srcnode->list_prev->list_next = dstnode; /* empty src list */ srcnode->list_next = srcnode->list_prev = srcnode; } void list_link_replace(list_node_t *lold, list_node_t *lnew) { ASSERT(list_link_active(lold)); ASSERT(!list_link_active(lnew)); lnew->list_next = lold->list_next; lnew->list_prev = lold->list_prev; lold->list_prev->list_next = lnew; lold->list_next->list_prev = lnew; lold->list_next = lold->list_prev = NULL; } void list_link_init(list_node_t *link) { link->list_next = NULL; link->list_prev = NULL; } int list_link_active(list_node_t *link) { EQUIV(link->list_next == NULL, link->list_prev == NULL); return (link->list_next != NULL); } int list_is_empty(list_t *list) { return (list_empty(list)); }