File Manager

003 File Manager

Current Path: /usr/src/sys/contrib/openzfs/include/os/linux/spl/sys

usr / src / sys / contrib / openzfs / include / os / linux / spl / sys /

📁 ..
📄 Makefile.am(799 B)
📄 acl.h(4.14 KB)
📄 atomic.h(3.3 KB)
📄 byteorder.h(2.27 KB)
📄 callb.h(1.72 KB)
📄 callo.h(2.06 KB)
📄 cmn_err.h(1.4 KB)
📄 condvar.h(4.71 KB)
📄 console.h(1.11 KB)
📄 cred.h(2.09 KB)
📄 ctype.h(1.07 KB)
📄 debug.h(5.71 KB)
📄 disp.h(1.19 KB)
📄 dkio.h(1.38 KB)
📄 errno.h(1.67 KB)
📄 fcntl.h(1.13 KB)
📄 file.h(2.09 KB)
📄 inttypes.h(1.05 KB)
📄 isa_defs.h(4.95 KB)
📄 kmem.h(6.11 KB)
📄 kmem_cache.h(8.58 KB)
📄 kstat.h(7.47 KB)
📄 list.h(5.12 KB)
📄 mod_os.h(1.07 KB)
📄 mutex.h(5.21 KB)
📄 param.h(1.22 KB)
📄 proc.h(1.31 KB)
📄 processor.h(1.12 KB)
📄 procfs_list.h(2.14 KB)
📄 random.h(1.28 KB)
📄 rwlock.h(4.68 KB)
📄 shrinker.h(3.32 KB)
📄 sid.h(1.62 KB)
📄 signal.h(1.73 KB)
📄 simd.h(1.1 KB)
📄 stat.h(1.07 KB)
📄 strings.h(1.13 KB)
📄 sunddi.h(1.97 KB)
📄 sysmacros.h(5.68 KB)
📄 systeminfo.h(1.36 KB)
📄 taskq.h(5.62 KB)
📄 thread.h(2.31 KB)
📄 time.h(3 KB)
📄 timer.h(2.73 KB)
📄 trace.h(5.88 KB)
📄 trace_spl.h(966 B)
📄 trace_taskq.h(2.42 KB)
📄 tsd.h(1.44 KB)
📄 types.h(1.66 KB)
📄 types32.h(1.18 KB)
📄 uio.h(4.31 KB)
📄 user.h(1.47 KB)
📄 vfs.h(1.48 KB)
📄 vmem.h(4.17 KB)
📄 vmsystm.h(2.32 KB)
📄 vnode.h(3.25 KB)
📄 wait.h(1.63 KB)
📄 zmod.h(2.74 KB)
📄 zone.h(1.2 KB)

Editing: list.h

/*
 *  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 <behlendorf1@llnl.gov>.
 *  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 <http://www.gnu.org/licenses/>.
 */

#ifndef _SPL_LIST_H
#define	_SPL_LIST_H

#include <sys/types.h>
#include <sys/debug.h>
#include <linux/list.h>

/*
 * 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;
	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 */

003 File Manager

Editing: list.h

Upload File

Create Folder