libcfs/libcfs/user-prim.c

   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) 2011, 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/libcfs/user-prim.c
  37  *
  38  * Implementations of portable APIs for liblustre
  39  *
  40  * Author: Nikita Danilov <nikita@clusterfs.com>
  41  */
  42
  43 /*
  44  * liblustre is single-threaded, so most "synchronization" APIs are trivial.
  45  */
  46
  47 #ifndef __KERNEL__
  48
  49 #include <string.h>
  50 #include <libcfs/libcfs.h>
  51
  52 /*
  53  * Wait queue. No-op implementation.
  54  */
  55
  56 void init_waitqueue_head(struct cfs_waitq *waitq)
  57 {
  58         LASSERT(waitq != NULL);
  59         (void)waitq;
  60 }
  61
  62 void init_waitqueue_entry_current(struct cfs_waitlink *link)
  63 {
  64         LASSERT(link != NULL);
  65         (void)link;
  66 }
  67
  68 void add_wait_queue(struct cfs_waitq *waitq, struct cfs_waitlink *link)
  69 {
  70         LASSERT(waitq != NULL);
  71         LASSERT(link != NULL);
  72         (void)waitq;
  73         (void)link;
  74 }
  75
  76 void add_wait_queue_exclusive(struct cfs_waitq *waitq, struct cfs_waitlink *link)
  77 {
  78         LASSERT(waitq != NULL);
  79         LASSERT(link != NULL);
  80         (void)waitq;
  81         (void)link;
  82 }
  83
  84 void add_wait_queue_exclusive_head(struct cfs_waitq *waitq, struct cfs_waitlink *link)
  85 {
  86         add_wait_queue_exclusive(waitq, link);
  87 }
  88
  89 void remove_wait_queue(struct cfs_waitq *waitq, struct cfs_waitlink *link)
  90 {
  91         LASSERT(waitq != NULL);
  92         LASSERT(link != NULL);
  93         (void)waitq;
  94         (void)link;
  95 }
  96
  97 int waitqueue_active(struct cfs_waitq *waitq)
  98 {
  99         LASSERT(waitq != NULL);
 100         (void)waitq;
 101         return 0;
 102 }
 103
 104 void wake_up(struct cfs_waitq *waitq)
 105 {
 106         LASSERT(waitq != NULL);
 107         (void)waitq;
 108 }
 109
 110 void wake_up_nr(struct cfs_waitq *waitq, int nr)
 111 {
 112         LASSERT(waitq != NULL);
 113         (void)waitq;
 114 }
 115
 116 void wake_up_all(struct cfs_waitq *waitq)
 117 {
 118         LASSERT(waitq != NULL);
 119         (void)waitq;
 120 }
 121
 122 void waitq_wait(struct cfs_waitlink *link, long state)
 123 {
 124         LASSERT(link != NULL);
 125         (void)link;
 126
 127         /* well, wait for something to happen */
 128         call_wait_handler(0);
 129 }
 130
 131 int64_t waitq_timedwait(struct cfs_waitlink *link, long state,
 132                         int64_t timeout)
 133 {
 134         LASSERT(link != NULL);
 135         (void)link;
 136         call_wait_handler(timeout);
 137         return 0;
 138 }
 139
 140 void schedule_timeout_and_set_state(long state, int64_t timeout)
 141 {
 142         wait_queue_t    l;
 143         /* sleep(timeout) here instead? */
 144         waitq_timedwait(&l, state, timeout);
 145 }
 146
 147 void
 148 cfs_pause(cfs_duration_t d)
 149 {
 150         struct timespec s;
 151
 152         cfs_duration_nsec(d, &s);
 153         nanosleep(&s, NULL);
 154 }
 155
 156 int need_resched(void)
 157 {
 158         return 0;
 159 }
 160
 161 void cond_resched(void)
 162 {
 163 }
 164
 165 /*
 166  * Timer
 167  */
 168
 169 void cfs_init_timer(struct timer_list *t)
 170 {
 171         INIT_LIST_HEAD(&t->tl_list);
 172 }
 173
 174 void cfs_timer_init(struct timer_list *l, cfs_timer_func_t *func, void *arg)
 175 {
 176         INIT_LIST_HEAD(&l->tl_list);
 177         l->function = func;
 178         l->data = (ulong_ptr_t)arg;
 179         return;
 180 }
 181
 182 int cfs_timer_is_armed(struct timer_list *l)
 183 {
 184         if (cfs_time_before(cfs_time_current(), l->expires))
 185                 return 1;
 186         else
 187                 return 0;
 188 }
 189
 190 void cfs_timer_arm(struct timer_list *l, cfs_time_t deadline)
 191 {
 192         l->expires = deadline;
 193 }
 194
 195 void cfs_timer_disarm(struct timer_list *l)
 196 {
 197 }
 198 cfs_time_t cfs_timer_deadline(struct timer_list *l)
 199 {
 200         return l->expires;
 201 }
 202
 203
 204 #ifdef HAVE_LIBPTHREAD
 205
 206 /*
 207  * Threads
 208  */
 209
 210 struct lustre_thread_arg {
 211         cfs_thread_t f;
 212         void *arg;
 213 };
 214 static void *cfs_thread_helper(void *data)
 215 {
 216         struct lustre_thread_arg *targ = data;
 217         cfs_thread_t f  = targ->f;
 218         void *arg = targ->arg;
 219
 220         free(targ);
 221
 222         (void)f(arg);
 223         return NULL;
 224 }
 225
 226 void *kthread_run(cfs_thread_t func, void *arg, const char namefmt[], ...)
 227 {
 228         pthread_t tid;
 229         pthread_attr_t tattr;
 230         int rc;
 231         struct lustre_thread_arg *targ_p =
 232                                 malloc(sizeof(struct lustre_thread_arg));
 233
 234         if (targ_p == NULL)
 235                 return ERR_PTR(-ENOMEM);
 236
 237         targ_p->f = func;
 238         targ_p->arg = arg;
 239
 240         pthread_attr_init(&tattr);
 241         pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
 242         rc = pthread_create(&tid, &tattr, cfs_thread_helper, targ_p);
 243         pthread_attr_destroy(&tattr);
 244         return ERR_PTR(rc);
 245 }
 246 #endif
 247
 248 struct user_namespace init_user_ns __read_mostly;
 249 EXPORT_SYMBOL(init_user_ns);
 250
 251 uid_t current_uid(void)
 252 {
 253         return getuid();
 254 }
 255
 256 gid_t current_gid(void)
 257 {
 258         return getgid();
 259 }
 260
 261 uid_t current_fsuid(void)
 262 {
 263         return getuid();
 264 }
 265
 266 gid_t current_fsgid(void)
 267 {
 268         return getgid();
 269 }
 270
 271 /* Read the environment variable of current process specified by @key. */
 272 int cfs_get_environ(const char *key, char *value, int *val_len)
 273 {
 274         char *entry;
 275         int len;
 276
 277         entry = getenv(key);
 278         if (entry == NULL)
 279                 return -ENOENT;
 280
 281         len = strlcpy(value, entry, *val_len);
 282         if (len >= *val_len)
 283                 return -EOVERFLOW;
 284
 285         return 0;
 286 }
 287
 288 void cfs_enter_debugger(void)
 289 {
 290         /*
 291          * nothing for now.
 292          */
 293 }
 294
 295 int unshare_fs_struct()
 296 {
 297         return 0;
 298 }
 299
 300 sigset_t cfs_block_allsigs(void)
 301 {
 302         sigset_t   all;
 303         sigset_t   old;
 304         int            rc;
 305
 306         sigfillset(&all);
 307         rc = sigprocmask(SIG_BLOCK, &all, &old);
 308         LASSERT(rc == 0);
 309
 310         return old;
 311 }
 312
 313 sigset_t cfs_block_sigs(unsigned long sigs)
 314 {
 315         sigset_t   old;
 316         sigset_t   blocks = { { sigs } }; /* kludge */
 317         int   rc;
 318
 319         rc = sigprocmask(SIG_BLOCK, &blocks, &old);
 320         LASSERT (rc == 0);
 321
 322         return old;
 323 }
 324
 325 /* Block all signals except for the @sigs. It's only used in
 326  * Linux kernel, just a dummy here. */
 327 sigset_t cfs_block_sigsinv(unsigned long sigs)
 328 {
 329         sigset_t old;
 330         int rc;
 331
 332         /* Return old blocked sigs */
 333         rc = sigprocmask(SIG_SETMASK, NULL, &old);
 334         LASSERT(rc == 0);
 335
 336         return old;
 337 }
 338
 339 void cfs_restore_sigs(sigset_t old)
 340 {
 341         int   rc = sigprocmask(SIG_SETMASK, &old, NULL);
 342
 343         LASSERT (rc == 0);
 344 }
 345
 346 int cfs_signal_pending(void)
 347 {
 348         sigset_t    empty;
 349         sigset_t    set;
 350         int  rc;
 351
 352         rc = sigpending(&set);
 353         LASSERT (rc == 0);
 354
 355         sigemptyset(&empty);
 356
 357         return !memcmp(&empty, &set, sizeof(set));
 358 }
 359
 360 void cfs_clear_sigpending(void)
 361 {
 362         return;
 363 }
 364
 365
 366 /*
 367  * In glibc (NOT in Linux, so check above is not right), implement
 368  * stack-back-tracing through backtrace() function.
 369  */
 370 #include <execinfo.h>
 371
 372 void cfs_stack_trace_fill(struct cfs_stack_trace *trace)
 373 {
 374         backtrace(trace->frame, ARRAY_SIZE(trace->frame));
 375 }
 376
 377 void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no)
 378 {
 379         if (0 <= frame_no && frame_no < ARRAY_SIZE(trace->frame))
 380                 return trace->frame[frame_no];
 381         else
 382                 return NULL;
 383 }
 384
 385
 386 void lbug_with_loc(struct libcfs_debug_msg_data *msgdata)
 387 {
 388         /* No libcfs_catastrophe in userspace! */
 389         libcfs_debug_msg(msgdata, "LBUG\n");
 390         abort();
 391 }
 392
 393 /* !__KERNEL__ */
 394 #endif
 395
 396 /*
 397  * Local variables:
 398  * c-indentation-style: "K&R"
 399  * c-basic-offset: 8
 400  * tab-width: 8
 401  * fill-column: 80
 402  * scroll-step: 1
 403  * End:
 404  */