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 #ifndef HAVE_STRLCPY /* not in glibc for RHEL 5.x, remove when obsolete */
 272 size_t strlcpy(char *tgt, const char *src, size_t tgt_len)
 273 {
 274         int src_len = strlen(src);
 275
 276         strncpy(tgt, src, tgt_len - 1);
 277         tgt[tgt_len - 1] = '\0';
 278
 279         return src_len + 1;
 280 }
 281 #endif
 282
 283 #ifndef HAVE_STRLCAT /* not in glibc for RHEL 5.x, remove when obsolete */
 284 size_t strlcat(char *tgt, const char *src, size_t size)
 285 {
 286         size_t tgt_len = strlen(tgt);
 287
 288         if (size > tgt_len) {
 289                 strncat(tgt, src, size - tgt_len - 1);
 290                 tgt[size - 1] = '\0';
 291         }
 292
 293         return tgt_len + strlen(src);
 294 }
 295 #endif
 296
 297 /* Read the environment variable of current process specified by @key. */
 298 int cfs_get_environ(const char *key, char *value, int *val_len)
 299 {
 300         char *entry;
 301         int len;
 302
 303         entry = getenv(key);
 304         if (entry == NULL)
 305                 return -ENOENT;
 306
 307         len = strlcpy(value, entry, *val_len);
 308         if (len >= *val_len)
 309                 return -EOVERFLOW;
 310
 311         return 0;
 312 }
 313
 314 void cfs_enter_debugger(void)
 315 {
 316         /*
 317          * nothing for now.
 318          */
 319 }
 320
 321 int unshare_fs_struct()
 322 {
 323         return 0;
 324 }
 325
 326 sigset_t cfs_block_allsigs(void)
 327 {
 328         sigset_t   all;
 329         sigset_t   old;
 330         int            rc;
 331
 332         sigfillset(&all);
 333         rc = sigprocmask(SIG_BLOCK, &all, &old);
 334         LASSERT(rc == 0);
 335
 336         return old;
 337 }
 338
 339 sigset_t cfs_block_sigs(unsigned long sigs)
 340 {
 341         sigset_t   old;
 342         sigset_t   blocks = { { sigs } }; /* kludge */
 343         int   rc;
 344
 345         rc = sigprocmask(SIG_BLOCK, &blocks, &old);
 346         LASSERT (rc == 0);
 347
 348         return old;
 349 }
 350
 351 /* Block all signals except for the @sigs. It's only used in
 352  * Linux kernel, just a dummy here. */
 353 sigset_t cfs_block_sigsinv(unsigned long sigs)
 354 {
 355         sigset_t old;
 356         int rc;
 357
 358         /* Return old blocked sigs */
 359         rc = sigprocmask(SIG_SETMASK, NULL, &old);
 360         LASSERT(rc == 0);
 361
 362         return old;
 363 }
 364
 365 void cfs_restore_sigs(sigset_t old)
 366 {
 367         int   rc = sigprocmask(SIG_SETMASK, &old, NULL);
 368
 369         LASSERT (rc == 0);
 370 }
 371
 372 int cfs_signal_pending(void)
 373 {
 374         sigset_t    empty;
 375         sigset_t    set;
 376         int  rc;
 377
 378         rc = sigpending(&set);
 379         LASSERT (rc == 0);
 380
 381         sigemptyset(&empty);
 382
 383         return !memcmp(&empty, &set, sizeof(set));
 384 }
 385
 386 void cfs_clear_sigpending(void)
 387 {
 388         return;
 389 }
 390
 391 #ifdef __linux__
 392
 393 /*
 394  * In glibc (NOT in Linux, so check above is not right), implement
 395  * stack-back-tracing through backtrace() function.
 396  */
 397 #include <execinfo.h>
 398
 399 void cfs_stack_trace_fill(struct cfs_stack_trace *trace)
 400 {
 401         backtrace(trace->frame, ARRAY_SIZE(trace->frame));
 402 }
 403
 404 void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no)
 405 {
 406         if (0 <= frame_no && frame_no < ARRAY_SIZE(trace->frame))
 407                 return trace->frame[frame_no];
 408         else
 409                 return NULL;
 410 }
 411
 412 #else
 413
 414 void cfs_stack_trace_fill(struct cfs_stack_trace *trace)
 415 {}
 416 void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no)
 417 {
 418         return NULL;
 419 }
 420
 421 /* __linux__ */
 422 #endif
 423
 424 void lbug_with_loc(struct libcfs_debug_msg_data *msgdata)
 425 {
 426         /* No libcfs_catastrophe in userspace! */
 427         libcfs_debug_msg(msgdata, "LBUG\n");
 428         abort();
 429 }
 430
 431 /* !__KERNEL__ */
 432 #endif
 433
 434 /*
 435  * Local variables:
 436  * c-indentation-style: "K&R"
 437  * c-basic-offset: 8
 438  * tab-width: 8
 439  * fill-column: 80
 440  * scroll-step: 1
 441  * End:
 442  */