# define libcfs_kmem_dec(ptr, size) do {} while (0)
#endif /* LIBCFS_DEBUG */
+#ifndef LIBCFS_VMALLOC_SIZE
#define LIBCFS_VMALLOC_SIZE (2 << CFS_PAGE_SHIFT) /* 2 pages */
+#endif
#define LIBCFS_ALLOC_GFP(ptr, size, mask) \
do { \
extern void *cfs_alloc_large(size_t nr_bytes);
extern void cfs_free_large(void *addr);
-extern cfs_page_t *cfs_alloc_pages(unsigned int flags, unsigned int order);
-extern void __cfs_free_pages(cfs_page_t *page, unsigned int order);
-
-#define cfs_alloc_page(flags) cfs_alloc_pages(flags, 0)
-#define __cfs_free_page(page) __cfs_free_pages(page, 0)
-#define cfs_free_page(p) __free_pages(p, 0)
+extern cfs_page_t *cfs_alloc_page(unsigned int flags);
+extern void cfs_free_page(cfs_page_t *page);
#define cfs_memory_pressure_get() (current->flags & PF_MEMALLOC)
#define cfs_memory_pressure_set() do { current->flags |= PF_MEMALLOC; } while (0)
#define CFS_PAGE_SIZE (1UL << CFS_PAGE_SHIFT)
#define CFS_PAGE_MASK (~((__u64)CFS_PAGE_SIZE-1))
-cfs_page_t *cfs_alloc_pages(int mask, unsigned long order);
-void cfs_free_pages(cfs_page_t *pg, int what);
cfs_page_t *cfs_alloc_page(unsigned int flags);
void cfs_free_page(cfs_page_t *pg);
void *cfs_page_address(cfs_page_t *pg);
void *cfs_kmap(cfs_page_t *pg);
void cfs_kunmap(cfs_page_t *pg);
-#define __cfs_free_pages(pg, what) cfs_free_pages((pg), (what))
-
#define cfs_get_page(p) __I_should_not_be_called__(at_all)
#define cfs_page_count(p) __I_should_not_be_called__(at_all)
#define cfs_page_index(p) ((p)->index)
void cfs_free_page(cfs_page_t *pg);
void cfs_release_page(cfs_page_t *pg);
cfs_page_t * virt_to_page(void * addr);
-cfs_page_t *cfs_alloc_pages(unsigned int flags, unsigned int order);
-void __cfs_free_pages(cfs_page_t *page, unsigned int order);
int cfs_mem_is_in_cache(const void *addr, const cfs_mem_cache_t *kmem);
#define page_cache_get(a) do {} while (0)
* These signal functions almost do nothing now, we
* need to investigate more about signal in Darwin.
*/
-cfs_sigset_t cfs_get_blockedsigs()
-{
- return (cfs_sigset_t)0;
-}
extern int block_procsigmask(struct proc *p, int bit);
vfree(addr);
}
-cfs_page_t *cfs_alloc_pages(unsigned int flags, unsigned int order)
+cfs_page_t *cfs_alloc_page(unsigned int flags)
{
/*
* XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
* from here: this will lead to infinite recursion.
*/
- return alloc_pages(cfs_alloc_flags_to_gfp(flags), order);
+ return alloc_page(cfs_alloc_flags_to_gfp(flags));
}
-void __cfs_free_pages(cfs_page_t *page, unsigned int order)
+void cfs_free_page(cfs_page_t *page)
{
- __free_pages(page, order);
+ __free_page(page);
}
cfs_mem_cache_t *
EXPORT_SYMBOL(cfs_free);
EXPORT_SYMBOL(cfs_alloc_large);
EXPORT_SYMBOL(cfs_free_large);
-EXPORT_SYMBOL(cfs_alloc_pages);
-EXPORT_SYMBOL(__cfs_free_pages);
+EXPORT_SYMBOL(cfs_alloc_page);
+EXPORT_SYMBOL(cfs_free_page);
EXPORT_SYMBOL(cfs_mem_cache_create);
EXPORT_SYMBOL(cfs_mem_cache_destroy);
EXPORT_SYMBOL(cfs_mem_cache_alloc);
}
sigset_t
-cfs_get_blockedsigs(void)
-{
- unsigned long flags;
- sigset_t old;
-
- SIGNAL_MASK_LOCK(current, flags);
- old = current->blocked;
- SIGNAL_MASK_UNLOCK(current, flags);
- return old;
-}
-
-sigset_t
cfs_block_allsigs(void)
{
unsigned long flags;
EXPORT_SYMBOL(cfs_daemonize_ctxt);
EXPORT_SYMBOL(cfs_block_allsigs);
EXPORT_SYMBOL(cfs_block_sigs);
-EXPORT_SYMBOL(cfs_get_blockedsigs);
EXPORT_SYMBOL(cfs_restore_sigs);
EXPORT_SYMBOL(cfs_signal_pending);
EXPORT_SYMBOL(cfs_clear_sigpending);
#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)
+cfs_page_t *cfs_alloc_page(unsigned int flags)
{
cfs_page_t *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(CFS_PAGE_SIZE);
#elif defined (__WINNT__)
- pg->addr = pgalloc(order);
+ pg->addr = pgalloc(0);
#else
- pg->addr = memalign(CFS_PAGE_SIZE, CFS_PAGE_SIZE << order);
+ rc = posix_memalign(&pg->addr, CFS_PAGE_SIZE, CFS_PAGE_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 cfs_free_page(cfs_page_t *pg)
{
-#if 0 //#ifdef MAP_ANONYMOUS
- munmap(pg->addr, PAGE_SIZE);
-#elif defined (__WINNT__)
+#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);
}
cfs_mem_cache_free(cfs_page_t_slab, pg);
}
-cfs_page_t *cfs_alloc_pages(unsigned int flags, unsigned int order)
-{
- cfs_page_t *pg;
- pg = cfs_mem_cache_alloc(cfs_page_t_slab, 0);
-
- if (NULL == pg) {
- cfs_enter_debugger();
- return NULL;
- }
-
- memset(pg, 0, sizeof(cfs_page_t));
- pg->addr = cfs_alloc((CFS_PAGE_SIZE << order),0);
- cfs_atomic_set(&pg->count, 1);
-
- if (pg->addr) {
- if (cfs_is_flag_set(flags, CFS_ALLOC_ZERO)) {
- memset(pg->addr, 0, CFS_PAGE_SIZE << order);
- }
- cfs_atomic_add(1 << order, &libcfs_total_pages);
- } else {
- cfs_enter_debugger();
- cfs_mem_cache_free(cfs_page_t_slab, pg);
- pg = NULL;
- }
-
- return pg;
-}
-
-void __cfs_free_pages(cfs_page_t *pg, unsigned int order)
-{
- ASSERT(pg != NULL);
- ASSERT(pg->addr != NULL);
- ASSERT(cfs_atomic_read(&pg->count) <= 1);
-
- cfs_atomic_sub(1 << order, &libcfs_total_pages);
- cfs_free(pg->addr);
- cfs_mem_cache_free(cfs_page_t_slab, pg);
-}
-
int cfs_mem_is_in_cache(const void *addr, const cfs_mem_cache_t *kmem)
{
KdPrint(("cfs_mem_is_in_cache: not implemented. (should maintain a"
* routine related with sigals
*/
-cfs_sigset_t cfs_get_blockedsigs()
-{
- return 0;
-}
-
cfs_sigset_t cfs_block_allsigs()
{
return 0;
cleanup:
for (i = 0; i < rdpg->rp_npages; i++)
if (rdpg->rp_pages[i] != NULL)
- __cfs_free_page(rdpg->rp_pages[i]);
+ cfs_free_page(rdpg->rp_pages[i]);
return rc;
}
__blocked = l_w_e_set_sigs(0); \
\
for (;;) { \
- cfs_set_current_state(CFS_TASK_INTERRUPTIBLE); \
+ unsigned __wstate; \
+ \
+ __wstate = info->lwi_on_signal != NULL && \
+ (__timeout == 0 || __allow_intr) ? \
+ CFS_TASK_INTERRUPTIBLE : CFS_TASK_UNINT; \
+ \
+ cfs_set_current_state(__wstate); \
\
if (condition) \
break; \
\
if (__timeout == 0) { \
- cfs_waitq_wait(&__wait, CFS_TASK_INTERRUPTIBLE); \
+ cfs_waitq_wait(&__wait, __wstate); \
} else { \
cfs_duration_t interval = info->lwi_interval? \
min_t(cfs_duration_t, \
info->lwi_interval,__timeout):\
__timeout; \
cfs_duration_t remaining = cfs_waitq_timedwait(&__wait,\
- CFS_TASK_INTERRUPTIBLE, \
+ __wstate, \
interval); \
__timeout = cfs_time_sub(__timeout, \
cfs_time_sub(interval, remaining));\
(keylen >= (sizeof(str)-1) && memcmp(key, str, (sizeof(str)-1)) == 0)
/* Wrapper for contiguous page frame allocation */
-#define OBD_PAGES_ALLOC(ptr, order, gfp_mask) \
+#define OBD_PAGE_ALLOC(ptr, gfp_mask) \
do { \
- (ptr) = cfs_alloc_pages(gfp_mask, order); \
+ (ptr) = cfs_alloc_page(gfp_mask); \
if (unlikely((ptr) == NULL)) { \
CERROR("alloc_pages of '" #ptr "' %d page(s) / "LPU64" bytes "\
- "failed\n", (int)(1 << (order)), \
- (__u64)((1 << (order)) << CFS_PAGE_SHIFT)); \
+ "failed\n", (int)1, \
+ (__u64)(1 << CFS_PAGE_SHIFT)); \
CERROR(LPU64" total bytes and "LPU64" total pages " \
"("LPU64" bytes) allocated by Lustre, " \
"%d total bytes by LNET\n", \
obd_pages_sum(), \
cfs_atomic_read(&libcfs_kmemory)); \
} else { \
- obd_pages_add(order); \
+ obd_pages_add(0); \
CDEBUG(D_MALLOC, "alloc_pages '" #ptr "': %d page(s) / " \
LPU64" bytes at %p.\n", \
- (int)(1 << (order)), \
- (__u64)((1 << (order)) << CFS_PAGE_SHIFT), ptr); \
+ (int)1, \
+ (__u64)(1 << CFS_PAGE_SHIFT), ptr); \
} \
} while (0)
-#define OBD_PAGE_ALLOC(ptr, gfp_mask) \
- OBD_PAGES_ALLOC(ptr, 0, gfp_mask)
-
-#define OBD_PAGES_FREE(ptr, order) \
+#define OBD_PAGE_FREE(ptr) \
do { \
LASSERT(ptr); \
- obd_pages_sub(order); \
+ obd_pages_sub(0); \
CDEBUG(D_MALLOC, "free_pages '" #ptr "': %d page(s) / "LPU64" bytes " \
"at %p.\n", \
- (int)(1 << (order)), (__u64)((1 << (order)) << CFS_PAGE_SHIFT),\
+ (int)1, (__u64)(1 << CFS_PAGE_SHIFT), \
ptr); \
- __cfs_free_pages(ptr, order); \
+ cfs_free_page(ptr); \
(ptr) = (void *)0xdeadbeef; \
} while (0)
-#define OBD_PAGE_FREE(ptr) OBD_PAGES_FREE(ptr, 0)
-
#endif
git://git.whamcloud.com / fs / lustre-release.git / commitdiff