mirror of
https://git.proxmox.com/git/mirror_zfs.git
synced 2024-12-24 18:39:34 +03:00
Refactor existing code
This change introduces no functional changes to the memory management
interfaces. It only restructures the existing codes by separating the
kmem, vmem, and kmem cache implementations in the separate source and
header files.
Splitting this functionality in to separate files required the addition
of spl_vmem_{init,fini}() and spl_kmem_cache_{initi,fini}() functions.
Additionally, several minor changes to the #include's were required to
accommodate the removal of extraneous header from kmem.h.
But again, while large this patch introduces no functional changes.
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
This commit is contained in:
Brian Behlendorf
parent
6ecf6d7228
commit
e5b9b344c7
@ -22,8 +22,8 @@
|
||||
* with the SPL. If not, see <http://www.gnu.org/licenses/>.
|
||||
\*****************************************************************************/
|
||||
|
||||
#ifndef _SPL_PROC_H
|
||||
#define _SPL_PROC_H
|
||||
#ifndef _SPL_PROC_COMPAT_H
|
||||
#define _SPL_PROC_COMPAT_H
|
||||
|
||||
#include <linux/proc_fs.h>
|
||||
|
||||
@ -32,4 +32,4 @@ extern struct proc_dir_entry *proc_spl_kstat;
|
||||
int spl_proc_init(void);
|
||||
void spl_proc_fini(void);
|
||||
|
||||
#endif /* SPL_PROC_H */
|
||||
#endif /* SPL_PROC_COMPAT_H */
|
||||
|
||||
@ -44,6 +44,7 @@ KERNEL_H = \
|
||||
$(top_srcdir)/include/sys/isa_defs.h \
|
||||
$(top_srcdir)/include/sys/kidmap.h \
|
||||
$(top_srcdir)/include/sys/kmem.h \
|
||||
$(top_srcdir)/include/sys/kmem_cache.h \
|
||||
$(top_srcdir)/include/sys/kobj.h \
|
||||
$(top_srcdir)/include/sys/kstat.h \
|
||||
$(top_srcdir)/include/sys/list.h \
|
||||
@ -94,6 +95,7 @@ KERNEL_H = \
|
||||
$(top_srcdir)/include/sys/varargs.h \
|
||||
$(top_srcdir)/include/sys/vfs.h \
|
||||
$(top_srcdir)/include/sys/vfs_opreg.h \
|
||||
$(top_srcdir)/include/sys/vmem.h \
|
||||
$(top_srcdir)/include/sys/vmsystm.h \
|
||||
$(top_srcdir)/include/sys/vnode.h \
|
||||
$(top_srcdir)/include/sys/zmod.h \
|
||||
|
||||
@ -25,19 +25,13 @@
|
||||
#ifndef _SPL_KMEM_H
|
||||
#define _SPL_KMEM_H
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/rwsem.h>
|
||||
#include <linux/hash.h>
|
||||
#include <linux/rbtree.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/vmsystm.h>
|
||||
#include <sys/kstat.h>
|
||||
#include <sys/taskq.h>
|
||||
|
||||
extern int kmem_debugging(void);
|
||||
extern char *kmem_vasprintf(const char *fmt, va_list ap);
|
||||
extern char *kmem_asprintf(const char *fmt, ...);
|
||||
extern char *strdup(const char *str);
|
||||
extern void strfree(char *str);
|
||||
|
||||
/*
|
||||
* Memory allocation interfaces
|
||||
@ -99,52 +93,6 @@ kmalloc_node_nofail(size_t size, gfp_t flags, int node)
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
vmalloc_nofail(size_t size, gfp_t flags)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
/*
|
||||
* Retry failed __vmalloc() allocations once every second. The
|
||||
* rational for the delay is that the likely failure modes are:
|
||||
*
|
||||
* 1) The system has completely exhausted memory, in which case
|
||||
* delaying 1 second for the memory reclaim to run is reasonable
|
||||
* to avoid thrashing the system.
|
||||
* 2) The system has memory but has exhausted the small virtual
|
||||
* address space available on 32-bit systems. Retrying the
|
||||
* allocation immediately will only result in spinning on the
|
||||
* virtual address space lock. It is better delay a second and
|
||||
* hope that another process will free some of the address space.
|
||||
* But the bottom line is there is not much we can actually do
|
||||
* since we can never safely return a failure and honor the
|
||||
* Solaris semantics.
|
||||
*/
|
||||
while (1) {
|
||||
ptr = __vmalloc(size, flags | __GFP_HIGHMEM, PAGE_KERNEL);
|
||||
if (unlikely((ptr == NULL) && (flags & __GFP_WAIT))) {
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
schedule_timeout(HZ);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
vzalloc_nofail(size_t size, gfp_t flags)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
ptr = vmalloc_nofail(size, flags);
|
||||
if (ptr)
|
||||
memset(ptr, 0, (size));
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_KMEM
|
||||
|
||||
/*
|
||||
@ -156,15 +104,9 @@ vzalloc_nofail(size_t size, gfp_t flags)
|
||||
# define kmem_alloc_used_sub(size) atomic64_sub(size, &kmem_alloc_used)
|
||||
# define kmem_alloc_used_read() atomic64_read(&kmem_alloc_used)
|
||||
# define kmem_alloc_used_set(size) atomic64_set(&kmem_alloc_used, size)
|
||||
# define vmem_alloc_used_add(size) atomic64_add(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_sub(size) atomic64_sub(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_read() atomic64_read(&vmem_alloc_used)
|
||||
# define vmem_alloc_used_set(size) atomic64_set(&vmem_alloc_used, size)
|
||||
|
||||
extern atomic64_t kmem_alloc_used;
|
||||
extern unsigned long long kmem_alloc_max;
|
||||
extern atomic64_t vmem_alloc_used;
|
||||
extern unsigned long long vmem_alloc_max;
|
||||
|
||||
# else /* HAVE_ATOMIC64_T */
|
||||
|
||||
@ -172,15 +114,9 @@ extern unsigned long long vmem_alloc_max;
|
||||
# define kmem_alloc_used_sub(size) atomic_sub(size, &kmem_alloc_used)
|
||||
# define kmem_alloc_used_read() atomic_read(&kmem_alloc_used)
|
||||
# define kmem_alloc_used_set(size) atomic_set(&kmem_alloc_used, size)
|
||||
# define vmem_alloc_used_add(size) atomic_add(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_sub(size) atomic_sub(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_read() atomic_read(&vmem_alloc_used)
|
||||
# define vmem_alloc_used_set(size) atomic_set(&vmem_alloc_used, size)
|
||||
|
||||
extern atomic_t kmem_alloc_used;
|
||||
extern unsigned long long kmem_alloc_max;
|
||||
extern atomic_t vmem_alloc_used;
|
||||
extern unsigned long long vmem_alloc_max;
|
||||
|
||||
# endif /* HAVE_ATOMIC64_T */
|
||||
|
||||
@ -204,16 +140,8 @@ extern unsigned long long vmem_alloc_max;
|
||||
__FUNCTION__, __LINE__, 1, nd)
|
||||
# define kmem_free(ptr, sz) kmem_free_track((ptr), (sz))
|
||||
|
||||
# define vmem_alloc(sz, fl) vmem_alloc_track((sz), (fl), \
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_zalloc(sz, fl) vmem_alloc_track((sz), (fl)|__GFP_ZERO,\
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_free(ptr, sz) vmem_free_track((ptr), (sz))
|
||||
|
||||
extern void *kmem_alloc_track(size_t, int, const char *, int, int, int);
|
||||
extern void kmem_free_track(const void *, size_t);
|
||||
extern void *vmem_alloc_track(size_t, int, const char *, int);
|
||||
extern void vmem_free_track(const void *, size_t);
|
||||
|
||||
# else /* DEBUG_KMEM_TRACKING */
|
||||
/*
|
||||
@ -233,16 +161,8 @@ extern void vmem_free_track(const void *, size_t);
|
||||
__FUNCTION__, __LINE__, 1, nd)
|
||||
# define kmem_free(ptr, sz) kmem_free_debug((ptr), (sz))
|
||||
|
||||
# define vmem_alloc(sz, fl) vmem_alloc_debug((sz), (fl), \
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_zalloc(sz, fl) vmem_alloc_debug((sz), (fl)|__GFP_ZERO,\
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_free(ptr, sz) vmem_free_debug((ptr), (sz))
|
||||
|
||||
extern void *kmem_alloc_debug(size_t, int, const char *, int, int, int);
|
||||
extern void kmem_free_debug(const void *, size_t);
|
||||
extern void *vmem_alloc_debug(size_t, int, const char *, int);
|
||||
extern void vmem_free_debug(const void *, size_t);
|
||||
|
||||
# endif /* DEBUG_KMEM_TRACKING */
|
||||
#else /* DEBUG_KMEM */
|
||||
@ -258,230 +178,12 @@ extern void vmem_free_debug(const void *, size_t);
|
||||
# define kmem_alloc_node(sz, fl, nd) kmalloc_node_nofail((sz), (fl), (nd))
|
||||
# define kmem_free(ptr, sz) ((void)(sz), kfree(ptr))
|
||||
|
||||
# define vmem_alloc(sz, fl) vmalloc_nofail((sz), (fl))
|
||||
# define vmem_zalloc(sz, fl) vzalloc_nofail((sz), (fl))
|
||||
# define vmem_free(ptr, sz) ((void)(sz), vfree(ptr))
|
||||
|
||||
#endif /* DEBUG_KMEM */
|
||||
|
||||
extern int kmem_debugging(void);
|
||||
extern char *kmem_vasprintf(const char *fmt, va_list ap);
|
||||
extern char *kmem_asprintf(const char *fmt, ...);
|
||||
extern char *strdup(const char *str);
|
||||
extern void strfree(char *str);
|
||||
|
||||
|
||||
/*
|
||||
* Slab allocation interfaces. The SPL slab differs from the standard
|
||||
* Linux SLAB or SLUB primarily in that each cache may be backed by slabs
|
||||
* allocated from the physical or virtal memory address space. The virtual
|
||||
* slabs allow for good behavior when allocation large objects of identical
|
||||
* size. This slab implementation also supports both constructors and
|
||||
* destructions which the Linux slab does not.
|
||||
*/
|
||||
enum {
|
||||
KMC_BIT_NOTOUCH = 0, /* Don't update ages */
|
||||
KMC_BIT_NODEBUG = 1, /* Default behavior */
|
||||
KMC_BIT_NOMAGAZINE = 2, /* XXX: Unsupported */
|
||||
KMC_BIT_NOHASH = 3, /* XXX: Unsupported */
|
||||
KMC_BIT_QCACHE = 4, /* XXX: Unsupported */
|
||||
KMC_BIT_KMEM = 5, /* Use kmem cache */
|
||||
KMC_BIT_VMEM = 6, /* Use vmem cache */
|
||||
KMC_BIT_SLAB = 7, /* Use Linux slab cache */
|
||||
KMC_BIT_OFFSLAB = 8, /* Objects not on slab */
|
||||
KMC_BIT_NOEMERGENCY = 9, /* Disable emergency objects */
|
||||
KMC_BIT_DEADLOCKED = 14, /* Deadlock detected */
|
||||
KMC_BIT_GROWING = 15, /* Growing in progress */
|
||||
KMC_BIT_REAPING = 16, /* Reaping in progress */
|
||||
KMC_BIT_DESTROY = 17, /* Destroy in progress */
|
||||
KMC_BIT_TOTAL = 18, /* Proc handler helper bit */
|
||||
KMC_BIT_ALLOC = 19, /* Proc handler helper bit */
|
||||
KMC_BIT_MAX = 20, /* Proc handler helper bit */
|
||||
};
|
||||
|
||||
/* kmem move callback return values */
|
||||
typedef enum kmem_cbrc {
|
||||
KMEM_CBRC_YES = 0, /* Object moved */
|
||||
KMEM_CBRC_NO = 1, /* Object not moved */
|
||||
KMEM_CBRC_LATER = 2, /* Object not moved, try again later */
|
||||
KMEM_CBRC_DONT_NEED = 3, /* Neither object is needed */
|
||||
KMEM_CBRC_DONT_KNOW = 4, /* Object unknown */
|
||||
} kmem_cbrc_t;
|
||||
|
||||
#define KMC_NOTOUCH (1 << KMC_BIT_NOTOUCH)
|
||||
#define KMC_NODEBUG (1 << KMC_BIT_NODEBUG)
|
||||
#define KMC_NOMAGAZINE (1 << KMC_BIT_NOMAGAZINE)
|
||||
#define KMC_NOHASH (1 << KMC_BIT_NOHASH)
|
||||
#define KMC_QCACHE (1 << KMC_BIT_QCACHE)
|
||||
#define KMC_KMEM (1 << KMC_BIT_KMEM)
|
||||
#define KMC_VMEM (1 << KMC_BIT_VMEM)
|
||||
#define KMC_SLAB (1 << KMC_BIT_SLAB)
|
||||
#define KMC_OFFSLAB (1 << KMC_BIT_OFFSLAB)
|
||||
#define KMC_NOEMERGENCY (1 << KMC_BIT_NOEMERGENCY)
|
||||
#define KMC_DEADLOCKED (1 << KMC_BIT_DEADLOCKED)
|
||||
#define KMC_GROWING (1 << KMC_BIT_GROWING)
|
||||
#define KMC_REAPING (1 << KMC_BIT_REAPING)
|
||||
#define KMC_DESTROY (1 << KMC_BIT_DESTROY)
|
||||
#define KMC_TOTAL (1 << KMC_BIT_TOTAL)
|
||||
#define KMC_ALLOC (1 << KMC_BIT_ALLOC)
|
||||
#define KMC_MAX (1 << KMC_BIT_MAX)
|
||||
|
||||
#define KMC_REAP_CHUNK INT_MAX
|
||||
#define KMC_DEFAULT_SEEKS 1
|
||||
|
||||
#define KMC_EXPIRE_AGE 0x1 /* Due to age */
|
||||
#define KMC_EXPIRE_MEM 0x2 /* Due to low memory */
|
||||
|
||||
#define KMC_RECLAIM_ONCE 0x1 /* Force a single shrinker pass */
|
||||
|
||||
extern unsigned int spl_kmem_cache_expire;
|
||||
extern struct list_head spl_kmem_cache_list;
|
||||
extern struct rw_semaphore spl_kmem_cache_sem;
|
||||
|
||||
#define SKM_MAGIC 0x2e2e2e2e
|
||||
#define SKO_MAGIC 0x20202020
|
||||
#define SKS_MAGIC 0x22222222
|
||||
#define SKC_MAGIC 0x2c2c2c2c
|
||||
|
||||
#define SPL_KMEM_CACHE_DELAY 15 /* Minimum slab release age */
|
||||
#define SPL_KMEM_CACHE_REAP 0 /* Default reap everything */
|
||||
#define SPL_KMEM_CACHE_OBJ_PER_SLAB 16 /* Target objects per slab */
|
||||
#define SPL_KMEM_CACHE_OBJ_PER_SLAB_MIN 1 /* Minimum objects per slab */
|
||||
#define SPL_KMEM_CACHE_ALIGN 8 /* Default object alignment */
|
||||
|
||||
#define POINTER_IS_VALID(p) 0 /* Unimplemented */
|
||||
#define POINTER_INVALIDATE(pp) /* Unimplemented */
|
||||
|
||||
typedef int (*spl_kmem_ctor_t)(void *, void *, int);
|
||||
typedef void (*spl_kmem_dtor_t)(void *, void *);
|
||||
typedef void (*spl_kmem_reclaim_t)(void *);
|
||||
|
||||
typedef struct spl_kmem_magazine {
|
||||
uint32_t skm_magic; /* Sanity magic */
|
||||
uint32_t skm_avail; /* Available objects */
|
||||
uint32_t skm_size; /* Magazine size */
|
||||
uint32_t skm_refill; /* Batch refill size */
|
||||
struct spl_kmem_cache *skm_cache; /* Owned by cache */
|
||||
unsigned long skm_age; /* Last cache access */
|
||||
unsigned int skm_cpu; /* Owned by cpu */
|
||||
void *skm_objs[0]; /* Object pointers */
|
||||
} spl_kmem_magazine_t;
|
||||
|
||||
typedef struct spl_kmem_obj {
|
||||
uint32_t sko_magic; /* Sanity magic */
|
||||
void *sko_addr; /* Buffer address */
|
||||
struct spl_kmem_slab *sko_slab; /* Owned by slab */
|
||||
struct list_head sko_list; /* Free object list linkage */
|
||||
} spl_kmem_obj_t;
|
||||
|
||||
typedef struct spl_kmem_slab {
|
||||
uint32_t sks_magic; /* Sanity magic */
|
||||
uint32_t sks_objs; /* Objects per slab */
|
||||
struct spl_kmem_cache *sks_cache; /* Owned by cache */
|
||||
struct list_head sks_list; /* Slab list linkage */
|
||||
struct list_head sks_free_list; /* Free object list */
|
||||
unsigned long sks_age; /* Last modify jiffie */
|
||||
uint32_t sks_ref; /* Ref count used objects */
|
||||
} spl_kmem_slab_t;
|
||||
|
||||
typedef struct spl_kmem_alloc {
|
||||
struct spl_kmem_cache *ska_cache; /* Owned by cache */
|
||||
int ska_flags; /* Allocation flags */
|
||||
taskq_ent_t ska_tqe; /* Task queue entry */
|
||||
} spl_kmem_alloc_t;
|
||||
|
||||
typedef struct spl_kmem_emergency {
|
||||
struct rb_node ske_node; /* Emergency tree linkage */
|
||||
void *ske_obj; /* Buffer address */
|
||||
} spl_kmem_emergency_t;
|
||||
|
||||
typedef struct spl_kmem_cache {
|
||||
uint32_t skc_magic; /* Sanity magic */
|
||||
uint32_t skc_name_size; /* Name length */
|
||||
char *skc_name; /* Name string */
|
||||
spl_kmem_magazine_t *skc_mag[NR_CPUS]; /* Per-CPU warm cache */
|
||||
uint32_t skc_mag_size; /* Magazine size */
|
||||
uint32_t skc_mag_refill; /* Magazine refill count */
|
||||
spl_kmem_ctor_t skc_ctor; /* Constructor */
|
||||
spl_kmem_dtor_t skc_dtor; /* Destructor */
|
||||
spl_kmem_reclaim_t skc_reclaim; /* Reclaimator */
|
||||
void *skc_private; /* Private data */
|
||||
void *skc_vmp; /* Unused */
|
||||
struct kmem_cache *skc_linux_cache; /* Linux slab cache if used */
|
||||
unsigned long skc_flags; /* Flags */
|
||||
uint32_t skc_obj_size; /* Object size */
|
||||
uint32_t skc_obj_align; /* Object alignment */
|
||||
uint32_t skc_slab_objs; /* Objects per slab */
|
||||
uint32_t skc_slab_size; /* Slab size */
|
||||
uint32_t skc_delay; /* Slab reclaim interval */
|
||||
uint32_t skc_reap; /* Slab reclaim count */
|
||||
atomic_t skc_ref; /* Ref count callers */
|
||||
taskqid_t skc_taskqid; /* Slab reclaim task */
|
||||
struct list_head skc_list; /* List of caches linkage */
|
||||
struct list_head skc_complete_list;/* Completely alloc'ed */
|
||||
struct list_head skc_partial_list; /* Partially alloc'ed */
|
||||
struct rb_root skc_emergency_tree; /* Min sized objects */
|
||||
spinlock_t skc_lock; /* Cache lock */
|
||||
wait_queue_head_t skc_waitq; /* Allocation waiters */
|
||||
uint64_t skc_slab_fail; /* Slab alloc failures */
|
||||
uint64_t skc_slab_create;/* Slab creates */
|
||||
uint64_t skc_slab_destroy;/* Slab destroys */
|
||||
uint64_t skc_slab_total; /* Slab total current */
|
||||
uint64_t skc_slab_alloc; /* Slab alloc current */
|
||||
uint64_t skc_slab_max; /* Slab max historic */
|
||||
uint64_t skc_obj_total; /* Obj total current */
|
||||
uint64_t skc_obj_alloc; /* Obj alloc current */
|
||||
uint64_t skc_obj_max; /* Obj max historic */
|
||||
uint64_t skc_obj_deadlock; /* Obj emergency deadlocks */
|
||||
uint64_t skc_obj_emergency; /* Obj emergency current */
|
||||
uint64_t skc_obj_emergency_max; /* Obj emergency max */
|
||||
} spl_kmem_cache_t;
|
||||
#define kmem_cache_t spl_kmem_cache_t
|
||||
|
||||
extern spl_kmem_cache_t *spl_kmem_cache_create(char *name, size_t size,
|
||||
size_t align, spl_kmem_ctor_t ctor, spl_kmem_dtor_t dtor,
|
||||
spl_kmem_reclaim_t reclaim, void *priv, void *vmp, int flags);
|
||||
extern void spl_kmem_cache_set_move(spl_kmem_cache_t *,
|
||||
kmem_cbrc_t (*)(void *, void *, size_t, void *));
|
||||
extern void spl_kmem_cache_destroy(spl_kmem_cache_t *skc);
|
||||
extern void *spl_kmem_cache_alloc(spl_kmem_cache_t *skc, int flags);
|
||||
extern void spl_kmem_cache_free(spl_kmem_cache_t *skc, void *obj);
|
||||
extern void spl_kmem_cache_reap_now(spl_kmem_cache_t *skc, int count);
|
||||
extern void spl_kmem_reap(void);
|
||||
|
||||
int spl_kmem_init(void);
|
||||
void spl_kmem_fini(void);
|
||||
|
||||
#define kmem_cache_create(name,size,align,ctor,dtor,rclm,priv,vmp,flags) \
|
||||
spl_kmem_cache_create(name,size,align,ctor,dtor,rclm,priv,vmp,flags)
|
||||
#define kmem_cache_set_move(skc, move) spl_kmem_cache_set_move(skc, move)
|
||||
#define kmem_cache_destroy(skc) spl_kmem_cache_destroy(skc)
|
||||
#define kmem_cache_alloc(skc, flags) spl_kmem_cache_alloc(skc, flags)
|
||||
#define kmem_cache_free(skc, obj) spl_kmem_cache_free(skc, obj)
|
||||
#define kmem_cache_reap_now(skc) \
|
||||
spl_kmem_cache_reap_now(skc, skc->skc_reap)
|
||||
#define kmem_reap() spl_kmem_reap()
|
||||
#define kmem_virt(ptr) (((ptr) >= (void *)VMALLOC_START) && \
|
||||
((ptr) < (void *)VMALLOC_END))
|
||||
|
||||
/*
|
||||
* Allow custom slab allocation flags to be set for KMC_SLAB based caches.
|
||||
* One use for this function is to ensure the __GFP_COMP flag is part of
|
||||
* the default allocation mask which ensures higher order allocations are
|
||||
* properly refcounted. This flag was added to the default ->allocflags
|
||||
* as of Linux 3.11.
|
||||
*/
|
||||
static inline void
|
||||
kmem_cache_set_allocflags(spl_kmem_cache_t *skc, gfp_t flags)
|
||||
{
|
||||
if (skc->skc_linux_cache == NULL)
|
||||
return;
|
||||
|
||||
#if defined(HAVE_KMEM_CACHE_ALLOCFLAGS)
|
||||
skc->skc_linux_cache->allocflags |= flags;
|
||||
#elif defined(HAVE_KMEM_CACHE_GFPFLAGS)
|
||||
skc->skc_linux_cache->gfpflags |= flags;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* _SPL_KMEM_H */
|
||||
|
||||
246
include/sys/kmem_cache.h
Normal file
246
include/sys/kmem_cache.h
Normal file
@ -0,0 +1,246 @@
|
||||
/*****************************************************************************\
|
||||
* 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.
|
||||
* For details, see <http://zfsonlinux.org/>.
|
||||
*
|
||||
* 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_KMEM_CACHE_H
|
||||
#define _SPL_KMEM_CACHE_H
|
||||
|
||||
#include <sys/taskq.h>
|
||||
|
||||
/*
|
||||
* Slab allocation interfaces. The SPL slab differs from the standard
|
||||
* Linux SLAB or SLUB primarily in that each cache may be backed by slabs
|
||||
* allocated from the physical or virtal memory address space. The virtual
|
||||
* slabs allow for good behavior when allocation large objects of identical
|
||||
* size. This slab implementation also supports both constructors and
|
||||
* destructions which the Linux slab does not.
|
||||
*/
|
||||
enum {
|
||||
KMC_BIT_NOTOUCH = 0, /* Don't update ages */
|
||||
KMC_BIT_NODEBUG = 1, /* Default behavior */
|
||||
KMC_BIT_NOMAGAZINE = 2, /* XXX: Unsupported */
|
||||
KMC_BIT_NOHASH = 3, /* XXX: Unsupported */
|
||||
KMC_BIT_QCACHE = 4, /* XXX: Unsupported */
|
||||
KMC_BIT_KMEM = 5, /* Use kmem cache */
|
||||
KMC_BIT_VMEM = 6, /* Use vmem cache */
|
||||
KMC_BIT_SLAB = 7, /* Use Linux slab cache */
|
||||
KMC_BIT_OFFSLAB = 8, /* Objects not on slab */
|
||||
KMC_BIT_NOEMERGENCY = 9, /* Disable emergency objects */
|
||||
KMC_BIT_DEADLOCKED = 14, /* Deadlock detected */
|
||||
KMC_BIT_GROWING = 15, /* Growing in progress */
|
||||
KMC_BIT_REAPING = 16, /* Reaping in progress */
|
||||
KMC_BIT_DESTROY = 17, /* Destroy in progress */
|
||||
KMC_BIT_TOTAL = 18, /* Proc handler helper bit */
|
||||
KMC_BIT_ALLOC = 19, /* Proc handler helper bit */
|
||||
KMC_BIT_MAX = 20, /* Proc handler helper bit */
|
||||
};
|
||||
|
||||
/* kmem move callback return values */
|
||||
typedef enum kmem_cbrc {
|
||||
KMEM_CBRC_YES = 0, /* Object moved */
|
||||
KMEM_CBRC_NO = 1, /* Object not moved */
|
||||
KMEM_CBRC_LATER = 2, /* Object not moved, try again later */
|
||||
KMEM_CBRC_DONT_NEED = 3, /* Neither object is needed */
|
||||
KMEM_CBRC_DONT_KNOW = 4, /* Object unknown */
|
||||
} kmem_cbrc_t;
|
||||
|
||||
#define KMC_NOTOUCH (1 << KMC_BIT_NOTOUCH)
|
||||
#define KMC_NODEBUG (1 << KMC_BIT_NODEBUG)
|
||||
#define KMC_NOMAGAZINE (1 << KMC_BIT_NOMAGAZINE)
|
||||
#define KMC_NOHASH (1 << KMC_BIT_NOHASH)
|
||||
#define KMC_QCACHE (1 << KMC_BIT_QCACHE)
|
||||
#define KMC_KMEM (1 << KMC_BIT_KMEM)
|
||||
#define KMC_VMEM (1 << KMC_BIT_VMEM)
|
||||
#define KMC_SLAB (1 << KMC_BIT_SLAB)
|
||||
#define KMC_OFFSLAB (1 << KMC_BIT_OFFSLAB)
|
||||
#define KMC_NOEMERGENCY (1 << KMC_BIT_NOEMERGENCY)
|
||||
#define KMC_DEADLOCKED (1 << KMC_BIT_DEADLOCKED)
|
||||
#define KMC_GROWING (1 << KMC_BIT_GROWING)
|
||||
#define KMC_REAPING (1 << KMC_BIT_REAPING)
|
||||
#define KMC_DESTROY (1 << KMC_BIT_DESTROY)
|
||||
#define KMC_TOTAL (1 << KMC_BIT_TOTAL)
|
||||
#define KMC_ALLOC (1 << KMC_BIT_ALLOC)
|
||||
#define KMC_MAX (1 << KMC_BIT_MAX)
|
||||
|
||||
#define KMC_REAP_CHUNK INT_MAX
|
||||
#define KMC_DEFAULT_SEEKS 1
|
||||
|
||||
#define KMC_EXPIRE_AGE 0x1 /* Due to age */
|
||||
#define KMC_EXPIRE_MEM 0x2 /* Due to low memory */
|
||||
|
||||
#define KMC_RECLAIM_ONCE 0x1 /* Force a single shrinker pass */
|
||||
|
||||
extern unsigned int spl_kmem_cache_expire;
|
||||
extern struct list_head spl_kmem_cache_list;
|
||||
extern struct rw_semaphore spl_kmem_cache_sem;
|
||||
|
||||
#define SKM_MAGIC 0x2e2e2e2e
|
||||
#define SKO_MAGIC 0x20202020
|
||||
#define SKS_MAGIC 0x22222222
|
||||
#define SKC_MAGIC 0x2c2c2c2c
|
||||
|
||||
#define SPL_KMEM_CACHE_DELAY 15 /* Minimum slab release age */
|
||||
#define SPL_KMEM_CACHE_REAP 0 /* Default reap everything */
|
||||
#define SPL_KMEM_CACHE_OBJ_PER_SLAB 16 /* Target objects per slab */
|
||||
#define SPL_KMEM_CACHE_OBJ_PER_SLAB_MIN 1 /* Minimum objects per slab */
|
||||
#define SPL_KMEM_CACHE_ALIGN 8 /* Default object alignment */
|
||||
|
||||
#define POINTER_IS_VALID(p) 0 /* Unimplemented */
|
||||
#define POINTER_INVALIDATE(pp) /* Unimplemented */
|
||||
|
||||
typedef int (*spl_kmem_ctor_t)(void *, void *, int);
|
||||
typedef void (*spl_kmem_dtor_t)(void *, void *);
|
||||
typedef void (*spl_kmem_reclaim_t)(void *);
|
||||
|
||||
typedef struct spl_kmem_magazine {
|
||||
uint32_t skm_magic; /* Sanity magic */
|
||||
uint32_t skm_avail; /* Available objects */
|
||||
uint32_t skm_size; /* Magazine size */
|
||||
uint32_t skm_refill; /* Batch refill size */
|
||||
struct spl_kmem_cache *skm_cache; /* Owned by cache */
|
||||
unsigned long skm_age; /* Last cache access */
|
||||
unsigned int skm_cpu; /* Owned by cpu */
|
||||
void *skm_objs[0]; /* Object pointers */
|
||||
} spl_kmem_magazine_t;
|
||||
|
||||
typedef struct spl_kmem_obj {
|
||||
uint32_t sko_magic; /* Sanity magic */
|
||||
void *sko_addr; /* Buffer address */
|
||||
struct spl_kmem_slab *sko_slab; /* Owned by slab */
|
||||
struct list_head sko_list; /* Free object list linkage */
|
||||
} spl_kmem_obj_t;
|
||||
|
||||
typedef struct spl_kmem_slab {
|
||||
uint32_t sks_magic; /* Sanity magic */
|
||||
uint32_t sks_objs; /* Objects per slab */
|
||||
struct spl_kmem_cache *sks_cache; /* Owned by cache */
|
||||
struct list_head sks_list; /* Slab list linkage */
|
||||
struct list_head sks_free_list; /* Free object list */
|
||||
unsigned long sks_age; /* Last modify jiffie */
|
||||
uint32_t sks_ref; /* Ref count used objects */
|
||||
} spl_kmem_slab_t;
|
||||
|
||||
typedef struct spl_kmem_alloc {
|
||||
struct spl_kmem_cache *ska_cache; /* Owned by cache */
|
||||
int ska_flags; /* Allocation flags */
|
||||
taskq_ent_t ska_tqe; /* Task queue entry */
|
||||
} spl_kmem_alloc_t;
|
||||
|
||||
typedef struct spl_kmem_emergency {
|
||||
struct rb_node ske_node; /* Emergency tree linkage */
|
||||
void *ske_obj; /* Buffer address */
|
||||
} spl_kmem_emergency_t;
|
||||
|
||||
typedef struct spl_kmem_cache {
|
||||
uint32_t skc_magic; /* Sanity magic */
|
||||
uint32_t skc_name_size; /* Name length */
|
||||
char *skc_name; /* Name string */
|
||||
spl_kmem_magazine_t *skc_mag[NR_CPUS]; /* Per-CPU warm cache */
|
||||
uint32_t skc_mag_size; /* Magazine size */
|
||||
uint32_t skc_mag_refill; /* Magazine refill count */
|
||||
spl_kmem_ctor_t skc_ctor; /* Constructor */
|
||||
spl_kmem_dtor_t skc_dtor; /* Destructor */
|
||||
spl_kmem_reclaim_t skc_reclaim; /* Reclaimator */
|
||||
void *skc_private; /* Private data */
|
||||
void *skc_vmp; /* Unused */
|
||||
struct kmem_cache *skc_linux_cache; /* Linux slab cache if used */
|
||||
unsigned long skc_flags; /* Flags */
|
||||
uint32_t skc_obj_size; /* Object size */
|
||||
uint32_t skc_obj_align; /* Object alignment */
|
||||
uint32_t skc_slab_objs; /* Objects per slab */
|
||||
uint32_t skc_slab_size; /* Slab size */
|
||||
uint32_t skc_delay; /* Slab reclaim interval */
|
||||
uint32_t skc_reap; /* Slab reclaim count */
|
||||
atomic_t skc_ref; /* Ref count callers */
|
||||
taskqid_t skc_taskqid; /* Slab reclaim task */
|
||||
struct list_head skc_list; /* List of caches linkage */
|
||||
struct list_head skc_complete_list;/* Completely alloc'ed */
|
||||
struct list_head skc_partial_list; /* Partially alloc'ed */
|
||||
struct rb_root skc_emergency_tree; /* Min sized objects */
|
||||
spinlock_t skc_lock; /* Cache lock */
|
||||
wait_queue_head_t skc_waitq; /* Allocation waiters */
|
||||
uint64_t skc_slab_fail; /* Slab alloc failures */
|
||||
uint64_t skc_slab_create;/* Slab creates */
|
||||
uint64_t skc_slab_destroy;/* Slab destroys */
|
||||
uint64_t skc_slab_total; /* Slab total current */
|
||||
uint64_t skc_slab_alloc; /* Slab alloc current */
|
||||
uint64_t skc_slab_max; /* Slab max historic */
|
||||
uint64_t skc_obj_total; /* Obj total current */
|
||||
uint64_t skc_obj_alloc; /* Obj alloc current */
|
||||
uint64_t skc_obj_max; /* Obj max historic */
|
||||
uint64_t skc_obj_deadlock; /* Obj emergency deadlocks */
|
||||
uint64_t skc_obj_emergency; /* Obj emergency current */
|
||||
uint64_t skc_obj_emergency_max; /* Obj emergency max */
|
||||
} spl_kmem_cache_t;
|
||||
#define kmem_cache_t spl_kmem_cache_t
|
||||
|
||||
extern spl_kmem_cache_t *spl_kmem_cache_create(char *name, size_t size,
|
||||
size_t align, spl_kmem_ctor_t ctor, spl_kmem_dtor_t dtor,
|
||||
spl_kmem_reclaim_t reclaim, void *priv, void *vmp, int flags);
|
||||
extern void spl_kmem_cache_set_move(spl_kmem_cache_t *,
|
||||
kmem_cbrc_t (*)(void *, void *, size_t, void *));
|
||||
extern void spl_kmem_cache_destroy(spl_kmem_cache_t *skc);
|
||||
extern void *spl_kmem_cache_alloc(spl_kmem_cache_t *skc, int flags);
|
||||
extern void spl_kmem_cache_free(spl_kmem_cache_t *skc, void *obj);
|
||||
extern void spl_kmem_cache_reap_now(spl_kmem_cache_t *skc, int count);
|
||||
extern void spl_kmem_reap(void);
|
||||
|
||||
#define kmem_cache_create(name,size,align,ctor,dtor,rclm,priv,vmp,flags) \
|
||||
spl_kmem_cache_create(name,size,align,ctor,dtor,rclm,priv,vmp,flags)
|
||||
#define kmem_cache_set_move(skc, move) spl_kmem_cache_set_move(skc, move)
|
||||
#define kmem_cache_destroy(skc) spl_kmem_cache_destroy(skc)
|
||||
#define kmem_cache_alloc(skc, flags) spl_kmem_cache_alloc(skc, flags)
|
||||
#define kmem_cache_free(skc, obj) spl_kmem_cache_free(skc, obj)
|
||||
#define kmem_cache_reap_now(skc) \
|
||||
spl_kmem_cache_reap_now(skc, skc->skc_reap)
|
||||
#define kmem_reap() spl_kmem_reap()
|
||||
#define kmem_virt(ptr) (((ptr) >= (void *)VMALLOC_START) && \
|
||||
((ptr) < (void *)VMALLOC_END))
|
||||
|
||||
/*
|
||||
* Allow custom slab allocation flags to be set for KMC_SLAB based caches.
|
||||
* One use for this function is to ensure the __GFP_COMP flag is part of
|
||||
* the default allocation mask which ensures higher order allocations are
|
||||
* properly refcounted. This flag was added to the default ->allocflags
|
||||
* as of Linux 3.11.
|
||||
*/
|
||||
static inline void
|
||||
kmem_cache_set_allocflags(spl_kmem_cache_t *skc, gfp_t flags)
|
||||
{
|
||||
if (skc->skc_linux_cache == NULL)
|
||||
return;
|
||||
|
||||
#if defined(HAVE_KMEM_CACHE_ALLOCFLAGS)
|
||||
skc->skc_linux_cache->allocflags |= flags;
|
||||
#elif defined(HAVE_KMEM_CACHE_GFPFLAGS)
|
||||
skc->skc_linux_cache->gfpflags |= flags;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* The following functions are only available for internal use.
|
||||
*/
|
||||
extern int spl_kmem_cache_init(void);
|
||||
extern void spl_kmem_cache_fini(void);
|
||||
|
||||
#endif /* _SPL_KMEM_CACHE_H */
|
||||
@ -48,7 +48,6 @@ typedef long long longlong_t;
|
||||
typedef long long offset_t;
|
||||
typedef struct task_struct kthread_t;
|
||||
typedef struct task_struct proc_t;
|
||||
typedef struct vmem { } vmem_t;
|
||||
typedef short pri_t;
|
||||
typedef struct timespec timestruc_t; /* definition per SVr4 */
|
||||
typedef struct timespec timespec_t;
|
||||
|
||||
183
include/sys/vmem.h
Normal file
183
include/sys/vmem.h
Normal file
@ -0,0 +1,183 @@
|
||||
/*****************************************************************************\
|
||||
* 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.
|
||||
* For details, see <http://zfsonlinux.org/>.
|
||||
*
|
||||
* 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_VMEM_H
|
||||
#define _SPL_VMEM_H
|
||||
|
||||
#include <sys/kmem.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/vmalloc.h>
|
||||
|
||||
typedef struct vmem { } vmem_t;
|
||||
|
||||
extern vmem_t *heap_arena;
|
||||
extern vmem_t *zio_alloc_arena;
|
||||
extern vmem_t *zio_arena;
|
||||
|
||||
extern size_t vmem_size(vmem_t *vmp, int typemask);
|
||||
|
||||
/*
|
||||
* Memory allocation interfaces
|
||||
*/
|
||||
#define VMEM_ALLOC 0x01
|
||||
#define VMEM_FREE 0x02
|
||||
|
||||
#ifndef VMALLOC_TOTAL
|
||||
#define VMALLOC_TOTAL (VMALLOC_END - VMALLOC_START)
|
||||
#endif
|
||||
|
||||
static inline void *
|
||||
vmalloc_nofail(size_t size, gfp_t flags)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
/*
|
||||
* Retry failed __vmalloc() allocations once every second. The
|
||||
* rational for the delay is that the likely failure modes are:
|
||||
*
|
||||
* 1) The system has completely exhausted memory, in which case
|
||||
* delaying 1 second for the memory reclaim to run is reasonable
|
||||
* to avoid thrashing the system.
|
||||
* 2) The system has memory but has exhausted the small virtual
|
||||
* address space available on 32-bit systems. Retrying the
|
||||
* allocation immediately will only result in spinning on the
|
||||
* virtual address space lock. It is better delay a second and
|
||||
* hope that another process will free some of the address space.
|
||||
* But the bottom line is there is not much we can actually do
|
||||
* since we can never safely return a failure and honor the
|
||||
* Solaris semantics.
|
||||
*/
|
||||
while (1) {
|
||||
ptr = __vmalloc(size, flags | __GFP_HIGHMEM, PAGE_KERNEL);
|
||||
if (unlikely((ptr == NULL) && (flags & __GFP_WAIT))) {
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
schedule_timeout(HZ);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static inline void *
|
||||
vzalloc_nofail(size_t size, gfp_t flags)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
ptr = vmalloc_nofail(size, flags);
|
||||
if (ptr)
|
||||
memset(ptr, 0, (size));
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_KMEM
|
||||
|
||||
/*
|
||||
* Memory accounting functions to be used only when DEBUG_KMEM is set.
|
||||
*/
|
||||
# ifdef HAVE_ATOMIC64_T
|
||||
|
||||
# define vmem_alloc_used_add(size) atomic64_add(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_sub(size) atomic64_sub(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_read() atomic64_read(&vmem_alloc_used)
|
||||
# define vmem_alloc_used_set(size) atomic64_set(&vmem_alloc_used, size)
|
||||
|
||||
extern atomic64_t vmem_alloc_used;
|
||||
extern unsigned long long vmem_alloc_max;
|
||||
|
||||
# else /* HAVE_ATOMIC64_T */
|
||||
|
||||
# define vmem_alloc_used_add(size) atomic_add(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_sub(size) atomic_sub(size, &vmem_alloc_used)
|
||||
# define vmem_alloc_used_read() atomic_read(&vmem_alloc_used)
|
||||
# define vmem_alloc_used_set(size) atomic_set(&vmem_alloc_used, size)
|
||||
|
||||
extern atomic_t vmem_alloc_used;
|
||||
extern unsigned long long vmem_alloc_max;
|
||||
|
||||
# endif /* HAVE_ATOMIC64_T */
|
||||
|
||||
# ifdef DEBUG_KMEM_TRACKING
|
||||
/*
|
||||
* DEBUG_KMEM && DEBUG_KMEM_TRACKING
|
||||
*
|
||||
* The maximum level of memory debugging. All memory will be accounted
|
||||
* for and each allocation will be explicitly tracked. Any allocation
|
||||
* which is leaked will be reported on module unload and the exact location
|
||||
* where that memory was allocation will be reported. This level of memory
|
||||
* tracking will have a significant impact on performance and should only
|
||||
* be enabled for debugging. This feature may be enabled by passing
|
||||
* --enable-debug-kmem-tracking to configure.
|
||||
*/
|
||||
# define vmem_alloc(sz, fl) vmem_alloc_track((sz), (fl), \
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_zalloc(sz, fl) vmem_alloc_track((sz), (fl)|__GFP_ZERO,\
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_free(ptr, sz) vmem_free_track((ptr), (sz))
|
||||
|
||||
extern void *kmem_alloc_track(size_t, int, const char *, int, int, int);
|
||||
extern void kmem_free_track(const void *, size_t);
|
||||
extern void *vmem_alloc_track(size_t, int, const char *, int);
|
||||
extern void vmem_free_track(const void *, size_t);
|
||||
|
||||
# else /* DEBUG_KMEM_TRACKING */
|
||||
/*
|
||||
* DEBUG_KMEM && !DEBUG_KMEM_TRACKING
|
||||
*
|
||||
* The default build will set DEBUG_KEM. This provides basic memory
|
||||
* accounting with little to no impact on performance. When the module
|
||||
* is unloaded in any memory was leaked the total number of leaked bytes
|
||||
* will be reported on the console. To disable this basic accounting
|
||||
* pass the --disable-debug-kmem option to configure.
|
||||
*/
|
||||
# define vmem_alloc(sz, fl) vmem_alloc_debug((sz), (fl), \
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_zalloc(sz, fl) vmem_alloc_debug((sz), (fl)|__GFP_ZERO,\
|
||||
__FUNCTION__, __LINE__)
|
||||
# define vmem_free(ptr, sz) vmem_free_debug((ptr), (sz))
|
||||
|
||||
extern void *vmem_alloc_debug(size_t, int, const char *, int);
|
||||
extern void vmem_free_debug(const void *, size_t);
|
||||
|
||||
# endif /* DEBUG_KMEM_TRACKING */
|
||||
#else /* DEBUG_KMEM */
|
||||
/*
|
||||
* !DEBUG_KMEM && !DEBUG_KMEM_TRACKING
|
||||
*
|
||||
* All debugging is disabled. There will be no overhead even for
|
||||
* minimal memory accounting. To enable basic accounting pass the
|
||||
* --enable-debug-kmem option to configure.
|
||||
*/
|
||||
# define vmem_alloc(sz, fl) vmalloc_nofail((sz), (fl))
|
||||
# define vmem_zalloc(sz, fl) vzalloc_nofail((sz), (fl))
|
||||
# define vmem_free(ptr, sz) ((void)(sz), vfree(ptr))
|
||||
|
||||
#endif /* DEBUG_KMEM */
|
||||
|
||||
int spl_vmem_init(void);
|
||||
void spl_vmem_fini(void);
|
||||
|
||||
#endif /* _SPL_VMEM_H */
|
||||
@ -37,19 +37,6 @@
|
||||
#define physmem totalram_pages
|
||||
#define freemem nr_free_pages()
|
||||
|
||||
extern vmem_t *heap_arena; /* primary kernel heap arena */
|
||||
extern vmem_t *zio_alloc_arena; /* arena for zio caches */
|
||||
extern vmem_t *zio_arena; /* arena for allocating zio memory */
|
||||
|
||||
extern size_t vmem_size(vmem_t *vmp, int typemask);
|
||||
|
||||
#define VMEM_ALLOC 0x01
|
||||
#define VMEM_FREE 0x02
|
||||
|
||||
#ifndef VMALLOC_TOTAL
|
||||
#define VMALLOC_TOTAL (VMALLOC_END - VMALLOC_START)
|
||||
#endif
|
||||
|
||||
#define xcopyin(from, to, size) copy_from_user(to, from, size)
|
||||
#define xcopyout(from, to, size) copy_to_user(to, from, size)
|
||||
|
||||
|
||||
@ -8,6 +8,8 @@ obj-$(CONFIG_SPL) := $(MODULE).o
|
||||
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-proc.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-kmem.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-kmem-cache.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-vmem.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-thread.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-taskq.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/spl/spl-rwlock.o
|
||||
|
||||
@ -25,6 +25,7 @@
|
||||
\*****************************************************************************/
|
||||
|
||||
#include <sys/condvar.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
void
|
||||
__cv_init(kcondvar_t *cvp, char *name, kcv_type_t type, void *arg)
|
||||
|
||||
@ -29,6 +29,8 @@
|
||||
#include <sys/vmsystm.h>
|
||||
#include <sys/kobj.h>
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/kmem_cache.h>
|
||||
#include <sys/vmem.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/rwlock.h>
|
||||
#include <sys/taskq.h>
|
||||
@ -38,6 +40,7 @@
|
||||
#include <sys/proc.h>
|
||||
#include <sys/kstat.h>
|
||||
#include <sys/file.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <linux/kmod.h>
|
||||
#include <linux/math64_compat.h>
|
||||
#include <linux/proc_compat.h>
|
||||
@ -479,12 +482,46 @@ zone_get_hostid(void *zone)
|
||||
}
|
||||
EXPORT_SYMBOL(zone_get_hostid);
|
||||
|
||||
static int
|
||||
spl_kvmem_init(void)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
rc = spl_kmem_init();
|
||||
if (rc)
|
||||
goto out1;
|
||||
|
||||
rc = spl_vmem_init();
|
||||
if (rc)
|
||||
goto out2;
|
||||
|
||||
rc = spl_kmem_cache_init();
|
||||
if (rc)
|
||||
goto out3;
|
||||
|
||||
return (rc);
|
||||
out3:
|
||||
spl_vmem_fini();
|
||||
out2:
|
||||
spl_kmem_fini();
|
||||
out1:
|
||||
return (rc);
|
||||
}
|
||||
|
||||
static void
|
||||
spl_kvmem_fini(void)
|
||||
{
|
||||
spl_kmem_cache_fini();
|
||||
spl_vmem_fini();
|
||||
spl_kmem_fini();
|
||||
}
|
||||
|
||||
static int
|
||||
__init spl_init(void)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
if ((rc = spl_kmem_init()))
|
||||
if ((rc = spl_kvmem_init()))
|
||||
goto out1;
|
||||
|
||||
if ((rc = spl_mutex_init()))
|
||||
@ -530,7 +567,7 @@ out4:
|
||||
out3:
|
||||
spl_mutex_fini();
|
||||
out2:
|
||||
spl_kmem_fini();
|
||||
spl_kvmem_fini();
|
||||
out1:
|
||||
printk(KERN_NOTICE "SPL: Failed to Load Solaris Porting Layer "
|
||||
"v%s-%s%s, rc = %d\n", SPL_META_VERSION, SPL_META_RELEASE,
|
||||
@ -552,7 +589,7 @@ spl_fini(void)
|
||||
spl_taskq_fini();
|
||||
spl_rw_fini();
|
||||
spl_mutex_fini();
|
||||
spl_kmem_fini();
|
||||
spl_kvmem_fini();
|
||||
}
|
||||
|
||||
/* Called when a dependent module is loaded */
|
||||
|
||||
1648
module/spl/spl-kmem-cache.c
Normal file
1648
module/spl/spl-kmem-cache.c
Normal file
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -26,6 +26,7 @@
|
||||
|
||||
#include <linux/seq_file.h>
|
||||
#include <sys/kstat.h>
|
||||
#include <sys/vmem.h>
|
||||
|
||||
#ifndef HAVE_PDE_DATA
|
||||
#define PDE_DATA(x) (PDE(x)->data)
|
||||
|
||||
@ -26,9 +26,14 @@
|
||||
|
||||
#include <sys/systeminfo.h>
|
||||
#include <sys/kstat.h>
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/kmem_cache.h>
|
||||
#include <sys/vmem.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <linux/kmod.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/proc_compat.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/version.h>
|
||||
|
||||
#if defined(CONSTIFY_PLUGIN) && LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)
|
||||
|
||||
@ -61,6 +61,7 @@
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/thread.h>
|
||||
#include <sys/tsd.h>
|
||||
#include <linux/hash.h>
|
||||
|
||||
typedef struct tsd_hash_bin {
|
||||
spinlock_t hb_lock;
|
||||
|
||||
355
module/spl/spl-vmem.c
Normal file
355
module/spl/spl-vmem.c
Normal file
@ -0,0 +1,355 @@
|
||||
/*****************************************************************************\
|
||||
* 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.
|
||||
* For details, see <http://zfsonlinux.org/>.
|
||||
*
|
||||
* 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/>.
|
||||
*****************************************************************************
|
||||
* Solaris Porting Layer (SPL) Kmem Implementation.
|
||||
\*****************************************************************************/
|
||||
|
||||
#include <sys/debug.h>
|
||||
#include <sys/vmem.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
vmem_t *heap_arena = NULL;
|
||||
EXPORT_SYMBOL(heap_arena);
|
||||
|
||||
vmem_t *zio_alloc_arena = NULL;
|
||||
EXPORT_SYMBOL(zio_alloc_arena);
|
||||
|
||||
vmem_t *zio_arena = NULL;
|
||||
EXPORT_SYMBOL(zio_arena);
|
||||
|
||||
size_t
|
||||
vmem_size(vmem_t *vmp, int typemask)
|
||||
{
|
||||
ASSERT3P(vmp, ==, NULL);
|
||||
ASSERT3S(typemask & VMEM_ALLOC, ==, VMEM_ALLOC);
|
||||
ASSERT3S(typemask & VMEM_FREE, ==, VMEM_FREE);
|
||||
|
||||
return (VMALLOC_TOTAL);
|
||||
}
|
||||
EXPORT_SYMBOL(vmem_size);
|
||||
|
||||
/*
|
||||
* Memory allocation interfaces and debugging for basic kmem_*
|
||||
* and vmem_* style memory allocation. When DEBUG_KMEM is enabled
|
||||
* the SPL will keep track of the total memory allocated, and
|
||||
* report any memory leaked when the module is unloaded.
|
||||
*/
|
||||
#ifdef DEBUG_KMEM
|
||||
|
||||
/* Shim layer memory accounting */
|
||||
# ifdef HAVE_ATOMIC64_T
|
||||
atomic64_t vmem_alloc_used = ATOMIC64_INIT(0);
|
||||
unsigned long long vmem_alloc_max = 0;
|
||||
# else /* HAVE_ATOMIC64_T */
|
||||
atomic_t vmem_alloc_used = ATOMIC_INIT(0);
|
||||
unsigned long long vmem_alloc_max = 0;
|
||||
# endif /* HAVE_ATOMIC64_T */
|
||||
|
||||
EXPORT_SYMBOL(vmem_alloc_used);
|
||||
EXPORT_SYMBOL(vmem_alloc_max);
|
||||
|
||||
/* When DEBUG_KMEM_TRACKING is enabled not only will total bytes be tracked
|
||||
* but also the location of every alloc and free. When the SPL module is
|
||||
* unloaded a list of all leaked addresses and where they were allocated
|
||||
* will be dumped to the console. Enabling this feature has a significant
|
||||
* impact on performance but it makes finding memory leaks straight forward.
|
||||
*
|
||||
* Not surprisingly with debugging enabled the xmem_locks are very highly
|
||||
* contended particularly on xfree(). If we want to run with this detailed
|
||||
* debugging enabled for anything other than debugging we need to minimize
|
||||
* the contention by moving to a lock per xmem_table entry model.
|
||||
*/
|
||||
# ifdef DEBUG_KMEM_TRACKING
|
||||
|
||||
# define VMEM_HASH_BITS 10
|
||||
# define VMEM_TABLE_SIZE (1 << VMEM_HASH_BITS)
|
||||
|
||||
typedef struct kmem_debug {
|
||||
struct hlist_node kd_hlist; /* Hash node linkage */
|
||||
struct list_head kd_list; /* List of all allocations */
|
||||
void *kd_addr; /* Allocation pointer */
|
||||
size_t kd_size; /* Allocation size */
|
||||
const char *kd_func; /* Allocation function */
|
||||
int kd_line; /* Allocation line */
|
||||
} kmem_debug_t;
|
||||
|
||||
spinlock_t vmem_lock;
|
||||
struct hlist_head vmem_table[VMEM_TABLE_SIZE];
|
||||
struct list_head vmem_list;
|
||||
|
||||
EXPORT_SYMBOL(vmem_lock);
|
||||
EXPORT_SYMBOL(vmem_table);
|
||||
EXPORT_SYMBOL(vmem_list);
|
||||
|
||||
void *
|
||||
vmem_alloc_track(size_t size, int flags, const char *func, int line)
|
||||
{
|
||||
void *ptr = NULL;
|
||||
kmem_debug_t *dptr;
|
||||
unsigned long irq_flags;
|
||||
|
||||
ASSERT(flags & KM_SLEEP);
|
||||
|
||||
/* Function may be called with KM_NOSLEEP so failure is possible */
|
||||
dptr = (kmem_debug_t *) kmalloc_nofail(sizeof(kmem_debug_t),
|
||||
flags & ~__GFP_ZERO);
|
||||
if (unlikely(dptr == NULL)) {
|
||||
printk(KERN_WARNING "debug vmem_alloc(%ld, 0x%x) "
|
||||
"at %s:%d failed (%lld/%llu)\n",
|
||||
sizeof(kmem_debug_t), flags, func, line,
|
||||
vmem_alloc_used_read(), vmem_alloc_max);
|
||||
} else {
|
||||
/*
|
||||
* We use __strdup() below because the string pointed to by
|
||||
* __FUNCTION__ might not be available by the time we want
|
||||
* to print it, since the module might have been unloaded.
|
||||
* This can never fail because we have already asserted
|
||||
* that flags is KM_SLEEP.
|
||||
*/
|
||||
dptr->kd_func = __strdup(func, flags & ~__GFP_ZERO);
|
||||
if (unlikely(dptr->kd_func == NULL)) {
|
||||
kfree(dptr);
|
||||
printk(KERN_WARNING "debug __strdup() at %s:%d "
|
||||
"failed (%lld/%llu)\n", func, line,
|
||||
vmem_alloc_used_read(), vmem_alloc_max);
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Use the correct allocator */
|
||||
if (flags & __GFP_ZERO) {
|
||||
ptr = vzalloc_nofail(size, flags & ~__GFP_ZERO);
|
||||
} else {
|
||||
ptr = vmalloc_nofail(size, flags);
|
||||
}
|
||||
|
||||
if (unlikely(ptr == NULL)) {
|
||||
kfree(dptr->kd_func);
|
||||
kfree(dptr);
|
||||
printk(KERN_WARNING "vmem_alloc (%llu, 0x%x) "
|
||||
"at %s:%d failed (%lld/%llu)\n",
|
||||
(unsigned long long) size, flags, func, line,
|
||||
vmem_alloc_used_read(), vmem_alloc_max);
|
||||
goto out;
|
||||
}
|
||||
|
||||
vmem_alloc_used_add(size);
|
||||
if (unlikely(vmem_alloc_used_read() > vmem_alloc_max))
|
||||
vmem_alloc_max = vmem_alloc_used_read();
|
||||
|
||||
INIT_HLIST_NODE(&dptr->kd_hlist);
|
||||
INIT_LIST_HEAD(&dptr->kd_list);
|
||||
|
||||
dptr->kd_addr = ptr;
|
||||
dptr->kd_size = size;
|
||||
dptr->kd_line = line;
|
||||
|
||||
spin_lock_irqsave(&vmem_lock, irq_flags);
|
||||
hlist_add_head(&dptr->kd_hlist,
|
||||
&vmem_table[hash_ptr(ptr, VMEM_HASH_BITS)]);
|
||||
list_add_tail(&dptr->kd_list, &vmem_list);
|
||||
spin_unlock_irqrestore(&vmem_lock, irq_flags);
|
||||
}
|
||||
out:
|
||||
return (ptr);
|
||||
}
|
||||
EXPORT_SYMBOL(vmem_alloc_track);
|
||||
|
||||
void
|
||||
vmem_free_track(const void *ptr, size_t size)
|
||||
{
|
||||
kmem_debug_t *dptr;
|
||||
|
||||
ASSERTF(ptr || size > 0, "ptr: %p, size: %llu", ptr,
|
||||
(unsigned long long) size);
|
||||
|
||||
/* Must exist in hash due to vmem_alloc() */
|
||||
dptr = kmem_del_init(&vmem_lock, vmem_table, VMEM_HASH_BITS, ptr);
|
||||
ASSERT(dptr);
|
||||
|
||||
/* Size must match */
|
||||
ASSERTF(dptr->kd_size == size, "kd_size (%llu) != size (%llu), "
|
||||
"kd_func = %s, kd_line = %d\n", (unsigned long long) dptr->kd_size,
|
||||
(unsigned long long) size, dptr->kd_func, dptr->kd_line);
|
||||
|
||||
vmem_alloc_used_sub(size);
|
||||
kfree(dptr->kd_func);
|
||||
|
||||
memset((void *)dptr, 0x5a, sizeof(kmem_debug_t));
|
||||
kfree(dptr);
|
||||
|
||||
memset((void *)ptr, 0x5a, size);
|
||||
vfree(ptr);
|
||||
}
|
||||
EXPORT_SYMBOL(vmem_free_track);
|
||||
|
||||
# else /* DEBUG_KMEM_TRACKING */
|
||||
|
||||
void *
|
||||
vmem_alloc_debug(size_t size, int flags, const char *func, int line)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
ASSERT(flags & KM_SLEEP);
|
||||
|
||||
/* Use the correct allocator */
|
||||
if (flags & __GFP_ZERO) {
|
||||
ptr = vzalloc_nofail(size, flags & (~__GFP_ZERO));
|
||||
} else {
|
||||
ptr = vmalloc_nofail(size, flags);
|
||||
}
|
||||
|
||||
if (unlikely(ptr == NULL)) {
|
||||
printk(KERN_WARNING
|
||||
"vmem_alloc(%llu, 0x%x) at %s:%d failed (%lld/%llu)\n",
|
||||
(unsigned long long)size, flags, func, line,
|
||||
(unsigned long long)vmem_alloc_used_read(), vmem_alloc_max);
|
||||
} else {
|
||||
vmem_alloc_used_add(size);
|
||||
if (unlikely(vmem_alloc_used_read() > vmem_alloc_max))
|
||||
vmem_alloc_max = vmem_alloc_used_read();
|
||||
}
|
||||
|
||||
return (ptr);
|
||||
}
|
||||
EXPORT_SYMBOL(vmem_alloc_debug);
|
||||
|
||||
void
|
||||
vmem_free_debug(const void *ptr, size_t size)
|
||||
{
|
||||
ASSERT(ptr || size > 0);
|
||||
vmem_alloc_used_sub(size);
|
||||
vfree(ptr);
|
||||
}
|
||||
EXPORT_SYMBOL(vmem_free_debug);
|
||||
|
||||
# endif /* DEBUG_KMEM_TRACKING */
|
||||
#endif /* DEBUG_KMEM */
|
||||
|
||||
#if defined(DEBUG_KMEM) && defined(DEBUG_KMEM_TRACKING)
|
||||
static char *
|
||||
spl_sprintf_addr(kmem_debug_t *kd, char *str, int len, int min)
|
||||
{
|
||||
int size = ((len - 1) < kd->kd_size) ? (len - 1) : kd->kd_size;
|
||||
int i, flag = 1;
|
||||
|
||||
ASSERT(str != NULL && len >= 17);
|
||||
memset(str, 0, len);
|
||||
|
||||
/* Check for a fully printable string, and while we are at
|
||||
* it place the printable characters in the passed buffer. */
|
||||
for (i = 0; i < size; i++) {
|
||||
str[i] = ((char *)(kd->kd_addr))[i];
|
||||
if (isprint(str[i])) {
|
||||
continue;
|
||||
} else {
|
||||
/* Minimum number of printable characters found
|
||||
* to make it worthwhile to print this as ascii. */
|
||||
if (i > min)
|
||||
break;
|
||||
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!flag) {
|
||||
sprintf(str, "%02x%02x%02x%02x%02x%02x%02x%02x",
|
||||
*((uint8_t *)kd->kd_addr),
|
||||
*((uint8_t *)kd->kd_addr + 2),
|
||||
*((uint8_t *)kd->kd_addr + 4),
|
||||
*((uint8_t *)kd->kd_addr + 6),
|
||||
*((uint8_t *)kd->kd_addr + 8),
|
||||
*((uint8_t *)kd->kd_addr + 10),
|
||||
*((uint8_t *)kd->kd_addr + 12),
|
||||
*((uint8_t *)kd->kd_addr + 14));
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
static int
|
||||
spl_kmem_init_tracking(struct list_head *list, spinlock_t *lock, int size)
|
||||
{
|
||||
int i;
|
||||
|
||||
spin_lock_init(lock);
|
||||
INIT_LIST_HEAD(list);
|
||||
|
||||
for (i = 0; i < size; i++)
|
||||
INIT_HLIST_HEAD(&kmem_table[i]);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
static void
|
||||
spl_kmem_fini_tracking(struct list_head *list, spinlock_t *lock)
|
||||
{
|
||||
unsigned long flags;
|
||||
kmem_debug_t *kd;
|
||||
char str[17];
|
||||
|
||||
spin_lock_irqsave(lock, flags);
|
||||
if (!list_empty(list))
|
||||
printk(KERN_WARNING "%-16s %-5s %-16s %s:%s\n", "address",
|
||||
"size", "data", "func", "line");
|
||||
|
||||
list_for_each_entry(kd, list, kd_list)
|
||||
printk(KERN_WARNING "%p %-5d %-16s %s:%d\n", kd->kd_addr,
|
||||
(int)kd->kd_size, spl_sprintf_addr(kd, str, 17, 8),
|
||||
kd->kd_func, kd->kd_line);
|
||||
|
||||
spin_unlock_irqrestore(lock, flags);
|
||||
}
|
||||
#else /* DEBUG_KMEM && DEBUG_KMEM_TRACKING */
|
||||
#define spl_kmem_init_tracking(list, lock, size)
|
||||
#define spl_kmem_fini_tracking(list, lock)
|
||||
#endif /* DEBUG_KMEM && DEBUG_KMEM_TRACKING */
|
||||
|
||||
int
|
||||
spl_vmem_init(void)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
#ifdef DEBUG_KMEM
|
||||
vmem_alloc_used_set(0);
|
||||
spl_kmem_init_tracking(&vmem_list, &vmem_lock, VMEM_TABLE_SIZE);
|
||||
#endif
|
||||
|
||||
return (rc);
|
||||
}
|
||||
|
||||
void
|
||||
spl_vmem_fini(void)
|
||||
{
|
||||
#ifdef DEBUG_KMEM
|
||||
/* Display all unreclaimed memory addresses, including the
|
||||
* allocation size and the first few bytes of what's located
|
||||
* at that address to aid in debugging. Performance is not
|
||||
* a serious concern here since it is module unload time. */
|
||||
if (vmem_alloc_used_read() != 0)
|
||||
printk(KERN_WARNING "vmem leaked %ld/%llu bytes\n",
|
||||
vmem_alloc_used_read(), vmem_alloc_max);
|
||||
|
||||
spl_kmem_fini_tracking(&vmem_list, &vmem_lock);
|
||||
#endif /* DEBUG_KMEM */
|
||||
}
|
||||
@ -26,6 +26,7 @@
|
||||
|
||||
#include <sys/cred.h>
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/kmem_cache.h>
|
||||
#include <linux/falloc.h>
|
||||
#include <linux/file_compat.h>
|
||||
|
||||
|
||||
@ -54,6 +54,7 @@
|
||||
|
||||
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/kmem_cache.h>
|
||||
#include <sys/zmod.h>
|
||||
#include <linux/zlib_compat.h>
|
||||
|
||||
|
||||
@ -24,8 +24,9 @@
|
||||
* Solaris Porting LAyer Tests (SPLAT) Condition Variable Tests.
|
||||
\*****************************************************************************/
|
||||
|
||||
#include <linux/kthread.h>
|
||||
#include <sys/condvar.h>
|
||||
#include <sys/timer.h>
|
||||
#include <sys/thread.h>
|
||||
#include "splat-internal.h"
|
||||
|
||||
#define SPLAT_CONDVAR_NAME "condvar"
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
|
||||
#include "splat-ctl.h"
|
||||
#include <sys/mutex.h>
|
||||
#include <linux/file_compat.h>
|
||||
|
||||
#define SPLAT_SUBSYSTEM_INIT(type) \
|
||||
({ splat_subsystem_t *_sub_; \
|
||||
|
||||
@ -25,7 +25,10 @@
|
||||
\*****************************************************************************/
|
||||
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/kmem_cache.h>
|
||||
#include <sys/vmem.h>
|
||||
#include <sys/thread.h>
|
||||
#include <sys/vmsystm.h>
|
||||
#include "splat-internal.h"
|
||||
|
||||
#define SPLAT_KMEM_NAME "kmem"
|
||||
|
||||
@ -25,8 +25,10 @@
|
||||
\*****************************************************************************/
|
||||
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/vmem.h>
|
||||
#include <sys/random.h>
|
||||
#include <sys/taskq.h>
|
||||
#include <sys/timer.h>
|
||||
#include <linux/delay.h>
|
||||
#include "splat-internal.h"
|
||||
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
#include <sys/zmod.h>
|
||||
#include <sys/random.h>
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/vmem.h>
|
||||
#include "splat-internal.h"
|
||||
|
||||
#define SPLAT_ZLIB_NAME "zlib"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user