sys/acl_impl.h _ All borrowed from libsolcompat
* Implement solaris style atomic interfaces
+
+* Fully implement vnode support for ZPL layer to intergrate with VFS.
extern "C" {
#endif
-#undef DEBUG_KMEM
+#define DEBUG_KMEM
#undef DEBUG_KMEM_UNIMPLEMENTED
#include <linux/module.h>
#include <linux/slab.h>
+#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
/*
#define KM_FLAGS __GFP_BITS_MASK
#ifdef DEBUG_KMEM
-/* Shim layer memory accounting */
extern atomic_t kmem_alloc_used;
extern unsigned int kmem_alloc_max;
-#endif
+extern atomic_t vmem_alloc_used;
+extern unsigned int vmem_alloc_max;
-#ifdef DEBUG_KMEM
#define __kmem_alloc(size, flags, allocator) \
({ void *_ptr_; \
\
#define kmem_free(ptr, size) \
({ \
- BUG_ON(!ptr || size < 0); \
+ BUG_ON(!(ptr) || (size) < 0); \
atomic_sub((size), &kmem_alloc_used); \
memset(ptr, 0x5a, (size)); /* Poison */ \
kfree(ptr); \
- (ptr) = (void *)0xdeadbeef; \
})
+#define __vmem_alloc(size, flags) \
+({ void *_ptr_; \
+ \
+ BUG_ON(flags != KM_SLEEP); \
+ \
+ _ptr_ = (void *)vmalloc((size)); \
+ if (_ptr_ == NULL) { \
+ printk("Warning: vmem_alloc(%d, 0x%x) failed at %s:%d " \
+ "(%d/%d)\n", (int)(size), (int)(flags), \
+ __FILE__, __LINE__, \
+ atomic_read(&vmem_alloc_used), vmem_alloc_max); \
+ atomic_add((size), &vmem_alloc_used); \
+ if (unlikely(atomic_read(&vmem_alloc_used) > vmem_alloc_max)) \
+ vmem_alloc_max = atomic_read(&vmem_alloc_used); \
+ } \
+ \
+ _ptr_; \
+})
+
+#define vmem_alloc(size, flags) __vmem_alloc(size, flags)
+
+#define vmem_free(ptr, size) \
+({ \
+ BUG_ON(!(ptr) || (size) < 0); \
+ atomic_sub((size), &vmem_alloc_used); \
+ memset(ptr, 0x5a, (size)); /* Poison */ \
+ vfree(ptr); \
+})
#else
#define kmem_zalloc(size, flags) kzalloc(size, flags)
#define kmem_free(ptr, size) \
({ \
- BUG_ON(!ptr || size < 0); \
+ BUG_ON(!(ptr) || (size) < 0); \
kfree(ptr); \
})
+#define vmem_alloc(size, flags) vmalloc(size)
+#define vmem_free(ptr, size) \
+({ \
+ BUG_ON(!(ptr) || (size) < 0); \
+ vfree(ptr); \
+})
+
#endif /* DEBUG_KMEM */
#include <linux/time.h>
#include <sys/types.h>
-extern unsigned long long monotonic_clock(void);
-extern void __gethrestime(timestruc_t *);
-
-#define gethrestime(ts) __gethrestime(ts)
-
#define TIME32_MAX INT32_MAX
#define TIME32_MIN INT32_MIN
#define MICROSEC 1000000
#define NANOSEC 1000000000
+/* Already defined in include/linux/time.h */
+#undef CLOCK_THREAD_CPUTIME_ID
+#undef CLOCK_REALTIME
+#undef CLOCK_MONOTONIC
+#undef CLOCK_PROCESS_CPUTIME_ID
+
+typedef enum clock_type {
+ __CLOCK_REALTIME0 = 0, /* obsolete; same as CLOCK_REALTIME */
+ CLOCK_VIRTUAL = 1, /* thread's user-level CPU clock */
+ CLOCK_THREAD_CPUTIME_ID = 2, /* thread's user+system CPU clock */
+ CLOCK_REALTIME = 3, /* wall clock */
+ CLOCK_MONOTONIC = 4, /* high resolution monotonic clock */
+ CLOCK_PROCESS_CPUTIME_ID = 5, /* process's user+system CPU clock */
+ CLOCK_HIGHRES = CLOCK_MONOTONIC, /* alternate name */
+ CLOCK_PROF = CLOCK_THREAD_CPUTIME_ID,/* alternate name */
+} clock_type_t;
+
#define hz \
({ \
BUG_ON(HZ < 100 || HZ > MICROSEC); \
HZ; \
})
+extern void __gethrestime(timestruc_t *);
+extern int __clock_gettime(clock_type_t, timespec_t *);
+extern hrtime_t __gethrtime(void);
+
+#define gethrestime(ts) __gethrestime(ts)
+#define clock_gettime(fl, tp) __clock_gettime(fl, tp)
+#define gethrtime() __gethrtime()
+
static __inline__ time_t
gethrestime_sec(void)
{
return now.tv_sec;
}
-static __inline__ hrtime_t
-gethrtime(void) {
- /* BUG_ON(cur_timer == timer_none); */
-
- /* Solaris expects a long long here but monotonic_clock() returns an
- * unsigned long long. Note that monotonic_clock() returns the number
- * of nanoseconds passed since kernel initialization. Even for a signed
- * long long this will not "go negative" for ~292 years.
- */
- return monotonic_clock();
-}
-
-
#ifdef __cplusplus
}
#endif
typedef struct vmem { } vmem_t;
typedef short pri_t;
typedef struct timespec timestruc_t; /* definition per SVr4 */
+typedef struct timespec timespec_t;
typedef longlong_t hrtime_t;
typedef unsigned short ushort_t;
typedef u_longlong_t len_t;
/* Shim layer memory accounting */
atomic_t kmem_alloc_used;
unsigned int kmem_alloc_max;
+atomic_t vmem_alloc_used;
+unsigned int vmem_alloc_max;
+
+EXPORT_SYMBOL(kmem_alloc_used);
+EXPORT_SYMBOL(kmem_alloc_max);
+EXPORT_SYMBOL(vmem_alloc_used);
+EXPORT_SYMBOL(vmem_alloc_max);
#endif
/*
{
getnstimeofday((struct timespec *)ts);
}
-
EXPORT_SYMBOL(__gethrestime);
+
+int
+__clock_gettime(clock_type_t type, timespec_t *tp)
+{
+ /* Only support CLOCK_REALTIME+__CLOCK_REALTIME0 for now */
+ BUG_ON(!((type == CLOCK_REALTIME) || (type == __CLOCK_REALTIME0)));
+
+ getnstimeofday(tp);
+ return 0;
+}
+EXPORT_SYMBOL(__clock_gettime);
+
+/* This function may not be as fast as using monotonic_clock() but it
+ * should be much more portable, if performance becomes as issue we can
+ * look at using monotonic_clock() for x86_64 and x86 arches.
+ */
+hrtime_t
+__gethrtime(void) {
+ timespec_t tv;
+ hrtime_t rc;
+
+ do_posix_clock_monotonic_gettime(&tv);
+ rc = (NSEC_PER_SEC * (hrtime_t)tv.tv_sec) + (hrtime_t)tv.tv_nsec;
+
+ return rc;
+}
+EXPORT_SYMBOL(__gethrtime);
#define SPLAT_KMEM_TEST4_NAME "slab_reap"
#define SPLAT_KMEM_TEST4_DESC "Slab reaping test"
+#define SPLAT_KMEM_TEST5_ID 0x0105
+#define SPLAT_KMEM_TEST5_NAME "vmem_alloc"
+#define SPLAT_KMEM_TEST5_DESC "Memory allocation test (vmem_alloc)"
+
#define SPLAT_KMEM_ALLOC_COUNT 10
+#define SPLAT_VMEM_ALLOC_COUNT 10
+
/* XXX - This test may fail under tight memory conditions */
static int
splat_kmem_test1(struct file *file, void *arg)
int size = PAGE_SIZE;
int i, count, rc = 0;
- while ((!rc) && (size < (PAGE_SIZE * 16))) {
+ while ((!rc) && (size <= (PAGE_SIZE * 32))) {
count = 0;
for (i = 0; i < SPLAT_KMEM_ALLOC_COUNT; i++) {
int size = PAGE_SIZE;
int i, j, count, rc = 0;
- while ((!rc) && (size < (PAGE_SIZE * 16))) {
+ while ((!rc) && (size <= (PAGE_SIZE * 32))) {
count = 0;
for (i = 0; i < SPLAT_KMEM_ALLOC_COUNT; i++) {
return rc;
}
+static int
+splat_kmem_test5(struct file *file, void *arg)
+{
+ void *ptr[SPLAT_VMEM_ALLOC_COUNT];
+ int size = PAGE_SIZE;
+ int i, count, rc = 0;
+
+ while ((!rc) && (size <= (PAGE_SIZE * 1024))) {
+ count = 0;
+
+ for (i = 0; i < SPLAT_VMEM_ALLOC_COUNT; i++) {
+ ptr[i] = vmem_alloc(size, KM_SLEEP);
+ if (ptr[i])
+ count++;
+ }
+
+ for (i = 0; i < SPLAT_VMEM_ALLOC_COUNT; i++)
+ if (ptr[i])
+ vmem_free(ptr[i], size);
+
+ splat_vprint(file, SPLAT_KMEM_TEST5_NAME,
+ "%d byte allocations, %d/%d successful\n",
+ size, count, SPLAT_VMEM_ALLOC_COUNT);
+ if (count != SPLAT_VMEM_ALLOC_COUNT)
+ rc = -ENOMEM;
+
+ size *= 2;
+ }
+
+ return rc;
+}
+
splat_subsystem_t *
splat_kmem_init(void)
{
SPLAT_KMEM_TEST3_ID, splat_kmem_test3);
SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST4_NAME, SPLAT_KMEM_TEST4_DESC,
SPLAT_KMEM_TEST4_ID, splat_kmem_test4);
+ SPLAT_TEST_INIT(sub, SPLAT_KMEM_TEST5_NAME, SPLAT_KMEM_TEST5_DESC,
+ SPLAT_KMEM_TEST5_ID, splat_kmem_test5);
return sub;
}
splat_kmem_fini(splat_subsystem_t *sub)
{
ASSERT(sub);
+ SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST5_ID);
SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST4_ID);
SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST3_ID);
SPLAT_TEST_FINI(sub, SPLAT_KMEM_TEST2_ID);
projects / mirror_spl-debian.git / commitdiff