Whamcloud - gitweb
LU-1346 libcfs: replace libcfs wrappers with kernel API
[fs/lustre-release.git] / 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, Whamcloud, Inc.
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  */