Whamcloud - gitweb
LU-744 clio: save memory allocations for cl_page
[fs/lustre-release.git] / libcfs / include / libcfs / posix / libcfs.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2012, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * libcfs/include/libcfs/posix/libcfs.h
37  *
38  * Defines for posix userspace.
39  *
40  * Author: Robert Read <rread@sun.com>
41  */
42
43 #ifndef __LIBCFS_POSIX_LIBCFS_H__
44 #define __LIBCFS_POSIX_LIBCFS_H__
45
46 #include <errno.h>
47 #include <sys/errno.h>
48 #include <string.h>
49 #include <stdarg.h>
50 #include <stddef.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <sys/mman.h>
54 #include <sys/stat.h>
55 #include <fcntl.h>
56 #include <limits.h>
57 #include <assert.h>
58 #include <sys/ioctl.h>
59 #include <sys/signal.h>
60 #include <signal.h>
61 #include <sys/time.h>
62 #include <time.h>
63 #include <getopt.h>
64 #include <signal.h>
65 #include <pwd.h>
66 #include <sys/socket.h>
67 #include <sys/utsname.h>
68 #include <ctype.h>
69 #include <stdbool.h>
70
71 #ifdef HAVE_NETDB_H
72 #include <netdb.h>
73 #endif
74
75 #ifdef HAVE_UNISTD_H
76 #include <unistd.h>
77 #endif
78
79 #ifdef HAVE_LIBPTHREAD
80 #include <pthread.h>
81 #endif
82
83 #if defined(HAVE_SYS_TYPES_H)
84 #include <sys/types.h>
85 #endif
86
87 #ifdef HAVE_SYS_USER_H
88 # include <sys/user.h>
89 #endif
90
91 #ifdef HAVE_SYS_VFS_H
92 # include <sys/vfs.h>
93 #endif
94
95 #ifdef HAVE_STDINT_H
96 # include <stdint.h>
97 #endif
98
99 #include <libcfs/list.h>
100 #include <libcfs/posix/posix-types.h>
101 #include <libcfs/user-time.h>
102 #include <libcfs/user-prim.h>
103 #include <libcfs/user-mem.h>
104 #include <libcfs/user-lock.h>
105 #include <libcfs/user-tcpip.h>
106 #include <libcfs/posix/posix-wordsize.h>
107 #include <libcfs/user-bitops.h>
108
109 # define cfs_gettimeofday(tv) gettimeofday(tv, NULL);
110 typedef unsigned long long cfs_cycles_t;
111
112 #define IS_ERR(a) ((unsigned long)(a) > (unsigned long)-1000L)
113 #define PTR_ERR(a) ((long)(a))
114 #define ERR_PTR(a) ((void*)((long)(a)))
115
116 /* this goes in posix-fs.h */
117 #include <sys/mount.h>
118
119 #ifdef __linux__
120 #include <mntent.h>
121 #endif
122
123 typedef struct file cfs_file_t;
124 typedef struct dentry cfs_dentry_t;
125 #ifdef __linux__
126 typedef struct dirent64 cfs_dirent_t;
127 #endif
128
129 #define cfs_get_fd(x)   NULL
130 #define cfs_put_file(f) do {} while (0)
131
132 #ifdef __linux__
133 /* Userpace byte flipping */
134 # include <endian.h>
135 # include <byteswap.h>
136 # define __swab16(x) bswap_16(x)
137 # define __swab32(x) bswap_32(x)
138 # define __swab64(x) bswap_64(x)
139 # define __swab16s(x) do {*(x) = bswap_16(*(x));} while (0)
140 # define __swab32s(x) do {*(x) = bswap_32(*(x));} while (0)
141 # define __swab64s(x) do {*(x) = bswap_64(*(x));} while (0)
142 # if __BYTE_ORDER == __LITTLE_ENDIAN
143 #  define le16_to_cpu(x) (x)
144 #  define cpu_to_le16(x) (x)
145 #  define le32_to_cpu(x) (x)
146 #  define cpu_to_le32(x) (x)
147 #  define le64_to_cpu(x) (x)
148 #  define cpu_to_le64(x) (x)
149
150 #  define be16_to_cpu(x) bswap_16(x)
151 #  define cpu_to_be16(x) bswap_16(x)
152 #  define be32_to_cpu(x) bswap_32(x)
153 #  define cpu_to_be32(x) bswap_32(x)
154 #  define be64_to_cpu(x) (__u64)bswap_64(x)
155 #  define cpu_to_be64(x) (__u64)bswap_64(x)
156 # else
157 #  if __BYTE_ORDER == __BIG_ENDIAN
158 #   define le16_to_cpu(x) bswap_16(x)
159 #   define cpu_to_le16(x) bswap_16(x)
160 #   define le32_to_cpu(x) bswap_32(x)
161 #   define cpu_to_le32(x) bswap_32(x)
162 #   define le64_to_cpu(x) (__u64)bswap_64(x)
163 #   define cpu_to_le64(x) (__u64)bswap_64(x)
164
165 #   define be16_to_cpu(x) (x)
166 #   define cpu_to_be16(x) (x)
167 #   define be32_to_cpu(x) (x)
168 #   define cpu_to_be32(x) (x)
169 #   define be64_to_cpu(x) (x)
170 #   define cpu_to_be64(x) (x)
171
172 #  else
173 #   error "Unknown byte order"
174 #  endif /* __BIG_ENDIAN */
175 # endif /* __LITTLE_ENDIAN */
176 #elif __APPLE__
177 #define __cpu_to_le64(x)                        OSSwapHostToLittleInt64(x)
178 #define __cpu_to_le32(x)                        OSSwapHostToLittleInt32(x)
179 #define __cpu_to_le16(x)                        OSSwapHostToLittleInt16(x)
180
181 #define __le16_to_cpu(x)                        OSSwapLittleToHostInt16(x)
182 #define __le32_to_cpu(x)                        OSSwapLittleToHostInt32(x)
183 #define __le64_to_cpu(x)                        OSSwapLittleToHostInt64(x)
184
185 #define cpu_to_le64(x)                          __cpu_to_le64(x)
186 #define cpu_to_le32(x)                          __cpu_to_le32(x)
187 #define cpu_to_le16(x)                          __cpu_to_le16(x)
188
189 #define le64_to_cpu(x)                          __le64_to_cpu(x)
190 #define le32_to_cpu(x)                          __le32_to_cpu(x)
191 #define le16_to_cpu(x)                          __le16_to_cpu(x)
192
193 #define __swab16(x)                             OSSwapInt16(x)
194 #define __swab32(x)                             OSSwapInt32(x)
195 #define __swab64(x)                             OSSwapInt64(x)
196 #define __swab16s(x)                            do { *(x) = __swab16(*(x)); } while (0)
197 #define __swab32s(x)                            do { *(x) = __swab32(*(x)); } while (0)
198 #define __swab64s(x)                            do { *(x) = __swab64(*(x)); } while (0)
199 #endif
200
201 #if !defined(ALIGN)
202 #define __ALIGN_MASK(x, mask)   (((x) + (mask)) & ~(mask))
203 #define ALIGN(x, a)             __ALIGN_MASK(x, (typeof(x))(a) - 1)
204 #endif
205
206 # ifndef THREAD_SIZE /* x86_64 linux has THREAD_SIZE in userspace */
207 #  define CFS_THREAD_SIZE 8192
208 # else
209 #  define CFS_THREAD_SIZE THREAD_SIZE
210 # endif
211
212 #define LUSTRE_TRACE_SIZE (CFS_THREAD_SIZE >> 5)
213
214 #define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0)
215 #define CDEBUG_STACK() (0L)
216
217 /* initial pid  */
218 #define LUSTRE_LNET_PID          12345
219
220 #define ENTRY_NESTING_SUPPORT (1)
221 #define ENTRY_NESTING   do {;} while (0)
222 #define EXIT_NESTING   do {;} while (0)
223 #define __current_nesting_level() (0)
224
225 /**
226  * Platform specific declarations for cfs_curproc API (libcfs/curproc.h)
227  *
228  * Implementation is in linux-curproc.c
229  */
230 #define CFS_CURPROC_COMM_MAX (sizeof ((struct task_struct *)0)->comm)
231
232 typedef __u32 cfs_kernel_cap_t;
233
234 /**
235  * Module support (probably shouldn't be used in generic code?)
236  */
237 typedef struct cfs_module {
238         int count;
239         char *name;
240 } cfs_module_t;
241
242 static inline void MODULE_AUTHOR(char *name)
243 {
244         printf("%s\n", name);
245 }
246 #define MODULE_DESCRIPTION(name) MODULE_AUTHOR(name)
247 #define MODULE_LICENSE(name) MODULE_AUTHOR(name)
248
249 #define THIS_MODULE (void *)0x11111
250 #define __init
251 #define __exit
252
253 #define EXPORT_SYMBOL(symbol)
254
255 static inline int cfs_request_module(const char *name, ...)
256 {
257         return (-EINVAL);
258 }
259
260 static inline void __cfs_module_get(cfs_module_t *module)
261 {
262 }
263
264 static inline int cfs_try_module_get(cfs_module_t *module)
265 {
266         return 1;
267 }
268
269 static inline void cfs_module_put(cfs_module_t *module)
270 {
271 }
272
273
274 static inline int cfs_module_refcount(cfs_module_t *m)
275 {
276         return 1;
277 }
278
279 /***************************************************************************
280  *
281  * Linux kernel slab shrinker emulation. Currently used only in lu_object.c
282  *
283  ***************************************************************************/
284
285 struct cfs_shrinker {
286         ;
287 };
288
289 #define CFS_DEFAULT_SEEKS (0)
290
291 typedef int (*cfs_shrinker_t)(int, unsigned int);
292
293 static inline
294 struct cfs_shrinker *cfs_set_shrinker(int seeks, cfs_shrinker_t shrink)
295 {
296         return (struct cfs_shrinker *)0xdeadbea1; // Cannot return NULL here
297 }
298
299 static inline void cfs_remove_shrinker(struct cfs_shrinker *shrinker)
300 {
301 }
302
303 /***************************************************************************
304  *
305  * Linux kernel radix tree emulation.
306  *
307  * XXX this stub-implementation assumes that elements stored in a radix tree
308  *     are struct page's and nothing else. Proper implementation will be
309  *     committed soon.
310  *
311  ***************************************************************************/
312
313 struct radix_tree_root {
314         cfs_list_t list;
315         void *rnode;
316 };
317
318 struct radix_tree_node {
319         cfs_list_t _node;
320         unsigned long index;
321         void *item;
322 };
323
324 #define RADIX_TREE_INIT(mask)   {               \
325                 NOT_IMPLEMENTED                 \
326 }
327
328 #define RADIX_TREE(name, mask) \
329         struct radix_tree_root name = RADIX_TREE_INIT(mask)
330
331
332 #define INIT_RADIX_TREE(root, mask)                                     \
333 do {                                                                    \
334         CFS_INIT_LIST_HEAD(&((struct radix_tree_root *)root)->list);    \
335         ((struct radix_tree_root *)root)->rnode = NULL;                 \
336 } while (0)
337
338 static inline int radix_tree_insert(struct radix_tree_root *root,
339                         unsigned long idx, void *item)
340 {
341         struct radix_tree_node *node;
342         node = malloc(sizeof(*node));
343         if (!node)
344                 return -ENOMEM;
345
346         CFS_INIT_LIST_HEAD(&node->_node);
347         node->index = idx;
348         node->item = item;
349         cfs_list_add_tail(&node->_node, &root->list);
350         root->rnode = (void *)1001;
351         return 0;
352 }
353
354 static inline struct radix_tree_node *radix_tree_lookup0(struct radix_tree_root *root,
355                                       unsigned long idx)
356 {
357         struct radix_tree_node *node;
358
359         if (cfs_list_empty(&root->list))
360                 return NULL;
361
362         cfs_list_for_each_entry_typed(node, &root->list,
363                                       struct radix_tree_node, _node)
364                 if (node->index == idx)
365                         return node;
366
367         return NULL;
368 }
369
370 static inline void *radix_tree_lookup(struct radix_tree_root *root,
371                                       unsigned long idx)
372 {
373         struct radix_tree_node *node = radix_tree_lookup0(root, idx);
374
375         if (node)
376                 return node->item;
377         return node;
378 }
379
380 static inline void *radix_tree_delete(struct radix_tree_root *root,
381                                       unsigned long idx)
382 {
383         struct radix_tree_node *p = radix_tree_lookup0(root, idx);
384         void *item;
385
386         if (p == NULL)
387                 return NULL;
388
389         cfs_list_del_init(&p->_node);
390         item = p->item;
391         free(p);
392         if (cfs_list_empty(&root->list))
393                 root->rnode = NULL;
394
395         return item;
396 }
397
398 static inline unsigned int
399 radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
400                        unsigned long first_index, unsigned int max_items)
401 {
402         int i;
403         int j = 0;
404
405         for (i = 0; i < max_items; i++, first_index++) {
406                 results[j++] = radix_tree_lookup(root, first_index);
407                 if (results[j - 1] == NULL)
408                         --j;
409         }
410
411         return j;
412 }
413
414 static inline int radix_tree_preload(int gfp_mask)
415 {
416         return 0;
417 }
418
419 void radix_tree_init(void);
420
421 static inline void radix_tree_preload_end(void)
422 {
423 }
424
425 /***************************************************************************
426  *
427  * Linux kernel red black tree emulation.
428  *
429  ***************************************************************************/
430 struct rb_node {
431         unsigned long  rb_parent_color;
432 #define RB_RED          0
433 #define RB_BLACK        1
434         struct rb_node *rb_right;
435         struct rb_node *rb_left;
436 };
437
438 struct rb_root {
439         struct rb_node *rb_node;
440 };
441
442
443 #define rb_parent(r)   ((struct rb_node *)((r)->rb_parent_color & ~3))
444 #define rb_color(r)   ((r)->rb_parent_color & 1)
445 #define rb_is_red(r)   (!rb_color(r))
446 #define rb_is_black(r) rb_color(r)
447 #define rb_set_red(r)  do { (r)->rb_parent_color &= ~1; } while (0)
448 #define rb_set_black(r)  do { (r)->rb_parent_color |= 1; } while (0)
449
450 static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
451 {
452         rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
453 }
454 static inline void rb_set_color(struct rb_node *rb, int color)
455 {
456         rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
457 }
458
459 #define RB_ROOT ((struct rb_root) { NULL, })
460 #define rb_entry(ptr, type, member) container_of(ptr, type, member)
461
462 #define RB_EMPTY_ROOT(root)     ((root)->rb_node == NULL)
463 #define RB_EMPTY_NODE(node)     (rb_parent(node) == node)
464 #define RB_CLEAR_NODE(node)     (rb_set_parent(node, node))
465
466 static inline void rb_init_node(struct rb_node *rb)
467 {
468         rb->rb_parent_color = 0;
469         rb->rb_right = NULL;
470         rb->rb_left = NULL;
471         RB_CLEAR_NODE(rb);
472 }
473
474 extern void rb_insert_color(struct rb_node *, struct rb_root *);
475 extern void rb_erase(struct rb_node *, struct rb_root *);
476
477 /* Find logical next and previous nodes in a tree */
478 extern struct rb_node *rb_next(const struct rb_node *);
479 extern struct rb_node *rb_prev(const struct rb_node *);
480 extern struct rb_node *rb_first(const struct rb_root *);
481 extern struct rb_node *rb_last(const struct rb_root *);
482 static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
483                                 struct rb_node **rb_link)
484 {
485         node->rb_parent_color = (unsigned long)parent;
486         node->rb_left = node->rb_right = NULL;
487
488         *rb_link = node;
489 }
490
491 /***************************************************************************
492  *
493  * End of Linux kernel red black tree emulation.
494  *
495  ***************************************************************************/
496
497 typedef ssize_t (*read_actor_t)();
498
499 #define CFS_IFSHIFT 12
500
501 #define CFS_IFTODT(type)           (((type) & S_IFMT) >> CFS_IFSHIFT)
502 #define CFS_DTTOIF(dirtype)        ((dirtype) << CFS_IFSHIFT)
503
504 #endif