X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Fdarwin%2Fdarwin-prim.c;h=d9b95ff9bac8deef6be1cbf615d0b5a24b31503d;hb=refs%2Fchanges%2F56%2F6956%2F8;hp=536600018dba0f2d0f6cdb3e768010abbac61306;hpb=a5801799dc46b237186284d70a67f9e91dac4bc9;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/darwin/darwin-prim.c b/libcfs/libcfs/darwin/darwin-prim.c index 5366000..d9b95ff 100644 --- a/libcfs/libcfs/darwin/darwin-prim.c +++ b/libcfs/libcfs/darwin/darwin-prim.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -28,6 +26,8 @@ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -60,7 +60,7 @@ */ #define KLNET_MAJOR -1 -kern_return_t cfs_psdev_register(cfs_psdev_t *dev) { +kern_return_t misc_register(struct miscdevice *dev) { dev->index = cdevsw_add(KLNET_MAJOR, dev->devsw); if (dev->index < 0) { printf("libcfs_init: failed to allocate a major number!\n"); @@ -72,7 +72,7 @@ kern_return_t cfs_psdev_register(cfs_psdev_t *dev) { return KERN_SUCCESS; } -kern_return_t cfs_psdev_deregister(cfs_psdev_t *dev) { +kern_return_t misc_deregister(struct miscdevice *dev) { devfs_remove(dev->handle); cdevsw_remove(dev->index, dev->devsw); return KERN_SUCCESS; @@ -235,7 +235,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while(1); \ /* @@ -257,7 +257,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while(1) /* @@ -276,7 +276,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while (1); \ /* @@ -333,24 +333,29 @@ cfs_thread_agent (void) extern thread_t kernel_thread(task_t task, void (*start)(void)); -int -cfs_kernel_thread(cfs_thread_t func, void *arg, int flag) -{ - int ret = 0; - thread_t th = NULL; - - thread_arg_hold(&cfs_thread_arg, func, arg); - th = kernel_thread(kernel_task, cfs_thread_agent); - thread_arg_release(&cfs_thread_arg); - if (th == THREAD_NULL) +struct task_struct +kthread_run(cfs_thread_t func, void *arg, const char namefmt[], ...) +{ + int ret = 0; + thread_t th = NULL; + + thread_arg_hold(&cfs_thread_arg, func, arg); + th = kernel_thread(kernel_task, cfs_thread_agent); + thread_arg_release(&cfs_thread_arg); + if (th != THREAD_NULL) { + /* + * FIXME: change child thread name... + * current_comm() is already broken. So it is left as is... + va_list args; + va_start(args, namefmt); + snprintf(current_comm(), CFS_CURPROC_COMM_MAX, + namefmt, args); + va_end(args); + */ + } else { ret = -1; - return ret; -} - -void cfs_daemonize(char *str) -{ - snprintf(cfs_curproc_comm(), CFS_CURPROC_COMM_MAX, "%s", str); - return; + } + return (struct task_struct)((long)ret); } /* @@ -359,33 +364,41 @@ void cfs_daemonize(char *str) * without patching kernel. * Should we provide these functions in xnu? * - * These signal functions almost do nothing now, we + * These signal functions almost do nothing now, we * need to investigate more about signal in Darwin. */ extern int block_procsigmask(struct proc *p, int bit); -cfs_sigset_t cfs_block_allsigs() +sigset_t cfs_block_allsigs() { - cfs_sigset_t old = 0; + sigset_t old = 0; #ifdef __DARWIN8__ #else - block_procsigmask(current_proc(), -1); + block_procsigmask(current_proc(), -1); #endif - return old; + return old; } -cfs_sigset_t cfs_block_sigs(sigset_t bit) +sigset_t cfs_block_sigs(unsigned long sigs) { - cfs_sigset_t old = 0; + sigset_t old = 0; #ifdef __DARWIN8__ #else - block_procsigmask(current_proc(), bit); + block_procsigmask(current_proc(), sigs); #endif - return old; + return old; } -void cfs_restore_sigs(cfs_sigset_t old) +/* Block all signals except for the @sigs. It's only used in + * Linux kernel, just a dummy here. */ +sigset_t cfs_block_sigsinv(unsigned long sigs) +{ + sigset_t old = 0; + return old; +} + +void cfs_restore_sigs(sigset_t old) { } @@ -393,10 +406,10 @@ int cfs_signal_pending(void) { #ifdef __DARWIN8__ - extern int thread_issignal(proc_t, thread_t, sigset_t); - return thread_issignal(current_proc(), current_thread(), (sigset_t)-1); + extern int thread_issignal(proc_t, thread_t, sigset_t); + return thread_issignal(current_proc(), current_thread(), (sigset_t)-1); #else - return SHOULDissignal(current_proc(), current_uthread()) + return SHOULDissignal(current_proc(), current_uthread()) #endif } @@ -404,7 +417,7 @@ void cfs_clear_sigpending(void) { #ifdef __DARWIN8__ #else - clear_procsiglist(current_proc(), -1); + clear_procsiglist(current_proc(), -1); #endif } @@ -414,75 +427,75 @@ void cfs_clear_sigpending(void) void lustre_cone_in(boolean_t *state, funnel_t **cone) { - *cone = thread_funnel_get(); - if (*cone == network_flock) - thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL); - else if (*cone == NULL) - *state = thread_funnel_set(kernel_flock, TRUE); + *cone = thread_funnel_get(); + if (*cone == network_flock) + thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL); + else if (*cone == NULL) + *state = thread_funnel_set(kernel_flock, TRUE); } void lustre_cone_ex(boolean_t state, funnel_t *cone) { - if (cone == network_flock) - thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL); - else if (cone == NULL) - (void) thread_funnel_set(kernel_flock, state); + if (cone == network_flock) + thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL); + else if (cone == NULL) + (void) thread_funnel_set(kernel_flock, state); } void lustre_net_in(boolean_t *state, funnel_t **cone) { - *cone = thread_funnel_get(); - if (*cone == kernel_flock) - thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL); - else if (*cone == NULL) - *state = thread_funnel_set(network_flock, TRUE); + *cone = thread_funnel_get(); + if (*cone == kernel_flock) + thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL); + else if (*cone == NULL) + *state = thread_funnel_set(network_flock, TRUE); } void lustre_net_ex(boolean_t state, funnel_t *cone) { - if (cone == kernel_flock) - thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL); - else if (cone == NULL) - (void) thread_funnel_set(network_flock, state); + if (cone == kernel_flock) + thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL); + else if (cone == NULL) + (void) thread_funnel_set(network_flock, state); } #endif /* !__DARWIN8__ */ -void cfs_waitq_init(struct cfs_waitq *waitq) +void init_waitqueue_head(struct cfs_waitq *waitq) { ksleep_chan_init(&waitq->wq_ksleep_chan); } -void cfs_waitlink_init(struct cfs_waitlink *link) +void init_waitqueue_entry_current(struct cfs_waitlink *link) { ksleep_link_init(&link->wl_ksleep_link); } -void cfs_waitq_add(struct cfs_waitq *waitq, struct cfs_waitlink *link) +void add_wait_queue(struct cfs_waitq *waitq, struct cfs_waitlink *link) { - link->wl_waitq = waitq; + link->wl_waitq = waitq; ksleep_add(&waitq->wq_ksleep_chan, &link->wl_ksleep_link); } -void cfs_waitq_add_exclusive(struct cfs_waitq *waitq, - struct cfs_waitlink *link) +void add_wait_queue_exclusive(struct cfs_waitq *waitq, + struct cfs_waitlink *link) { - link->wl_waitq = waitq; + link->wl_waitq = waitq; link->wl_ksleep_link.flags |= KSLEEP_EXCLUSIVE; ksleep_add(&waitq->wq_ksleep_chan, &link->wl_ksleep_link); } -void cfs_waitq_del(struct cfs_waitq *waitq, - struct cfs_waitlink *link) +void remove_wait_queue(struct cfs_waitq *waitq, + struct cfs_waitlink *link) { ksleep_del(&waitq->wq_ksleep_chan, &link->wl_ksleep_link); } -int cfs_waitq_active(struct cfs_waitq *waitq) +int waitqueue_active(struct cfs_waitq *waitq) { return (1); } -void cfs_waitq_signal(struct cfs_waitq *waitq) +void wake_up(struct cfs_waitq *waitq) { /* * XXX nikita: do NOT call libcfs_debug_msg() (CDEBUG/ENTRY/EXIT) @@ -491,99 +504,99 @@ void cfs_waitq_signal(struct cfs_waitq *waitq) ksleep_wake(&waitq->wq_ksleep_chan); } -void cfs_waitq_signal_nr(struct cfs_waitq *waitq, int nr) +void wake_up_nr(struct cfs_waitq *waitq, int nr) { ksleep_wake_nr(&waitq->wq_ksleep_chan, nr); } -void cfs_waitq_broadcast(struct cfs_waitq *waitq) +void wake_up_all(struct cfs_waitq *waitq) { ksleep_wake_all(&waitq->wq_ksleep_chan); } -void cfs_waitq_wait(struct cfs_waitlink *link, cfs_task_state_t state) +void waitq_wait(struct cfs_waitlink *link, long state) { - ksleep_wait(&link->wl_waitq->wq_ksleep_chan, state); + ksleep_wait(&link->wl_waitq->wq_ksleep_chan, state); } -cfs_duration_t cfs_waitq_timedwait(struct cfs_waitlink *link, - cfs_task_state_t state, - cfs_duration_t timeout) +cfs_duration_t waitq_timedwait(struct cfs_waitlink *link, + long state, + cfs_duration_t timeout) { - return ksleep_timedwait(&link->wl_waitq->wq_ksleep_chan, - state, timeout); + return ksleep_timedwait(&link->wl_waitq->wq_ksleep_chan, + state, timeout); } typedef void (*ktimer_func_t)(void *); -void cfs_timer_init(cfs_timer_t *t, void (* func)(unsigned long), void *arg) +void cfs_timer_init(struct timer_list *t, void (* func)(unsigned long), void *arg) { - ktimer_init(&t->t, (ktimer_func_t)func, arg); + ktimer_init(&t->t, (ktimer_func_t)func, arg); } void cfs_timer_done(struct cfs_timer *t) { - ktimer_done(&t->t); + ktimer_done(&t->t); } void cfs_timer_arm(struct cfs_timer *t, cfs_time_t deadline) { - ktimer_arm(&t->t, deadline); + ktimer_arm(&t->t, deadline); } void cfs_timer_disarm(struct cfs_timer *t) { - ktimer_disarm(&t->t); + ktimer_disarm(&t->t); } int cfs_timer_is_armed(struct cfs_timer *t) { - return ktimer_is_armed(&t->t); + return ktimer_is_armed(&t->t); } cfs_time_t cfs_timer_deadline(struct cfs_timer *t) { - return ktimer_deadline(&t->t); + return ktimer_deadline(&t->t); } void cfs_enter_debugger(void) { #ifdef __DARWIN8__ - extern void Debugger(const char * reason); - Debugger("CFS"); + extern void Debugger(const char * reason); + Debugger("CFS"); #else - extern void PE_enter_debugger(char *cause); - PE_enter_debugger("CFS"); + extern void PE_enter_debugger(char *cause); + PE_enter_debugger("CFS"); #endif } int cfs_online_cpus(void) { - int activecpu; - size_t size; + int activecpu; + size_t size; -#ifdef __DARWIN8__ - size = sizeof(int); - sysctlbyname("hw.activecpu", &activecpu, &size, NULL, 0); - return activecpu; +#ifdef __DARWIN8__ + size = sizeof(int); + sysctlbyname("hw.activecpu", &activecpu, &size, NULL, 0); + return activecpu; #else - host_basic_info_data_t hinfo; - kern_return_t kret; - int count = HOST_BASIC_INFO_COUNT; + host_basic_info_data_t hinfo; + kern_return_t kret; + int count = HOST_BASIC_INFO_COUNT; #define BSD_HOST 1 - kret = host_info(BSD_HOST, HOST_BASIC_INFO, &hinfo, &count); - if (kret == KERN_SUCCESS) - return (hinfo.avail_cpus); - return(-EINVAL); + kret = host_info(BSD_HOST, HOST_BASIC_INFO, &hinfo, &count); + if (kret == KERN_SUCCESS) + return (hinfo.avail_cpus); + return(-EINVAL); #endif } int cfs_ncpus(void) { - int ncpu; - size_t size; + int ncpu; + size_t size; - size = sizeof(int); + size = sizeof(int); - sysctlbyname("hw.ncpu", &ncpu, &size, NULL, 0); - return ncpu; + sysctlbyname("hw.ncpu", &ncpu, &size, NULL, 0); + return ncpu; }