1 #ifndef _S_MEMORY_H__
2 #define _S_MEMORY_H__
3
4 #include "net_defs.h"
5 #include "net_debug.h"
6
7 struct s_mem_element{
8 unsigned int size;
9 unsigned char data[0];
10 };
11 //#define DEBUG_S_MEMORY
12 extern void s_system_heap_init(void *begin_addr, void *end_addr);
13 extern void *s_malloc(size_t size,char* func,unsigned int line);
14 extern void *s_realloc(void *rmem, size_t newsize,char* func,unsigned int line);
15 extern void *s_calloc(size_t count, size_t size,char* func,unsigned int line);
16 extern void s_free(void *rmem);
17 extern void *s_kmalloc(size_t size, gfp_t flags,char* func,unsigned int line);
18 extern void *s_kzalloc(size_t size, gfp_t flags,char* func,unsigned int line);
19 extern int s_kfree(void * mem);
20 extern void *s_krealloc(const void *p, size_t new_size, gfp_t flags,char* func,unsigned int line);
21 extern void s_print_mem_dump(void * mem);
22 #if 1
23 #define skmalloc(size, flags) (\
24 {\
25 uint8_t* ret = NULL;\
26 ret = s_kmalloc(size, flags,(char*)__func__, __LINE__);\
27 ret;\
28 }\
29 )
30 /*memset(test_buff,0,100);\
31 strcpy(test_buff,func); \
32 strcat(test_buff,' :: '); \
33 strcat(test_buff,__func__); \*/
34
35 #define skmalloc1(size, flags,func) (\
36 {\
37 uint8_t* ret = NULL;\
38 ret = s_kmalloc(size, flags,func, __LINE__);\
39 ret;\
40 }\
41 )
42 #else
43 #define skmalloc(size, flags) (\
44 {\
45 uint8_t* ret = NULL;\
46 ret = s_kmalloc(size, flags);\
47 printk(KERN_DEBUG, "skmalloc %s %d mem = 0x%x size:%d\n", __func__, __LINE__, ret, size);\
48 ret;\
49 }\
50 )
51 #endif
52 /**
53 * skzalloc - allocate memory. The memory is set to zero.
54 * @size: how many bytes of memory are required.
55 * @flags: the type of memory to allocate (see kmalloc).
56 */
57 #if 0
58 #define skzalloc(size, flags) (\
59 { \
60 uint8_t* ret = NULL;\
61 ret = s_kzalloc(size, flags);\
62 ret;\
63 }\
64 )
65 #else
66 #define skzalloc(size, flags) (\
67 { \
68 uint8_t* ret = NULL;\
69 ret = s_kzalloc(size, flags,__func__, __LINE__);\
70 printk(KERN_DEBUG, "kzalloc %s %d mem = 0x%x\n", __func__, __LINE__, ret);\
71 ret;\
72 }\
73 )
74 #endif
75 /**
76 * skcalloc - allocate memory for an array. The memory is set to zero.
77 * @n: number of elements.
78 * @size: element size.
79 * @flags: the type of memory to allocate (see kmalloc).
80 */
81 #define skcalloc( n, size, flags) skzalloc(n*size, flags)
82 #define smem_calloc(n, size) skzalloc(n*size, 1)
83
s_ksize(const void * objp)84 static __INLINE size_t s_ksize(const void *objp)
85 {
86 struct s_mem_element* mem_p = NULL;
87 mem_p = (struct s_mem_element *)((size_t)objp - offsetof(struct s_mem_element, data));
88 return mem_p->size;
89 }
90 #if 1
91 #define skzfree(mem) ({ \
92 uint32_t ret;\
93 if(mem) \
94 ret = s_kfree(mem);\
95 else\
96 ret = 0;\
97 ret;\
98 })
99 #else
100 #define skzfree(mem) ({ \
101 uint32_t ret;\
102 printk(KERN_DEBUG, "skzfree %s %d %x \n", __func__, __LINE__, mem);\
103 if(mem) \
104 ret = s_kfree(mem);\
105 else\
106 ret = 0;\
107 ret;\
108 })
109
110 #endif
111 #if 1
112 #define skfree(ptr) ({ \
113 uint32_t ret;\
114 if(ptr) \
115 ret = s_kfree(ptr);\
116 else\
117 ret = 0;\
118 ret;\
119 })
120
121 #define skrealloc(p, new_size, flags) ({\
122 uint8_t* ret = NULL;\
123 ret = s_krealloc(p, new_size, flags,__func__, __LINE__);\
124 ret;\
125 })
126 #else
127 #define skfree(ptr) ({ \
128 uint32_t ret;\
129 printk(KERN_DEBUG, "skfree %s %d %x \n", __func__, __LINE__, ptr);\
130 if(ptr) \
131 ret = s_kfree(ptr);\
132 else\
133 ret = 0;\
134 ret;\
135 })
136
137 #define skrealloc(p, new_size, flags) ({\
138 uint8_t* ret = NULL;\
139 printk(KERN_DEBUG, "skrealloc %s %d src_mem = 0x%x new_size:%d\n", __func__, __LINE__, p, new_size);\
140 ret = s_krealloc(p, new_size, flags);\
141 printk(KERN_DEBUG, "skrealloc mem = 0x%x\n", ret);\
142 ret;\
143 })
144
145 #endif
146 extern void *skmemdup(const void *src, size_t len, gfp_t gfp);
147 #endif
148