X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Flinux%2Flinux-prim.c;h=4d10dcb89bd3e8c502ed3d2b8383793450e73922;hb=refs%2Fchanges%2F66%2F22866%2F10;hp=d8a91172c6bf03be68ac9774d53904a4695eddb4;hpb=08aa217ce49aba1ded52e0f7adb8a607035123fd;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/linux/linux-prim.c b/libcfs/libcfs/linux/linux-prim.c index d8a9117..4d10dcb 100644 --- a/libcfs/libcfs/linux/linux-prim.c +++ b/libcfs/libcfs/linux/linux-prim.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -46,277 +42,126 @@ #include #endif -#define LINUX_WAITQ(w) ((wait_queue_t *) w) -#define LINUX_WAITQ_HEAD(w) ((wait_queue_head_t *) w) - -void -cfs_waitq_init(cfs_waitq_t *waitq) -{ - init_waitqueue_head(LINUX_WAITQ_HEAD(waitq)); -} -EXPORT_SYMBOL(cfs_waitq_init); - -void -cfs_waitlink_init(cfs_waitlink_t *link) -{ - init_waitqueue_entry(LINUX_WAITQ(link), current); -} -EXPORT_SYMBOL(cfs_waitlink_init); - -void -cfs_waitq_add(cfs_waitq_t *waitq, cfs_waitlink_t *link) -{ - add_wait_queue(LINUX_WAITQ_HEAD(waitq), LINUX_WAITQ(link)); -} -EXPORT_SYMBOL(cfs_waitq_add); - -#ifndef HAVE___ADD_WAIT_QUEUE_EXCLUSIVE - -static inline void __add_wait_queue_exclusive(wait_queue_head_t *q, - wait_queue_t *wait) -{ - wait->flags |= WQ_FLAG_EXCLUSIVE; - __add_wait_queue(q, wait); -} - -#endif /* HAVE___ADD_WAIT_QUEUE_EXCLUSIVE */ - -void -cfs_waitq_add_exclusive(cfs_waitq_t *waitq, - cfs_waitlink_t *link) -{ - add_wait_queue_exclusive(LINUX_WAITQ_HEAD(waitq), LINUX_WAITQ(link)); -} -EXPORT_SYMBOL(cfs_waitq_add_exclusive); - -/** - * wait_queue_t of Linux (version < 2.6.34) is a FIFO list for exclusively - * waiting threads, which is not always desirable because all threads will - * be waken up again and again, even user only needs a few of them to be - * active most time. This is not good for performance because cache can - * be polluted by different threads. - * - * LIFO list can resolve this problem because we always wakeup the most - * recent active thread by default. - * - * NB: please don't call non-exclusive & exclusive wait on the same - * waitq if cfs_waitq_add_exclusive_head is used. - */ -void -cfs_waitq_add_exclusive_head(cfs_waitq_t *waitq, cfs_waitlink_t *link) -{ - unsigned long flags; - - spin_lock_irqsave(&LINUX_WAITQ_HEAD(waitq)->lock, flags); - __add_wait_queue_exclusive(LINUX_WAITQ_HEAD(waitq), LINUX_WAITQ(link)); - spin_unlock_irqrestore(&LINUX_WAITQ_HEAD(waitq)->lock, flags); -} -EXPORT_SYMBOL(cfs_waitq_add_exclusive_head); - -void -cfs_waitq_del(cfs_waitq_t *waitq, cfs_waitlink_t *link) -{ - remove_wait_queue(LINUX_WAITQ_HEAD(waitq), LINUX_WAITQ(link)); -} -EXPORT_SYMBOL(cfs_waitq_del); - -int -cfs_waitq_active(cfs_waitq_t *waitq) -{ - return waitqueue_active(LINUX_WAITQ_HEAD(waitq)); -} -EXPORT_SYMBOL(cfs_waitq_active); - -void -cfs_waitq_signal(cfs_waitq_t *waitq) -{ - wake_up(LINUX_WAITQ_HEAD(waitq)); -} -EXPORT_SYMBOL(cfs_waitq_signal); - -void -cfs_waitq_signal_nr(cfs_waitq_t *waitq, int nr) -{ - wake_up_nr(LINUX_WAITQ_HEAD(waitq), nr); -} -EXPORT_SYMBOL(cfs_waitq_signal_nr); - -void -cfs_waitq_broadcast(cfs_waitq_t *waitq) -{ - wake_up_all(LINUX_WAITQ_HEAD(waitq)); -} -EXPORT_SYMBOL(cfs_waitq_broadcast); - -void -cfs_waitq_wait(cfs_waitlink_t *link, cfs_task_state_t state) -{ - schedule(); -} -EXPORT_SYMBOL(cfs_waitq_wait); - -int64_t -cfs_waitq_timedwait(cfs_waitlink_t *link, cfs_task_state_t state, - int64_t timeout) -{ - return schedule_timeout(timeout); -} -EXPORT_SYMBOL(cfs_waitq_timedwait); - -void -cfs_schedule_timeout_and_set_state(cfs_task_state_t state, int64_t timeout) -{ - set_current_state(state); - schedule_timeout(timeout); -} -EXPORT_SYMBOL(cfs_schedule_timeout_and_set_state); - -void -cfs_schedule_timeout(int64_t timeout) -{ - schedule_timeout(timeout); -} -EXPORT_SYMBOL(cfs_schedule_timeout); - -void -cfs_schedule(void) -{ - schedule(); -} -EXPORT_SYMBOL(cfs_schedule); - -/* deschedule for a bit... */ -void -cfs_pause(cfs_duration_t ticks) -{ - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_timeout(ticks); -} -EXPORT_SYMBOL(cfs_pause); - -int cfs_need_resched(void) -{ - return need_resched(); -} -EXPORT_SYMBOL(cfs_need_resched); - -void cfs_cond_resched(void) +void cfs_init_timer(struct timer_list *t) { - cond_resched(); -} -EXPORT_SYMBOL(cfs_cond_resched); - -void cfs_init_timer(cfs_timer_t *t) -{ - init_timer(t); + init_timer(t); } EXPORT_SYMBOL(cfs_init_timer); -void cfs_timer_init(cfs_timer_t *t, cfs_timer_func_t *func, void *arg) +void cfs_timer_init(struct timer_list *t, cfs_timer_func_t *func, void *arg) { - init_timer(t); - t->function = func; - t->data = (unsigned long)arg; + init_timer(t); + t->function = func; + t->data = (unsigned long)arg; } EXPORT_SYMBOL(cfs_timer_init); -void cfs_timer_done(cfs_timer_t *t) -{ - return; -} -EXPORT_SYMBOL(cfs_timer_done); - -void cfs_timer_arm(cfs_timer_t *t, cfs_time_t deadline) +void cfs_timer_arm(struct timer_list *t, cfs_time_t deadline) { - mod_timer(t, deadline); + mod_timer(t, deadline); } EXPORT_SYMBOL(cfs_timer_arm); -void cfs_timer_disarm(cfs_timer_t *t) +void cfs_timer_disarm(struct timer_list *t) { - del_timer(t); + del_timer(t); } EXPORT_SYMBOL(cfs_timer_disarm); -int cfs_timer_is_armed(cfs_timer_t *t) +int cfs_timer_is_armed(struct timer_list *t) { - return timer_pending(t); + return timer_pending(t); } EXPORT_SYMBOL(cfs_timer_is_armed); -cfs_time_t cfs_timer_deadline(cfs_timer_t *t) +cfs_time_t cfs_timer_deadline(struct timer_list *t) { - return t->expires; + return t->expires; } EXPORT_SYMBOL(cfs_timer_deadline); -void cfs_enter_debugger(void) +#ifndef HAVE_KTIME_GET_TS64 +void ktime_get_ts64(struct timespec64 *ts) { -#if defined(CONFIG_KGDB) -// BREAKPOINT(); -#elif defined(__arch_um__) - asm("int $3"); -#else - /* nothing */ -#endif + struct timespec now; + + ktime_get_ts(&now); + *ts = timespec_to_timespec64(now); } +EXPORT_SYMBOL(ktime_get_ts64); +#endif /* HAVE_KTIME_GET_TS64 */ -void cfs_daemonize(char *str) { - unsigned long flags; +#ifndef HAVE_KTIME_GET_REAL_TS64 +void ktime_get_real_ts64(struct timespec64 *ts) +{ + struct timespec now; - daemonize(str); - SIGNAL_MASK_LOCK(current, flags); - sigfillset(¤t->blocked); - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); + getnstimeofday(&now); + *ts = timespec_to_timespec64(now); } +EXPORT_SYMBOL(ktime_get_real_ts64); +#endif /* HAVE_KTIME_GET_REAL_TS64 */ -int cfs_daemonize_ctxt(char *str) { +#ifndef HAVE_KTIME_GET_REAL_SECONDS +/* + * Get the seconds portion of CLOCK_REALTIME (wall clock). + * This is the clock that can be altered by NTP and is + * independent of a reboot. + */ +time64_t ktime_get_real_seconds(void) +{ + return (time64_t)get_seconds(); +} +EXPORT_SYMBOL(ktime_get_real_seconds); +#endif /* HAVE_KTIME_GET_REAL_SECONDS */ - cfs_daemonize(str); -#ifndef HAVE_UNSHARE_FS_STRUCT - { - struct task_struct *tsk = current; - struct fs_struct *fs = NULL; - fs = copy_fs_struct(tsk->fs); - if (fs == NULL) - return -ENOMEM; - exit_fs(tsk); - tsk->fs = fs; - } -#else - unshare_fs_struct(); -#endif - return 0; +#ifndef HAVE_KTIME_GET_SECONDS +/* + * Get the seconds portion of CLOCK_MONOTONIC + * This clock is immutable and is reset across + * reboots. For older platforms this is a + * wrapper around get_seconds which is valid + * until 2038. By that time this will be gone + * one would hope. + */ +time64_t ktime_get_seconds(void) +{ + struct timespec64 now; + + ktime_get_ts64(&now); + return now.tv_sec; } +EXPORT_SYMBOL(ktime_get_seconds); +#endif /* HAVE_KTIME_GET_SECONDS */ sigset_t cfs_block_allsigs(void) { - unsigned long flags; - sigset_t old; - - SIGNAL_MASK_LOCK(current, flags); - old = current->blocked; - sigfillset(¤t->blocked); - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); + unsigned long flags; + sigset_t old; - return old; + spin_lock_irqsave(¤t->sighand->siglock, flags); + old = current->blocked; + sigfillset(¤t->blocked); + recalc_sigpending(); + spin_unlock_irqrestore(¤t->sighand->siglock, flags); + return old; } +EXPORT_SYMBOL(cfs_block_allsigs); sigset_t cfs_block_sigs(unsigned long sigs) { unsigned long flags; sigset_t old; - SIGNAL_MASK_LOCK(current, flags); + spin_lock_irqsave(¤t->sighand->siglock, flags); old = current->blocked; sigaddsetmask(¤t->blocked, sigs); - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); + recalc_sigpending(); + spin_unlock_irqrestore(¤t->sighand->siglock, flags); return old; } +EXPORT_SYMBOL(cfs_block_sigs); /* Block all signals except for the @sigs */ sigset_t cfs_block_sigsinv(unsigned long sigs) @@ -324,62 +169,34 @@ sigset_t cfs_block_sigsinv(unsigned long sigs) unsigned long flags; sigset_t old; - SIGNAL_MASK_LOCK(current, flags); + spin_lock_irqsave(¤t->sighand->siglock, flags); old = current->blocked; sigaddsetmask(¤t->blocked, ~sigs); - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); - + recalc_sigpending(); + spin_unlock_irqrestore(¤t->sighand->siglock, flags); return old; } +EXPORT_SYMBOL(cfs_block_sigsinv); void -cfs_restore_sigs (cfs_sigset_t old) +cfs_restore_sigs(sigset_t old) { - unsigned long flags; - - SIGNAL_MASK_LOCK(current, flags); - current->blocked = old; - RECALC_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); -} + unsigned long flags; -int -cfs_signal_pending(void) -{ - return signal_pending(current); + spin_lock_irqsave(¤t->sighand->siglock, flags); + current->blocked = old; + recalc_sigpending(); + spin_unlock_irqrestore(¤t->sighand->siglock, flags); } +EXPORT_SYMBOL(cfs_restore_sigs); void cfs_clear_sigpending(void) { - unsigned long flags; - - SIGNAL_MASK_LOCK(current, flags); - CLEAR_SIGPENDING; - SIGNAL_MASK_UNLOCK(current, flags); -} + unsigned long flags; -int -libcfs_arch_init(void) -{ - return 0; + spin_lock_irqsave(¤t->sighand->siglock, flags); + clear_tsk_thread_flag(current, TIF_SIGPENDING); + spin_unlock_irqrestore(¤t->sighand->siglock, flags); } - -void -libcfs_arch_cleanup(void) -{ - return; -} - -EXPORT_SYMBOL(libcfs_arch_init); -EXPORT_SYMBOL(libcfs_arch_cleanup); -EXPORT_SYMBOL(cfs_enter_debugger); -EXPORT_SYMBOL(cfs_daemonize); -EXPORT_SYMBOL(cfs_daemonize_ctxt); -EXPORT_SYMBOL(cfs_block_allsigs); -EXPORT_SYMBOL(cfs_block_sigs); -EXPORT_SYMBOL(cfs_block_sigsinv); -EXPORT_SYMBOL(cfs_restore_sigs); -EXPORT_SYMBOL(cfs_signal_pending); EXPORT_SYMBOL(cfs_clear_sigpending);