-/* -*- 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.
* 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/
*/
#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");
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;
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
break; \
} \
spin_unlock(&(pta)->lock); \
- cfs_schedule(); \
+ schedule(); \
} while(1); \
/*
break; \
} \
spin_unlock(&(pta)->lock); \
- cfs_schedule(); \
+ schedule(); \
} while(1)
/*
break; \
} \
spin_unlock(&(pta)->lock); \
- cfs_schedule(); \
+ schedule(); \
} while (1); \
/*
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);
}
/*
* 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)
{
}
{
#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
}
{
#ifdef __DARWIN8__
#else
- clear_procsiglist(current_proc(), -1);
+ clear_procsiglist(current_proc(), -1);
#endif
}
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)
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;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff