lnet/include/libcfs/user-prim.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2004 Cluster File Systems, Inc.
   5  * Author: Nikita Danilov <nikita@clusterfs.com>
   6  *
   7  * This file is part of Lustre, http://www.lustre.org.
   8  *
   9  * Lustre is free software; you can redistribute it and/or modify it under the
  10  * terms of version 2 of the GNU General Public License as published by the
  11  * Free Software Foundation.
  12  *
  13  * Lustre is distributed in the hope that it will be useful, but WITHOUT ANY
  14  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with Lustre; if not, write to the Free Software Foundation, Inc., 675 Mass
  20  * Ave, Cambridge, MA 02139, USA.
  21  *
  22  * Implementation of portable time API for user-level.
  23  *
  24  */
  25
  26 #ifndef __LIBCFS_USER_PRIM_H__
  27 #define __LIBCFS_USER_PRIM_H__
  28
  29 #ifndef __LIBCFS_LIBCFS_H__
  30 #error Do not #include this file directly. #include <libcfs/libcfs.h> instead
  31 #endif
  32
  33 /* Implementations of portable APIs for liblustre */
  34
  35 /*
  36  * liblustre is single-threaded, so most "synchronization" APIs are trivial.
  37  */
  38
  39 #ifndef __KERNEL__
  40
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <sys/signal.h>
  44 #include <sys/mman.h>
  45 #include <libcfs/list.h>
  46 #include <libcfs/user-time.h>
  47 #include <signal.h>
  48 #include <stdlib.h>
  49 #include <unistd.h>
  50
  51 #ifdef HAVE_LIBPTHREAD
  52 #include <pthread.h>
  53 #endif
  54
  55 #ifndef PAGE_SIZE
  56
  57 #define PAGE_SIZE (getpagesize())
  58 static __inline__ int getpageshift()
  59 {
  60         int pagesize = getpagesize();
  61 #if (__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))
  62         /* unsigned int is 32 bits on all our architectures */
  63         return (__builtin_clz(pagesize) ^ 31);
  64 #else
  65         register int pageshift = -1;
  66         while (pagesize) { pagesize >>= 1; pageshift++; }
  67         return pageshift;
  68 #endif
  69 }
  70
  71 #undef  PAGE_MASK
  72 #define PAGE_MASK  (~(PAGE_SIZE-1))
  73 #undef  PAGE_SHIFT
  74 #define PAGE_SHIFT (getpageshift())
  75
  76 #endif
  77
  78 /*
  79  * Wait Queue. No-op implementation.
  80  */
  81
  82 typedef struct cfs_waitlink {
  83         struct list_head sleeping;
  84         void *process;
  85 } cfs_waitlink_t;
  86
  87 typedef struct cfs_waitq {
  88         struct list_head sleepers;
  89 } cfs_waitq_t;
  90
  91 void cfs_waitq_init(struct cfs_waitq *waitq);
  92 void cfs_waitlink_init(struct cfs_waitlink *link);
  93 void cfs_waitq_add(struct cfs_waitq *waitq, struct cfs_waitlink *link);
  94 void cfs_waitq_add_exclusive(struct cfs_waitq *waitq,
  95                              struct cfs_waitlink *link);
  96 void cfs_waitq_forward(struct cfs_waitlink *link, struct cfs_waitq *waitq);
  97 void cfs_waitq_del(struct cfs_waitq *waitq, struct cfs_waitlink *link);
  98 int  cfs_waitq_active(struct cfs_waitq *waitq);
  99 void cfs_waitq_signal(struct cfs_waitq *waitq);
 100 void cfs_waitq_signal_nr(struct cfs_waitq *waitq, int nr);
 101 void cfs_waitq_broadcast(struct cfs_waitq *waitq);
 102 void cfs_waitq_wait(struct cfs_waitlink *link, int state);
 103 int64_t cfs_waitq_timedwait(struct cfs_waitlink *link, int state, int64_t timeout);
 104 #define cfs_schedule_timeout(s, t)              \
 105         do {                                    \
 106                 cfs_waitlink_t    l;            \
 107                 cfs_waitq_timedwait(&l, s, t);  \
 108         } while (0)
 109
 110 #define CFS_TASK_INTERRUPTIBLE  (0)
 111 #define CFS_TASK_UNINT          (0)
 112
 113 /* 2.4 defines */
 114
 115 /* XXX
 116  * for this moment, liblusre will not rely OST for non-page-aligned write
 117  */
 118 #define LIBLUSTRE_HANDLE_UNALIGNED_PAGE
 119
 120 struct page {
 121         void   *addr;
 122         unsigned long index;
 123         struct list_head list;
 124         unsigned long private;
 125
 126         /* internally used by liblustre file i/o */
 127         int     _offset;
 128         int     _count;
 129 #ifdef LIBLUSTRE_HANDLE_UNALIGNED_PAGE
 130         int     _managed;
 131 #endif
 132         struct list_head _node;
 133 };
 134
 135 typedef struct page cfs_page_t;
 136
 137 #define CFS_PAGE_SIZE                   PAGE_SIZE
 138 #define CFS_PAGE_SHIFT                  PAGE_SHIFT
 139 #define CFS_PAGE_MASK                   (~((__u64)CFS_PAGE_SIZE-1))
 140
 141 cfs_page_t *cfs_alloc_page(unsigned int flags);
 142 void cfs_free_page(cfs_page_t *pg);
 143 void *cfs_page_address(cfs_page_t *pg);
 144 void *cfs_kmap(cfs_page_t *pg);
 145 void cfs_kunmap(cfs_page_t *pg);
 146
 147 #define cfs_get_page(p)                 __I_should_not_be_called__(at_all)
 148 #define cfs_page_count(p)               __I_should_not_be_called__(at_all)
 149 #define cfs_page_index(p)               ((p)->index)
 150
 151 /*
 152  * Memory allocator
 153  * Inline function, so utils can use them without linking of libcfs
 154  */
 155 #define __ALLOC_ZERO    (1 << 2)
 156 static inline void *cfs_alloc(size_t nr_bytes, u_int32_t flags)
 157 {
 158         void *result;
 159
 160         result = malloc(nr_bytes);
 161         if (result != NULL && (flags & __ALLOC_ZERO))
 162                 memset(result, 0, nr_bytes);
 163         return result;
 164 }
 165
 166 #define cfs_free(addr)  free(addr)
 167 #define cfs_alloc_large(nr_bytes) cfs_alloc(nr_bytes, 0)
 168 #define cfs_free_large(addr) cfs_free(addr)
 169
 170 #define CFS_ALLOC_ATOMIC_TRY   (0)
 171 /*
 172  * SLAB allocator
 173  */
 174 typedef struct {
 175          int size;
 176 } cfs_mem_cache_t;
 177
 178 #define SLAB_HWCACHE_ALIGN 0
 179 #define SLAB_KERNEL 0
 180 #define SLAB_NOFS 0
 181
 182 cfs_mem_cache_t *
 183 cfs_mem_cache_create(const char *, size_t, size_t, unsigned long);
 184 int cfs_mem_cache_destroy(cfs_mem_cache_t *c);
 185 void *cfs_mem_cache_alloc(cfs_mem_cache_t *c, int gfp);
 186 void cfs_mem_cache_free(cfs_mem_cache_t *c, void *addr);
 187
 188 typedef int (cfs_read_proc_t)(char *page, char **start, off_t off,
 189                           int count, int *eof, void *data);
 190
 191 struct file; /* forward ref */
 192 typedef int (cfs_write_proc_t)(struct file *file, const char *buffer,
 193                                unsigned long count, void *data);
 194
 195 /*
 196  * Signal
 197  */
 198 typedef sigset_t                        cfs_sigset_t;
 199
 200 /*
 201  * Timer
 202  */
 203 #include <sys/time.h>
 204
 205 typedef struct {
 206         struct list_head tl_list;
 207         void (*function)(unsigned long unused);
 208         unsigned long data;
 209         long expires;
 210 } cfs_timer_t;
 211
 212 #define cfs_init_timer(t)       do {} while(0)
 213 #define cfs_jiffies                             \
 214 ({                                              \
 215         unsigned long _ret = 0;                 \
 216         struct timeval tv;                      \
 217         if (gettimeofday(&tv, NULL) == 0)       \
 218                 _ret = tv.tv_sec;               \
 219         _ret;                                   \
 220 })
 221
 222 static inline int cfs_timer_init(cfs_timer_t *l, void (* func)(unsigned long), void *arg)
 223 {
 224         CFS_INIT_LIST_HEAD(&l->tl_list);
 225         l->function = func;
 226         l->data = (unsigned long)arg;
 227         return 0;
 228 }
 229
 230 static inline int cfs_timer_is_armed(cfs_timer_t *l)
 231 {
 232         if (cfs_time_before(cfs_jiffies, l->expires))
 233                 return 1;
 234         else
 235                 return 0;
 236 }
 237
 238 static inline void cfs_timer_arm(cfs_timer_t *l, int thetime)
 239 {
 240         l->expires = thetime;
 241 }
 242
 243 static inline void cfs_timer_disarm(cfs_timer_t *l)
 244 {
 245 }
 246
 247 static inline long cfs_timer_deadline(cfs_timer_t *l)
 248 {
 249         return l->expires;
 250 }
 251
 252 #if 0
 253 #define cfs_init_timer(t)       do {} while(0)
 254 void cfs_timer_init(struct cfs_timer *t, void (*func)(unsigned long), void *arg);
 255 void cfs_timer_done(struct cfs_timer *t);
 256 void cfs_timer_arm(struct cfs_timer *t, cfs_time_t deadline);
 257 void cfs_timer_disarm(struct cfs_timer *t);
 258 int  cfs_timer_is_armed(struct cfs_timer *t);
 259
 260 cfs_time_t cfs_timer_deadline(struct cfs_timer *t);
 261 #endif
 262
 263 #define in_interrupt()    (0)
 264
 265 static inline void cfs_pause(cfs_duration_t d)
 266 {
 267         struct timespec s;
 268
 269         cfs_duration_nsec(d, &s);
 270         nanosleep(&s, NULL);
 271 }
 272
 273 typedef void cfs_psdev_t;
 274
 275 static inline int cfs_psdev_register(cfs_psdev_t *foo)
 276 {
 277         return 0;
 278 }
 279
 280 static inline int cfs_psdev_deregister(cfs_psdev_t *foo)
 281 {
 282         return 0;
 283 }
 284
 285 #define cfs_lock_kernel()               do {} while (0)
 286 #define cfs_sigfillset(l) do {}         while (0)
 287 #define cfs_recalc_sigpending(l)        do {} while (0)
 288 #define cfs_kernel_thread(l,m,n)        LBUG()
 289
 290 #ifdef HAVE_LIBPTHREAD
 291 typedef int (*cfs_thread_t)(void *);
 292 int cfs_create_thread(cfs_thread_t func, void *arg);
 293 #else
 294 #define cfs_create_thread(l,m) LBUG()
 295 #endif
 296
 297 int cfs_parse_int_tunable(int *value, char *name);
 298 uid_t cfs_curproc_uid(void);
 299
 300 #define LIBCFS_REALLOC(ptr, size) realloc(ptr, size)
 301
 302 #define cfs_online_cpus() sysconf(_SC_NPROCESSORS_ONLN)
 303
 304 // static inline void local_irq_save(unsigned long flag) {return;}
 305 // static inline void local_irq_restore(unsigned long flag) {return;}
 306
 307 enum {
 308         CFS_STACK_TRACE_DEPTH = 16
 309 };
 310
 311 struct cfs_stack_trace {
 312         void *frame[CFS_STACK_TRACE_DEPTH];
 313 };
 314
 315 /*
 316  * arithmetic
 317  */
 318 #define do_div(a,b)                     \
 319         ({                              \
 320                 unsigned long remainder;\
 321                 remainder = (a) % (b);  \
 322                 (a) = (a) / (b);        \
 323                 (remainder);            \
 324         })
 325
 326 /* !__KERNEL__ */
 327 #endif
 328
 329 /* __LIBCFS_USER_PRIM_H__ */
 330 #endif
 331 /*
 332  * Local variables:
 333  * c-indentation-style: "K&R"
 334  * c-basic-offset: 8
 335  * tab-width: 8
 336  * fill-column: 80
 337  * scroll-step: 1
 338  * End:
 339  */