mirror of
https://github.com/schoebel/mars
synced 2024-12-27 17:12:32 +00:00
241 lines
6.9 KiB
C
241 lines
6.9 KiB
C
/*
|
|
* MARS Long Distance Replication Software
|
|
*
|
|
* This file is part of MARS project: http://schoebel.github.io/mars/
|
|
*
|
|
* Copyright (C) 2010-2014 Thomas Schoebel-Theuer
|
|
* Copyright (C) 2011-2014 1&1 Internet AG
|
|
*
|
|
* This program 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.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef BRICK_MEM_H
|
|
#define BRICK_MEM_H
|
|
|
|
/* TRANSITIONAL compatibility to BOTH the old prepatch
|
|
* and the new wrapper around vfs_*(). Both will be replaced
|
|
* for kernel upstream.
|
|
*/
|
|
#include "compat.h"
|
|
|
|
#include <linux/mm_types.h>
|
|
|
|
#ifndef CONFIG_MARS_MODULE
|
|
// when unsure, include faked config file
|
|
#include "mars_config.h"
|
|
#endif
|
|
|
|
#define BRICK_DEBUG_MEM 4096
|
|
|
|
#ifndef CONFIG_MARS_DEBUG_MEM
|
|
#undef BRICK_DEBUG_MEM
|
|
#endif
|
|
#ifdef CONFIG_MARS_DEBUG_ORDER0
|
|
#define BRICK_DEBUG_ORDER0
|
|
#endif
|
|
|
|
#define GFP_BRICK GFP_NOIO
|
|
//#define GFP_BRICK GFP_KERNEL // can lead to deadlocks!
|
|
|
|
extern long long brick_global_memavail;
|
|
extern long long brick_global_memlimit;
|
|
extern atomic64_t brick_global_block_used;
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// compiler tweaking
|
|
|
|
/* Some functions are known to return non-null pointer values,
|
|
* at least under some Kconfig conditions.
|
|
*
|
|
* In code like...
|
|
*
|
|
* void *ptr = myfunction();
|
|
* if (unlikely(!ptr)) {
|
|
* printk("ERROR: this should not happen\n");
|
|
* goto fail;
|
|
* }
|
|
*
|
|
* ... the dead code elimination of gcc will not remove the if clause
|
|
* because the function might return a NULL value, even if a human
|
|
* would know that myfunction() does not return a NULL value.
|
|
*
|
|
* Unfortunately, the __attribute__((nonnull)) can only be applied
|
|
* to input parameters, but not to the return value.
|
|
*
|
|
* More unfortunately, a small inline wrapper does not help,
|
|
* because it seems that together with the elimination of the wrapper,
|
|
* its nonnull attribute seems to be eliminated alltogether.
|
|
* I don't know whether this is a bug or a feature (or just a weakness).
|
|
*
|
|
* Following is a small hack which solves the problem at least for gcc 4.7.
|
|
*
|
|
* In order to be useful, the -fdelete-null-pointer-checks must be set.
|
|
* Since MARS is superuser-only anyway, enabling this for MARS should not
|
|
* be a security risk
|
|
* (c.f. upstream kernel commit a3ca86aea507904148870946d599e07a340b39bf)
|
|
*/
|
|
extern inline
|
|
void *__mark_ptr_nonnull(void *_ptr)
|
|
{
|
|
char *ptr = _ptr;
|
|
// fool gcc to believe that the pointer were dereferenced...
|
|
asm("" : : "X" (*ptr));
|
|
return ptr;
|
|
}
|
|
|
|
/* All the brick memory allocations are guaranteed to succeed when
|
|
* CONFIG_MARS_MEM_RETRY is set. In case of low memory, they will just
|
|
* retry (forever).
|
|
*
|
|
* Allow checking code to be written which works for both cases:
|
|
* CONFIG_MARS_MEM_RETRY is selected, or not.
|
|
*/
|
|
#ifdef CONFIG_MARS_MEM_RETRY
|
|
#define brick_mark_nonnull __mark_ptr_nonnull
|
|
#else
|
|
#define brick_mark_nonnull(p) (p)
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// small memory allocation (use this only for len < PAGE_SIZE)
|
|
|
|
#define brick_mem_alloc(_len_) \
|
|
({ \
|
|
void *_res_ = _brick_mem_alloc(_len_, __LINE__); \
|
|
brick_mark_nonnull(_res_); \
|
|
})
|
|
|
|
#define brick_zmem_alloc(_len_) \
|
|
({ \
|
|
void *_res_ = _brick_mem_alloc(_len_, __LINE__); \
|
|
_res_ = brick_mark_nonnull(_res_); \
|
|
if (_res_) { \
|
|
memset(_res_, 0, _len_); \
|
|
} \
|
|
_res_; \
|
|
})
|
|
|
|
#define brick_mem_free(_data_) \
|
|
do { \
|
|
if (_data_) { \
|
|
_brick_mem_free(_data_, __LINE__); \
|
|
} \
|
|
} while(0)
|
|
|
|
|
|
// don't use the following directly
|
|
extern void *_brick_mem_alloc(int len, int line) __attribute__((malloc)) __attribute__((alloc_size(1)));
|
|
extern void _brick_mem_free(void *data, int line);
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// string memory allocation
|
|
|
|
#define BRICK_STRING_LEN 1024 /* default value when len == 0 */
|
|
|
|
#define brick_string_alloc(_len_) \
|
|
({ \
|
|
char *_res_ = _brick_string_alloc((_len_), __LINE__); \
|
|
(char*)brick_mark_nonnull(_res_); \
|
|
})
|
|
|
|
#define brick_strndup(_orig_,_len_) \
|
|
({ \
|
|
char *_res_ = _brick_string_alloc((_len_) + 1, __LINE__); \
|
|
_res_ = brick_mark_nonnull(_res_); \
|
|
if (_res_) { \
|
|
strncpy(_res_, (_orig_), (_len_)); \
|
|
/* always null-terminate for safety */ \
|
|
_res_[_len_] = '\0'; \
|
|
} \
|
|
(char*)brick_mark_nonnull(_res_); \
|
|
})
|
|
|
|
#define brick_strdup(_orig_) \
|
|
({ \
|
|
int _len_ = strlen(_orig_); \
|
|
char *_res_ = _brick_string_alloc((_len_) + 1, __LINE__); \
|
|
_res_ = brick_mark_nonnull(_res_); \
|
|
if (_res_) { \
|
|
strncpy(_res_, (_orig_), (_len_) + 1); \
|
|
} \
|
|
(char*)brick_mark_nonnull(_res_); \
|
|
})
|
|
|
|
#define brick_string_free(_data_) \
|
|
do { \
|
|
if (_data_) { \
|
|
_brick_string_free(_data_, __LINE__); \
|
|
} \
|
|
} while(0)
|
|
|
|
// don't use the following directly
|
|
extern char *_brick_string_alloc(int len, int line) __attribute__((malloc));
|
|
extern void _brick_string_free(const char *data, int line);
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// block memory allocation (for aligned multiples of 512 resp PAGE_SIZE)
|
|
|
|
#define brick_block_alloc(_pos_,_len_) \
|
|
({ \
|
|
void *_res_ = _brick_block_alloc((_pos_), (_len_), __LINE__); \
|
|
brick_mark_nonnull(_res_); \
|
|
})
|
|
|
|
#define brick_block_free(_data_,_len_)\
|
|
do { \
|
|
if (_data_) { \
|
|
_brick_block_free((_data_), (_len_), __LINE__); \
|
|
} \
|
|
} while(0)
|
|
|
|
extern struct page *brick_iomap(void *data, int *offset, int *len);
|
|
|
|
// don't use the following directly
|
|
extern void *_brick_block_alloc(loff_t pos, int len, int line) __attribute__((malloc)) __attribute__((alloc_size(2)));
|
|
extern void _brick_block_free(void *data, int len, int cline);
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// reservations / preallocation
|
|
|
|
#define BRICK_MAX_ORDER 11
|
|
|
|
#ifdef CONFIG_MARS_MEM_PREALLOC
|
|
extern int brick_allow_freelist;
|
|
|
|
extern int brick_pre_reserve[BRICK_MAX_ORDER+1];
|
|
extern int brick_mem_freelist_max[BRICK_MAX_ORDER+1];
|
|
extern int brick_mem_alloc_count[BRICK_MAX_ORDER+1];
|
|
extern int brick_mem_alloc_max[BRICK_MAX_ORDER+1];
|
|
|
|
extern int brick_mem_reserve(void);
|
|
|
|
#endif
|
|
|
|
extern void brick_mem_statistics(bool final);
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// init
|
|
|
|
extern int init_brick_mem(void);
|
|
extern void exit_brick_mem(void);
|
|
|
|
#endif
|