X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Flibcfs%2Fdarwin%2Fdarwin-prim.c;h=22ff5a9c5618d4c74bbf5dc14cd2c68e0d042ce3;hp=366a1ff8ac8f91f19060346bf282a4e352a8ca70;hb=92c51841c50cc4061c20b277d3f7c4468f2a80cc;hpb=6869932b552ac705f411de3362f01bd50c1f6f7d diff --git a/libcfs/libcfs/darwin/darwin-prim.c b/libcfs/libcfs/darwin/darwin-prim.c index 366a1ff..22ff5a9 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. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * 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; @@ -132,74 +132,72 @@ cfs_symbol_register(const char *name, const void *value) struct cfs_symbol *sym = NULL; struct cfs_symbol *new = NULL; - MALLOC(new, struct cfs_symbol *, sizeof(struct cfs_symbol), M_TEMP, M_WAITOK|M_ZERO); - strncpy(new->name, name, CFS_SYMBOL_LEN); - new->value = (void *)value; - new->ref = 0; - CFS_INIT_LIST_HEAD(&new->sym_list); - - down_write(&cfs_symbol_lock); - list_for_each(walker, &cfs_symbol_list) { - sym = list_entry (walker, struct cfs_symbol, sym_list); - if (!strcmp(sym->name, name)) { - up_write(&cfs_symbol_lock); - FREE(new, M_TEMP); - return KERN_NAME_EXISTS; - } - - } - list_add_tail(&new->sym_list, &cfs_symbol_list); - up_write(&cfs_symbol_lock); - - return KERN_SUCCESS; + MALLOC(new, struct cfs_symbol *, sizeof(struct cfs_symbol), M_TEMP, M_WAITOK|M_ZERO); + strncpy(new->name, name, CFS_SYMBOL_LEN); + new->value = (void *)value; + new->ref = 0; + INIT_LIST_HEAD(&new->sym_list); + + down_write(&cfs_symbol_lock); + list_for_each(walker, &cfs_symbol_list) { + sym = list_entry (walker, struct cfs_symbol, sym_list); + if (!strcmp(sym->name, name)) { + up_write(&cfs_symbol_lock); + FREE(new, M_TEMP); + return KERN_NAME_EXISTS; + } + } + list_add_tail(&new->sym_list, &cfs_symbol_list); + up_write(&cfs_symbol_lock); + return KERN_SUCCESS; } kern_return_t cfs_symbol_unregister(const char *name) { - struct list_head *walker; - struct list_head *nxt; - struct cfs_symbol *sym = NULL; - - down_write(&cfs_symbol_lock); - list_for_each_safe(walker, nxt, &cfs_symbol_list) { - sym = list_entry (walker, struct cfs_symbol, sym_list); - if (!strcmp(sym->name, name)) { - LASSERT(sym->ref == 0); - list_del (&sym->sym_list); - FREE(sym, M_TEMP); - break; - } - } - up_write(&cfs_symbol_lock); + struct list_head *walker; + struct list_head *nxt; + struct cfs_symbol *sym = NULL; + + down_write(&cfs_symbol_lock); + list_for_each_safe(walker, nxt, &cfs_symbol_list) { + sym = list_entry(walker, struct cfs_symbol, sym_list); + if (!strcmp(sym->name, name)) { + LASSERT(sym->ref == 0); + list_del(&sym->sym_list); + FREE(sym, M_TEMP); + break; + } + } + up_write(&cfs_symbol_lock); - return KERN_SUCCESS; + return KERN_SUCCESS; } void cfs_symbol_init() { - CFS_INIT_LIST_HEAD(&cfs_symbol_list); - init_rwsem(&cfs_symbol_lock); + INIT_LIST_HEAD(&cfs_symbol_list); + init_rwsem(&cfs_symbol_lock); } void cfs_symbol_fini() { - struct list_head *walker; - struct cfs_symbol *sym = NULL; + struct list_head *walker; + struct cfs_symbol *sym = NULL; - down_write(&cfs_symbol_lock); - list_for_each(walker, &cfs_symbol_list) { - sym = list_entry (walker, struct cfs_symbol, sym_list); - LASSERT(sym->ref == 0); - list_del (&sym->sym_list); - FREE(sym, M_TEMP); - } - up_write(&cfs_symbol_lock); + down_write(&cfs_symbol_lock); + list_for_each(walker, &cfs_symbol_list) { + sym = list_entry(walker, struct cfs_symbol, sym_list); + LASSERT(sym->ref == 0); + list_del(&sym->sym_list); + FREE(sym, M_TEMP); + } + up_write(&cfs_symbol_lock); - fini_rwsem(&cfs_symbol_lock); - return; + fini_rwsem(&cfs_symbol_lock); + return; } struct kernel_thread_arg @@ -235,7 +233,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while(1); \ /* @@ -257,7 +255,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while(1) /* @@ -276,7 +274,7 @@ struct kernel_thread_arg cfs_thread_arg; break; \ } \ spin_unlock(&(pta)->lock); \ - cfs_schedule(); \ + schedule(); \ } while (1); \ /* @@ -333,24 +331,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,37 +362,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. */ -cfs_sigset_t cfs_get_blockedsigs() -{ - return (cfs_sigset_t)0; -} 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) { } @@ -397,10 +404,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 } @@ -408,7 +415,7 @@ void cfs_clear_sigpending(void) { #ifdef __DARWIN8__ #else - clear_procsiglist(current_proc(), -1); + clear_procsiglist(current_proc(), -1); #endif } @@ -418,75 +425,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) @@ -495,99 +502,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; }