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 cfs_waitq_init(struct cfs_waitq *waitq)
  57 {
  58         LASSERT(waitq != NULL);
  59         (void)waitq;
  60 }
  61
  62 void cfs_waitlink_init(struct cfs_waitlink *link)
  63 {
  64         LASSERT(link != NULL);
  65         (void)link;
  66 }
  67
  68 void cfs_waitq_add(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 cfs_waitq_add_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 cfs_waitq_add_exclusive_head(struct cfs_waitq *waitq, struct cfs_waitlink *link)
  85 {
  86         cfs_waitq_add_exclusive(waitq, link);
  87 }
  88
  89 void cfs_waitq_del(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 cfs_waitq_active(struct cfs_waitq *waitq)
  98 {
  99         LASSERT(waitq != NULL);
 100         (void)waitq;
 101         return 0;
 102 }
 103
 104 void cfs_waitq_signal(struct cfs_waitq *waitq)
 105 {
 106         LASSERT(waitq != NULL);
 107         (void)waitq;
 108 }
 109
 110 void cfs_waitq_signal_nr(struct cfs_waitq *waitq, int nr)
 111 {
 112         LASSERT(waitq != NULL);
 113         (void)waitq;
 114 }
 115
 116 void cfs_waitq_broadcast(struct cfs_waitq *waitq)
 117 {
 118         LASSERT(waitq != NULL);
 119         (void)waitq;
 120 }
 121
 122 void cfs_waitq_wait(struct cfs_waitlink *link, cfs_task_state_t 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 cfs_waitq_timedwait(struct cfs_waitlink *link, cfs_task_state_t 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 cfs_schedule_timeout_and_set_state(cfs_task_state_t state, int64_t timeout)
 141 {
 142         cfs_waitlink_t    l;
 143         /* sleep(timeout) here instead? */
 144         cfs_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 cfs_need_resched(void)
 157 {
 158         return 0;
 159 }
 160
 161 void cfs_cond_resched(void)
 162 {
 163 }
 164
 165 /*
 166  * Timer
 167  */
 168
 169 void cfs_init_timer(cfs_timer_t *t)
 170 {
 171         CFS_INIT_LIST_HEAD(&t->tl_list);
 172 }
 173
 174 void cfs_timer_init(cfs_timer_t *l, cfs_timer_func_t *func, void *arg)
 175 {
 176         CFS_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(cfs_timer_t *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(cfs_timer_t *l, cfs_time_t deadline)
 191 {
 192         l->expires = deadline;
 193 }
 194
 195 void cfs_timer_disarm(cfs_timer_t *l)
 196 {
 197 }
 198 cfs_time_t cfs_timer_deadline(cfs_timer_t *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 int cfs_create_thread(cfs_thread_t func, void *arg, unsigned long flags)
 227 {
 228         pthread_t tid;
 229         pthread_attr_t tattr;
 230         int rc;
 231         struct lustre_thread_arg *targ_p = malloc(sizeof(struct lustre_thread_arg));
 232
 233         if ( targ_p == NULL )
 234                 return -ENOMEM;
 235
 236         targ_p->f = func;
 237         targ_p->arg = arg;
 238
 239         pthread_attr_init(&tattr);
 240         pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
 241         rc = pthread_create(&tid, &tattr, cfs_thread_helper, targ_p);
 242         pthread_attr_destroy(&tattr);
 243         return -rc;
 244 }
 245 #endif
 246
 247 uid_t cfs_curproc_uid(void)
 248 {
 249         return getuid();
 250 }
 251
 252 gid_t cfs_curproc_gid(void)
 253 {
 254         return getgid();
 255 }
 256
 257 uid_t cfs_curproc_fsuid(void)
 258 {
 259         return getuid();
 260 }
 261
 262 gid_t cfs_curproc_fsgid(void)
 263 {
 264         return getgid();
 265 }
 266
 267 #ifndef HAVE_STRLCPY /* not in glibc for RHEL 5.x, remove when obsolete */
 268 size_t strlcpy(char *tgt, const char *src, size_t tgt_len)
 269 {
 270         int src_len = strlen(src);
 271
 272         strncpy(tgt, src, tgt_len - 1);
 273         tgt[tgt_len - 1] = '\0';
 274
 275         return src_len + 1;
 276 }
 277 #endif
 278
 279 #ifndef HAVE_STRLCAT /* not in glibc for RHEL 5.x, remove when obsolete */
 280 size_t strlcat(char *tgt, const char *src, size_t size)
 281 {
 282         size_t tgt_len = strlen(tgt);
 283
 284         if (size > tgt_len) {
 285                 strncat(tgt, src, size - tgt_len - 1);
 286                 tgt[size - 1] = '\0';
 287         }
 288
 289         return tgt_len + strlen(src);
 290 }
 291 #endif
 292
 293 /* Read the environment variable of current process specified by @key. */
 294 int cfs_get_environ(const char *key, char *value, int *val_len)
 295 {
 296         char *entry;
 297         int len;
 298
 299         entry = getenv(key);
 300         if (entry == NULL)
 301                 return -ENOENT;
 302
 303         len = strlcpy(value, entry, *val_len);
 304         if (len >= *val_len)
 305                 return -EOVERFLOW;
 306
 307         return 0;
 308 }
 309
 310 void cfs_enter_debugger(void)
 311 {
 312         /*
 313          * nothing for now.
 314          */
 315 }
 316
 317 void cfs_daemonize(char *str)
 318 {
 319         return;
 320 }
 321
 322 int cfs_daemonize_ctxt(char *str)
 323 {
 324         return 0;
 325 }
 326
 327 cfs_sigset_t cfs_block_allsigs(void)
 328 {
 329         cfs_sigset_t   all;
 330         cfs_sigset_t   old;
 331         int            rc;
 332
 333         sigfillset(&all);
 334         rc = sigprocmask(SIG_BLOCK, &all, &old);
 335         LASSERT(rc == 0);
 336
 337         return old;
 338 }
 339
 340 cfs_sigset_t cfs_block_sigs(unsigned long sigs)
 341 {
 342         cfs_sigset_t   old;
 343         cfs_sigset_t   blocks = { { sigs } }; /* kludge */
 344         int   rc;
 345
 346         rc = sigprocmask(SIG_BLOCK, &blocks, &old);
 347         LASSERT (rc == 0);
 348
 349         return old;
 350 }
 351
 352 /* Block all signals except for the @sigs. It's only used in
 353  * Linux kernel, just a dummy here. */
 354 cfs_sigset_t cfs_block_sigsinv(unsigned long sigs)
 355 {
 356         cfs_sigset_t old;
 357         int rc;
 358
 359         /* Return old blocked sigs */
 360         rc = sigprocmask(SIG_SETMASK, NULL, &old);
 361         LASSERT(rc == 0);
 362
 363         return old;
 364 }
 365
 366 void cfs_restore_sigs(cfs_sigset_t old)
 367 {
 368         int   rc = sigprocmask(SIG_SETMASK, &old, NULL);
 369
 370         LASSERT (rc == 0);
 371 }
 372
 373 int cfs_signal_pending(void)
 374 {
 375         cfs_sigset_t    empty;
 376         cfs_sigset_t    set;
 377         int  rc;
 378
 379         rc = sigpending(&set);
 380         LASSERT (rc == 0);
 381
 382         sigemptyset(&empty);
 383
 384         return !memcmp(&empty, &set, sizeof(set));
 385 }
 386
 387 void cfs_clear_sigpending(void)
 388 {
 389         return;
 390 }
 391
 392 #ifdef __linux__
 393
 394 /*
 395  * In glibc (NOT in Linux, so check above is not right), implement
 396  * stack-back-tracing through backtrace() function.
 397  */
 398 #include <execinfo.h>
 399
 400 void cfs_stack_trace_fill(struct cfs_stack_trace *trace)
 401 {
 402         backtrace(trace->frame, ARRAY_SIZE(trace->frame));
 403 }
 404
 405 void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no)
 406 {
 407         if (0 <= frame_no && frame_no < ARRAY_SIZE(trace->frame))
 408                 return trace->frame[frame_no];
 409         else
 410                 return NULL;
 411 }
 412
 413 #else
 414
 415 void cfs_stack_trace_fill(struct cfs_stack_trace *trace)
 416 {}
 417 void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no)
 418 {
 419         return NULL;
 420 }
 421
 422 /* __linux__ */
 423 #endif
 424
 425 void lbug_with_loc(struct libcfs_debug_msg_data *msgdata)
 426 {
 427         /* No libcfs_catastrophe in userspace! */
 428         libcfs_debug_msg(msgdata, "LBUG\n");
 429         abort();
 430 }
 431
 432 /* !__KERNEL__ */
 433 #endif
 434
 435 /*
 436  * Local variables:
 437  * c-indentation-style: "K&R"
 438  * c-basic-offset: 8
 439  * tab-width: 8
 440  * fill-column: 80
 441  * scroll-step: 1
 442  * End:
 443  */