From 524e6b6dc7ddafad7ba50da72a079a05ae3de77a Mon Sep 17 00:00:00 2001 From: Pierre-Marc Fournier Date: Mon, 30 Mar 2009 17:39:16 -0400 Subject: [PATCH] continue work on build system --- libmarkers/jhash.h | 145 ---------- libmarkers/rcupdate.h | 270 ------------------- {libtracing => libtracectl}/marker-control.h | 0 3 files changed, 415 deletions(-) delete mode 100644 libmarkers/jhash.h delete mode 100644 libmarkers/rcupdate.h rename {libtracing => libtracectl}/marker-control.h (100%) diff --git a/libmarkers/jhash.h b/libmarkers/jhash.h deleted file mode 100644 index 10e44828..00000000 --- a/libmarkers/jhash.h +++ /dev/null @@ -1,145 +0,0 @@ -#ifndef _LINUX_JHASH_H -#define _LINUX_JHASH_H - -/* jhash.h: Jenkins hash support. - * - * Copyright (C) 1996 Bob Jenkins (bob_jenkins@burtleburtle.net) - * - * http://burtleburtle.net/bob/hash/ - * - * These are the credits from Bob's sources: - * - * lookup2.c, by Bob Jenkins, December 1996, Public Domain. - * hash(), hash2(), hash3, and mix() are externally useful functions. - * Routines to test the hash are included if SELF_TEST is defined. - * You can use this free for any purpose. It has no warranty. - * - * Copyright (C) 2003 David S. Miller (davem@redhat.com) - * - * I've modified Bob's hash to be useful in the Linux kernel, and - * any bugs present are surely my fault. -DaveM - */ - -#include "kernelcompat.h" - -/* NOTE: Arguments are modified. */ -#define __jhash_mix(a, b, c) \ -{ \ - a -= b; a -= c; a ^= (c>>13); \ - b -= c; b -= a; b ^= (a<<8); \ - c -= a; c -= b; c ^= (b>>13); \ - a -= b; a -= c; a ^= (c>>12); \ - b -= c; b -= a; b ^= (a<<16); \ - c -= a; c -= b; c ^= (b>>5); \ - a -= b; a -= c; a ^= (c>>3); \ - b -= c; b -= a; b ^= (a<<10); \ - c -= a; c -= b; c ^= (b>>15); \ -} - -/* The golden ration: an arbitrary value */ -#define JHASH_GOLDEN_RATIO 0x9e3779b9 - -/* The most generic version, hashes an arbitrary sequence - * of bytes. No alignment or length assumptions are made about - * the input key. - */ -static inline u32 jhash(const void *key, u32 length, u32 initval) -{ - u32 a, b, c, len; - const u8 *k = key; - - len = length; - a = b = JHASH_GOLDEN_RATIO; - c = initval; - - while (len >= 12) { - a += (k[0] +((u32)k[1]<<8) +((u32)k[2]<<16) +((u32)k[3]<<24)); - b += (k[4] +((u32)k[5]<<8) +((u32)k[6]<<16) +((u32)k[7]<<24)); - c += (k[8] +((u32)k[9]<<8) +((u32)k[10]<<16)+((u32)k[11]<<24)); - - __jhash_mix(a,b,c); - - k += 12; - len -= 12; - } - - c += length; - switch (len) { - case 11: c += ((u32)k[10]<<24); - case 10: c += ((u32)k[9]<<16); - case 9 : c += ((u32)k[8]<<8); - case 8 : b += ((u32)k[7]<<24); - case 7 : b += ((u32)k[6]<<16); - case 6 : b += ((u32)k[5]<<8); - case 5 : b += k[4]; - case 4 : a += ((u32)k[3]<<24); - case 3 : a += ((u32)k[2]<<16); - case 2 : a += ((u32)k[1]<<8); - case 1 : a += k[0]; - }; - - __jhash_mix(a,b,c); - - return c; -} - -/* A special optimized version that handles 1 or more of u32s. - * The length parameter here is the number of u32s in the key. - */ -static inline u32 jhash2(const u32 *k, u32 length, u32 initval) -{ - u32 a, b, c, len; - - a = b = JHASH_GOLDEN_RATIO; - c = initval; - len = length; - - while (len >= 3) { - a += k[0]; - b += k[1]; - c += k[2]; - __jhash_mix(a, b, c); - k += 3; len -= 3; - } - - c += length * 4; - - switch (len) { - case 2 : b += k[1]; - case 1 : a += k[0]; - }; - - __jhash_mix(a,b,c); - - return c; -} - - -/* A special ultra-optimized versions that knows they are hashing exactly - * 3, 2 or 1 word(s). - * - * NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally - * done at the end is not done here. - */ -static inline u32 jhash_3words(u32 a, u32 b, u32 c, u32 initval) -{ - a += JHASH_GOLDEN_RATIO; - b += JHASH_GOLDEN_RATIO; - c += initval; - - __jhash_mix(a, b, c); - - return c; -} - -static inline u32 jhash_2words(u32 a, u32 b, u32 initval) -{ - return jhash_3words(a, b, 0, initval); -} - -static inline u32 jhash_1word(u32 a, u32 initval) -{ - return jhash_3words(a, 0, 0, initval); -} - -#endif /* _LINUX_JHASH_H */ diff --git a/libmarkers/rcupdate.h b/libmarkers/rcupdate.h deleted file mode 100644 index 87d2128e..00000000 --- a/libmarkers/rcupdate.h +++ /dev/null @@ -1,270 +0,0 @@ -/* - * Read-Copy Update mechanism for mutual exclusion - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * Copyright IBM Corporation, 2001 - * - * Author: Dipankar Sarma - * - * Based on the original work by Paul McKenney - * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen. - * Papers: - * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf - * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001) - * - * For detailed explanation of Read-Copy Update mechanism see - - * http://lse.sourceforge.net/locking/rcupdate.html - * - */ - -#ifndef __LINUX_RCUPDATE_H -#define __LINUX_RCUPDATE_H - -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include - -/** - * struct rcu_head - callback structure for use with RCU - * @next: next update requests in a list - * @func: actual update function to call after the grace period. - */ -struct rcu_head { - struct rcu_head *next; - void (*func)(struct rcu_head *head); -}; - -//ust// #if defined(CONFIG_CLASSIC_RCU) -//ust// #include -//ust// #elif defined(CONFIG_TREE_RCU) -//ust// #include -//ust// #elif defined(CONFIG_PREEMPT_RCU) -//ust// #include -//ust// #else -//ust// #error "Unknown RCU implementation specified to kernel configuration" -//ust// #endif /* #else #if defined(CONFIG_CLASSIC_RCU) */ -//ust// -//ust// #define RCU_HEAD_INIT { .next = NULL, .func = NULL } -//ust// #define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT -//ust// #define INIT_RCU_HEAD(ptr) do { \ -//ust// (ptr)->next = NULL; (ptr)->func = NULL; \ -//ust// } while (0) -//ust// -//ust// /** -//ust// * rcu_read_lock - mark the beginning of an RCU read-side critical section. -//ust// * -//ust// * When synchronize_rcu() is invoked on one CPU while other CPUs -//ust// * are within RCU read-side critical sections, then the -//ust// * synchronize_rcu() is guaranteed to block until after all the other -//ust// * CPUs exit their critical sections. Similarly, if call_rcu() is invoked -//ust// * on one CPU while other CPUs are within RCU read-side critical -//ust// * sections, invocation of the corresponding RCU callback is deferred -//ust// * until after the all the other CPUs exit their critical sections. -//ust// * -//ust// * Note, however, that RCU callbacks are permitted to run concurrently -//ust// * with RCU read-side critical sections. One way that this can happen -//ust// * is via the following sequence of events: (1) CPU 0 enters an RCU -//ust// * read-side critical section, (2) CPU 1 invokes call_rcu() to register -//ust// * an RCU callback, (3) CPU 0 exits the RCU read-side critical section, -//ust// * (4) CPU 2 enters a RCU read-side critical section, (5) the RCU -//ust// * callback is invoked. This is legal, because the RCU read-side critical -//ust// * section that was running concurrently with the call_rcu() (and which -//ust// * therefore might be referencing something that the corresponding RCU -//ust// * callback would free up) has completed before the corresponding -//ust// * RCU callback is invoked. -//ust// * -//ust// * RCU read-side critical sections may be nested. Any deferred actions -//ust// * will be deferred until the outermost RCU read-side critical section -//ust// * completes. -//ust// * -//ust// * It is illegal to block while in an RCU read-side critical section. -//ust// */ -//ust// #define rcu_read_lock() __rcu_read_lock() -//ust// -//ust// /** -//ust// * rcu_read_unlock - marks the end of an RCU read-side critical section. -//ust// * -//ust// * See rcu_read_lock() for more information. -//ust// */ -//ust// -//ust// /* -//ust// * So where is rcu_write_lock()? It does not exist, as there is no -//ust// * way for writers to lock out RCU readers. This is a feature, not -//ust// * a bug -- this property is what provides RCU's performance benefits. -//ust// * Of course, writers must coordinate with each other. The normal -//ust// * spinlock primitives work well for this, but any other technique may be -//ust// * used as well. RCU does not care how the writers keep out of each -//ust// * others' way, as long as they do so. -//ust// */ -//ust// #define rcu_read_unlock() __rcu_read_unlock() -//ust// -//ust// /** -//ust// * rcu_read_lock_bh - mark the beginning of a softirq-only RCU critical section -//ust// * -//ust// * This is equivalent of rcu_read_lock(), but to be used when updates -//ust// * are being done using call_rcu_bh(). Since call_rcu_bh() callbacks -//ust// * consider completion of a softirq handler to be a quiescent state, -//ust// * a process in RCU read-side critical section must be protected by -//ust// * disabling softirqs. Read-side critical sections in interrupt context -//ust// * can use just rcu_read_lock(). -//ust// * -//ust// */ -//ust// #define rcu_read_lock_bh() __rcu_read_lock_bh() -//ust// -//ust// /* -//ust// * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section -//ust// * -//ust// * See rcu_read_lock_bh() for more information. -//ust// */ -//ust// #define rcu_read_unlock_bh() __rcu_read_unlock_bh() -//ust// -//ust// /** -//ust// * rcu_read_lock_sched - mark the beginning of a RCU-classic critical section -//ust// * -//ust// * Should be used with either -//ust// * - synchronize_sched() -//ust// * or -//ust// * - call_rcu_sched() and rcu_barrier_sched() -//ust// * on the write-side to insure proper synchronization. -//ust// */ -//ust// #define rcu_read_lock_sched() preempt_disable() -//ust// #define rcu_read_lock_sched_notrace() preempt_disable_notrace() -//ust// -//ust// /* -//ust// * rcu_read_unlock_sched - marks the end of a RCU-classic critical section -//ust// * -//ust// * See rcu_read_lock_sched for more information. -//ust// */ -//ust// #define rcu_read_unlock_sched() preempt_enable() -//ust// #define rcu_read_unlock_sched_notrace() preempt_enable_notrace() -//ust// -//ust// -//ust// -//ust// /** -//ust// * rcu_dereference - fetch an RCU-protected pointer in an -//ust// * RCU read-side critical section. This pointer may later -//ust// * be safely dereferenced. -//ust// * -//ust// * Inserts memory barriers on architectures that require them -//ust// * (currently only the Alpha), and, more importantly, documents -//ust// * exactly which pointers are protected by RCU. -//ust// */ -//ust// -//ust// #define rcu_dereference(p) ({ \ -//ust// typeof(p) _________p1 = ACCESS_ONCE(p); \ -//ust// smp_read_barrier_depends(); \ -//ust// (_________p1); \ -//ust// }) -//ust// -//ust// /** -//ust// * rcu_assign_pointer - assign (publicize) a pointer to a newly -//ust// * initialized structure that will be dereferenced by RCU read-side -//ust// * critical sections. Returns the value assigned. -//ust// * -//ust// * Inserts memory barriers on architectures that require them -//ust// * (pretty much all of them other than x86), and also prevents -//ust// * the compiler from reordering the code that initializes the -//ust// * structure after the pointer assignment. More importantly, this -//ust// * call documents which pointers will be dereferenced by RCU read-side -//ust// * code. -//ust// */ -//ust// -//ust// #define rcu_assign_pointer(p, v) \ -//ust// ({ \ -//ust// if (!__builtin_constant_p(v) || \ -//ust// ((v) != NULL)) \ -//ust// smp_wmb(); \ -//ust// (p) = (v); \ -//ust// }) -//ust// -//ust// /* Infrastructure to implement the synchronize_() primitives. */ -//ust// -//ust// struct rcu_synchronize { -//ust// struct rcu_head head; -//ust// struct completion completion; -//ust// }; -//ust// -//ust// extern void wakeme_after_rcu(struct rcu_head *head); -//ust// -//ust// /** -//ust// * synchronize_sched - block until all CPUs have exited any non-preemptive -//ust// * kernel code sequences. -//ust// * -//ust// * This means that all preempt_disable code sequences, including NMI and -//ust// * hardware-interrupt handlers, in progress on entry will have completed -//ust// * before this primitive returns. However, this does not guarantee that -//ust// * softirq handlers will have completed, since in some kernels, these -//ust// * handlers can run in process context, and can block. -//ust// * -//ust// * This primitive provides the guarantees made by the (now removed) -//ust// * synchronize_kernel() API. In contrast, synchronize_rcu() only -//ust// * guarantees that rcu_read_lock() sections will have completed. -//ust// * In "classic RCU", these two guarantees happen to be one and -//ust// * the same, but can differ in realtime RCU implementations. -//ust// */ -//ust// #define synchronize_sched() __synchronize_sched() -//ust// -//ust// /** -//ust// * call_rcu - Queue an RCU callback for invocation after a grace period. -//ust// * @head: structure to be used for queueing the RCU updates. -//ust// * @func: actual update function to be invoked after the grace period -//ust// * -//ust// * The update function will be invoked some time after a full grace -//ust// * period elapses, in other words after all currently executing RCU -//ust// * read-side critical sections have completed. RCU read-side critical -//ust// * sections are delimited by rcu_read_lock() and rcu_read_unlock(), -//ust// * and may be nested. -//ust// */ -//ust// extern void call_rcu(struct rcu_head *head, -//ust// void (*func)(struct rcu_head *head)); -//ust// -//ust// /** -//ust// * call_rcu_bh - Queue an RCU for invocation after a quicker grace period. -//ust// * @head: structure to be used for queueing the RCU updates. -//ust// * @func: actual update function to be invoked after the grace period -//ust// * -//ust// * The update function will be invoked some time after a full grace -//ust// * period elapses, in other words after all currently executing RCU -//ust// * read-side critical sections have completed. call_rcu_bh() assumes -//ust// * that the read-side critical sections end on completion of a softirq -//ust// * handler. This means that read-side critical sections in process -//ust// * context must not be interrupted by softirqs. This interface is to be -//ust// * used when most of the read-side critical sections are in softirq context. -//ust// * RCU read-side critical sections are delimited by : -//ust// * - rcu_read_lock() and rcu_read_unlock(), if in interrupt context. -//ust// * OR -//ust// * - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context. -//ust// * These may be nested. -//ust// */ -//ust// extern void call_rcu_bh(struct rcu_head *head, -//ust// void (*func)(struct rcu_head *head)); -//ust// -//ust// /* Exported common interfaces */ -//ust// extern void synchronize_rcu(void); -//ust// extern void rcu_barrier(void); -//ust// extern void rcu_barrier_bh(void); -//ust// extern void rcu_barrier_sched(void); -//ust// -//ust// /* Internal to kernel */ -//ust// extern void rcu_init(void); -//ust// extern int rcu_needs_cpu(int cpu); -//ust// -#endif /* __LINUX_RCUPDATE_H */ diff --git a/libtracing/marker-control.h b/libtracectl/marker-control.h similarity index 100% rename from libtracing/marker-control.h rename to libtracectl/marker-control.h -- 2.34.1