LU-4199 libcfs: add wrapper of dump_trace()

[fs/lustre-release.git] / libcfs / libcfs / user-mem.c

diff --git a/libcfs/libcfs/user-mem.c b/libcfs/libcfs/user-mem.c
index 7c2cc4d..af1d09c 100644 (file)
--- a/libcfs/libcfs/user-mem.c
+++ b/libcfs/libcfs/user-mem.c
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -26,7 +24,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  */
 /*
@@ -45,77 +43,55 @@
 
 #include <libcfs/libcfs.h>
 
-#ifdef __linux__
-#include <malloc.h>             /* memalign declared here on linux */
-#endif
-
 /*
  * Allocator
  */
 
-cfs_page_t *cfs_alloc_pages(int mask, unsigned long order)
+struct page *alloc_page(unsigned int flags)
 {
-        cfs_page_t *pg = malloc(sizeof(*pg));
+       struct page *pg = malloc(sizeof(*pg));
+        int rc = 0;
 
         if (!pg)
                 return NULL;
-#if 0 //#ifdef MAP_ANONYMOUS
-        pg->addr = mmap(0, PAGE_SIZE << order, PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
-#elif defined (__DARWIN__)
-        pg->addr = valloc(CFS_PAGE_SIZE << order);
+        pg->addr = NULL;
+
+#if defined (__DARWIN__)
+       pg->addr = valloc(PAGE_CACHE_SIZE);
+#elif defined (__WINNT__)
+        pg->addr = pgalloc(0);
 #else
-        pg->addr = memalign(CFS_PAGE_SIZE, CFS_PAGE_SIZE << order);
+       rc = posix_memalign(&pg->addr, PAGE_CACHE_SIZE, PAGE_CACHE_SIZE);
 #endif
-
-        if (!pg->addr) {
+        if (rc != 0 || pg->addr == NULL) {
                 free(pg);
                 return NULL;
         }
         return pg;
 }
 
-void cfs_free_pages(cfs_page_t *pg, int what)
+void __free_page(struct page *pg)
 {
-#if 0 //#ifdef MAP_ANONYMOUS
-        munmap(pg->addr, PAGE_SIZE);
+#if defined (__WINNT__)
+        pgfree(pg->addr);
 #else
         free(pg->addr);
 #endif
-        free(pg);
-}
 
-cfs_page_t *cfs_alloc_page(unsigned int flags)
-{
-        cfs_page_t *pg = malloc(sizeof(*pg));
-
-        if (!pg)
-                return NULL;
-        pg->addr = malloc(CFS_PAGE_SIZE);
-
-        if (!pg->addr) {
-                free(pg);
-                return NULL;
-        }
-        return pg;
-}
-
-void cfs_free_page(cfs_page_t *pg)
-{
-        free(pg->addr);
         free(pg);
 }
 
-void *cfs_page_address(cfs_page_t *pg)
+void *page_address(struct page *pg)
 {
         return pg->addr;
 }
 
-void *cfs_kmap(cfs_page_t *pg)
+void *kmap(struct page *pg)
 {
         return pg->addr;
 }
 
-void cfs_kunmap(cfs_page_t *pg)
+void kunmap(struct page *pg)
 {
 }
 
@@ -123,10 +99,11 @@ void cfs_kunmap(cfs_page_t *pg)
  * SLAB allocator
  */
 
-cfs_mem_cache_t *
-cfs_mem_cache_create(const char *name, size_t objsize, size_t off, unsigned long flags)
+struct kmem_cache *
+kmem_cache_create(const char *name, size_t objsize, size_t off,
+                 unsigned long flags, void *ctor)
 {
-        cfs_mem_cache_t *c;
+       struct kmem_cache *c;
 
         c = malloc(sizeof(*c));
         if (!c)
@@ -137,21 +114,20 @@ cfs_mem_cache_create(const char *name, size_t objsize, size_t off, unsigned long
         return c;
 }
 
-int cfs_mem_cache_destroy(cfs_mem_cache_t *c)
+void kmem_cache_destroy(struct kmem_cache *c)
 {
         CDEBUG(D_MALLOC, "destroy slab cache %p, objsize %u\n", c, c->size);
         free(c);
-        return 0;
 }
 
-void *cfs_mem_cache_alloc(cfs_mem_cache_t *c, int gfp)
+void *kmem_cache_alloc(struct kmem_cache *c, int gfp)
 {
-        return cfs_alloc(c->size, gfp);
+       return kmalloc(c->size, gfp);
 }
 
-void cfs_mem_cache_free(cfs_mem_cache_t *c, void *addr)
+void kmem_cache_free(struct kmem_cache *c, void *addr)
 {
-        cfs_free(addr);
+       kfree(addr);
 }
 
 /**
@@ -160,7 +136,7 @@ void cfs_mem_cache_free(cfs_mem_cache_t *c, void *addr)
  * occasionally returns true for the incorrect addresses, but if it returns
  * false, then the addresses is guaranteed to be incorrect.
  */
-int cfs_mem_is_in_cache(const void *addr, const cfs_mem_cache_t *kmem)
+int kmem_is_in_cache(const void *addr, const struct kmem_cache *kmem)
 {
         return 1;
 }