335 lines
9.5 KiB
Diff
335 lines
9.5 KiB
Diff
autofs-5.1.6 - add hashtable implementation
|
|
|
|
From: Ian Kent <raven@themaw.net>
|
|
|
|
Include the (slightly modified) Linux kernel hashtable implementation.
|
|
|
|
Signed-off-by: Ian Kent <raven@themaw.net>
|
|
---
|
|
CHANGELOG | 1
|
|
include/automount.h | 19 -----
|
|
include/hash.h | 101 +++++++++++++++++++++++++++++++
|
|
include/hashtable.h | 166 ++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
4 files changed, 269 insertions(+), 18 deletions(-)
|
|
create mode 100644 include/hash.h
|
|
create mode 100644 include/hashtable.h
|
|
|
|
--- autofs-5.1.4.orig/CHANGELOG
|
|
+++ autofs-5.1.4/CHANGELOG
|
|
@@ -117,6 +117,7 @@ xx/xx/2018 autofs-5.1.5
|
|
- make bind mounts propagation slave by default.
|
|
- fix browse dir not re-created on symlink expire.
|
|
- update list.h.
|
|
+- add hashtable implementation.
|
|
|
|
19/12/2017 autofs-5.1.4
|
|
- fix spec file url.
|
|
--- autofs-5.1.4.orig/include/automount.h
|
|
+++ autofs-5.1.4/include/automount.h
|
|
@@ -22,6 +22,7 @@
|
|
#include <mntent.h>
|
|
#include "config.h"
|
|
#include "list.h"
|
|
+#include "hash.h"
|
|
|
|
#include <linux/auto_fs4.h>
|
|
|
|
@@ -143,24 +144,6 @@ struct autofs_point;
|
|
#define UMOUNT_RETRIES 8
|
|
#define EXPIRE_RETRIES 3
|
|
|
|
-static u_int32_t inline hash(const char *key, unsigned int size)
|
|
-{
|
|
- u_int32_t hashval;
|
|
- char *s = (char *) key;
|
|
-
|
|
- for (hashval = 0; *s != '\0';) {
|
|
- hashval += (unsigned char) *s++;
|
|
- hashval += (hashval << 10);
|
|
- hashval ^= (hashval >> 6);
|
|
- }
|
|
-
|
|
- hashval += (hashval << 3);
|
|
- hashval ^= (hashval >> 11);
|
|
- hashval += (hashval << 15);
|
|
-
|
|
- return hashval % size;
|
|
-}
|
|
-
|
|
struct mapent_cache {
|
|
pthread_rwlock_t rwlock;
|
|
unsigned int size;
|
|
--- /dev/null
|
|
+++ autofs-5.1.4/include/hash.h
|
|
@@ -0,0 +1,101 @@
|
|
+#ifndef _LINUX_HASH_H
|
|
+#define _LINUX_HASH_H
|
|
+/* Fast hashing routine for ints, longs and pointers.
|
|
+ (C) 2002 Nadia Yvette Chambers, IBM */
|
|
+
|
|
+#include <sys/types.h>
|
|
+#include <stdint.h>
|
|
+
|
|
+/*
|
|
+ * The "GOLDEN_RATIO_PRIME" is used in ifs/btrfs/brtfs_inode.h and
|
|
+ * fs/inode.c. It's not actually prime any more (the previous primes
|
|
+ * were actively bad for hashing), but the name remains.
|
|
+ */
|
|
+#if __WORDSIZE == 32
|
|
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_32
|
|
+#define hash_long(val, bits) hash_32(val, bits)
|
|
+#elif __WORDSIZE == 64
|
|
+#define hash_long(val, bits) hash_64(val, bits)
|
|
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_64
|
|
+#else
|
|
+#error Wordsize not 32 or 64
|
|
+#endif
|
|
+
|
|
+/* String based hash function */
|
|
+static uint32_t inline hash(const char *key, unsigned int size)
|
|
+{
|
|
+ u_int32_t hashval;
|
|
+ char *s = (char *) key;
|
|
+
|
|
+ for (hashval = 0; *s != '\0';) {
|
|
+ hashval += (unsigned char) *s++;
|
|
+ hashval += (hashval << 10);
|
|
+ hashval ^= (hashval >> 6);
|
|
+ }
|
|
+
|
|
+ hashval += (hashval << 3);
|
|
+ hashval ^= (hashval >> 11);
|
|
+ hashval += (hashval << 15);
|
|
+
|
|
+ return hashval % size;
|
|
+}
|
|
+
|
|
+/*
|
|
+ * This hash multiplies the input by a large odd number and takes the
|
|
+ * high bits. Since multiplication propagates changes to the most
|
|
+ * significant end only, it is essential that the high bits of the
|
|
+ * product be used for the hash value.
|
|
+ *
|
|
+ * Chuck Lever verified the effectiveness of this technique:
|
|
+ * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf
|
|
+ *
|
|
+ * Although a random odd number will do, it turns out that the golden
|
|
+ * ratio phi = (sqrt(5)-1)/2, or its negative, has particularly nice
|
|
+ * properties. (See Knuth vol 3, section 6.4, exercise 9.)
|
|
+ *
|
|
+ * These are the negative, (1 - phi) = phi**2 = (3 - sqrt(5))/2,
|
|
+ * which is very slightly easier to multiply by and makes no
|
|
+ * difference to the hash distribution.
|
|
+ */
|
|
+#define GOLDEN_RATIO_32 0x61C88647
|
|
+#define GOLDEN_RATIO_64 0x61C8864680B583EBull
|
|
+
|
|
+static inline uint32_t __hash_32(uint32_t val)
|
|
+{
|
|
+ return val * GOLDEN_RATIO_32;
|
|
+}
|
|
+
|
|
+static inline uint32_t hash_32(uint32_t val, unsigned int bits)
|
|
+{
|
|
+ /* High bits are more random, so use them. */
|
|
+ return __hash_32(val) >> (32 - bits);
|
|
+}
|
|
+
|
|
+static __always_inline uint32_t hash_64(uint64_t val, unsigned int bits)
|
|
+{
|
|
+#if __WORDSIZE == 64
|
|
+ /* 64x64-bit multiply is efficient on all 64-bit processors */
|
|
+ return val * GOLDEN_RATIO_64 >> (64 - bits);
|
|
+#else
|
|
+ /* Hash 64 bits using only 32x32-bit multiply. */
|
|
+ return hash_32((uint32_t) val ^ __hash_32(val >> 32), bits);
|
|
+#endif
|
|
+}
|
|
+
|
|
+static inline uint32_t hash_ptr(const void *ptr, unsigned int bits)
|
|
+{
|
|
+ return hash_long((unsigned long) ptr, bits);
|
|
+}
|
|
+
|
|
+/* This really should be called fold32_ptr; it does no hashing to speak of. */
|
|
+static inline uint32_t hash32_ptr(const void *ptr)
|
|
+{
|
|
+ unsigned long val = (unsigned long) ptr;
|
|
+
|
|
+#if __WORDSIZE == 64
|
|
+ val ^= (val >> 32);
|
|
+#endif
|
|
+ return (uint32_t) val;
|
|
+}
|
|
+
|
|
+#endif /* _LINUX_HASH_H */
|
|
--- /dev/null
|
|
+++ autofs-5.1.4/include/hashtable.h
|
|
@@ -0,0 +1,166 @@
|
|
+/*
|
|
+ * Statically sized hash table implementation
|
|
+ * (C) 2012 Sasha Levin <levinsasha928@gmail.com>
|
|
+ */
|
|
+
|
|
+#ifndef _LINUX_HASHTABLE_H
|
|
+#define _LINUX_HASHTABLE_H
|
|
+
|
|
+#include "list.h"
|
|
+#include "hash.h"
|
|
+
|
|
+#ifndef ARRAY_SIZE
|
|
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
|
|
+#endif
|
|
+
|
|
+static inline unsigned int ilog2(unsigned long val) {
|
|
+ unsigned int ret = -1;
|
|
+
|
|
+ while (val != 0) {
|
|
+ val >>= 1;
|
|
+ ret++;
|
|
+ }
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+#define DEFINE_HASHTABLE(name, bits) \
|
|
+ struct hlist_head name[1 << (bits)] = \
|
|
+ { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }
|
|
+
|
|
+#define DECLARE_HASHTABLE(name, bits) \
|
|
+ struct hlist_head name[1 << (bits)]
|
|
+
|
|
+#define HASH_SIZE(name) (ARRAY_SIZE(name))
|
|
+#define HASH_BITS(name) ilog2(HASH_SIZE(name))
|
|
+
|
|
+/* Use hash_32 when possible to allow for fast 32bit hashing in 64bit kernels. */
|
|
+#define hash_min(val, bits) \
|
|
+ (sizeof(val) <= 4 ? hash_32(val, bits) : hash_long(val, bits))
|
|
+
|
|
+static inline void __hash_init(struct hlist_head *ht, unsigned int sz)
|
|
+{
|
|
+ unsigned int i;
|
|
+
|
|
+ for (i = 0; i < sz; i++)
|
|
+ INIT_HLIST_HEAD(&ht[i]);
|
|
+}
|
|
+
|
|
+/**
|
|
+ * hash_init - initialize a hash table
|
|
+ * @hashtable: hashtable to be initialized
|
|
+ *
|
|
+ * Calculates the size of the hashtable from the given parameter, otherwise
|
|
+ * same as hash_init_size.
|
|
+ *
|
|
+ * This has to be a macro since HASH_BITS() will not work on pointers since
|
|
+ * it calculates the size during preprocessing.
|
|
+ */
|
|
+#define hash_init(hashtable) __hash_init(hashtable, HASH_SIZE(hashtable))
|
|
+
|
|
+/**
|
|
+ * hash_add - add an object to a hashtable
|
|
+ * @hashtable: hashtable to add to
|
|
+ * @node: the &struct hlist_node of the object to be added
|
|
+ * @key: the key of the object to be added
|
|
+ */
|
|
+#define hash_add(hashtable, node, key) \
|
|
+ hlist_add_head(node, &hashtable[hash_min(key, HASH_BITS(hashtable))])
|
|
+
|
|
+/**
|
|
+ * hash_add_str - add a string object to a hashtable
|
|
+ * @hashtable: hashtable to add to
|
|
+ * @node: the &struct hlist_node of the object to be added
|
|
+ * @key: the string key of the object to be added
|
|
+ */
|
|
+#define hash_add_str(hashtable, node, key) \
|
|
+ hlist_add_head(node, &hashtable[hash(key, HASH_SIZE(hashtable))])
|
|
+
|
|
+/**
|
|
+ * hash_hashed - check whether an object is in any hashtable
|
|
+ * @node: the &struct hlist_node of the object to be checked
|
|
+ */
|
|
+static inline int hash_hashed(struct hlist_node *node)
|
|
+{
|
|
+ return !hlist_unhashed(node);
|
|
+}
|
|
+
|
|
+static inline int __hash_empty(struct hlist_head *ht, unsigned int sz)
|
|
+{
|
|
+ unsigned int i;
|
|
+
|
|
+ for (i = 0; i < sz; i++)
|
|
+ if (!hlist_empty(&ht[i]))
|
|
+ return 0;
|
|
+
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+/**
|
|
+ * hash_empty - check whether a hashtable is empty
|
|
+ * @hashtable: hashtable to check
|
|
+ *
|
|
+ * This has to be a macro since HASH_BITS() will not work on pointers since
|
|
+ * it calculates the size during preprocessing.
|
|
+ */
|
|
+#define hash_empty(hashtable) __hash_empty(hashtable, HASH_SIZE(hashtable))
|
|
+
|
|
+/**
|
|
+ * hash_del - remove an object from a hashtable
|
|
+ * @node: &struct hlist_node of the object to remove
|
|
+ */
|
|
+static inline void hash_del(struct hlist_node *node)
|
|
+{
|
|
+ hlist_del_init(node);
|
|
+}
|
|
+
|
|
+/**
|
|
+ * hash_for_each - iterate over a hashtable
|
|
+ * @name: hashtable to iterate
|
|
+ * @bkt: integer to use as bucket loop cursor
|
|
+ * @obj: the type * to use as a loop cursor for each entry
|
|
+ * @member: the name of the hlist_node within the struct
|
|
+ */
|
|
+#define hash_for_each(name, bkt, obj, member) \
|
|
+ for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < HASH_SIZE(name);\
|
|
+ (bkt)++)\
|
|
+ hlist_for_each_entry(obj, &name[bkt], member)
|
|
+
|
|
+/**
|
|
+ * hash_for_each_safe - iterate over a hashtable safe against removal of
|
|
+ * hash entry
|
|
+ * @name: hashtable to iterate
|
|
+ * @bkt: integer to use as bucket loop cursor
|
|
+ * @tmp: a &struct used for temporary storage
|
|
+ * @obj: the type * to use as a loop cursor for each entry
|
|
+ * @member: the name of the hlist_node within the struct
|
|
+ */
|
|
+#define hash_for_each_safe(name, bkt, tmp, obj, member) \
|
|
+ for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < HASH_SIZE(name);\
|
|
+ (bkt)++)\
|
|
+ hlist_for_each_entry_safe(obj, tmp, &name[bkt], member)
|
|
+
|
|
+/**
|
|
+ * hash_for_each_possible - iterate over all possible objects hashing to the
|
|
+ * same bucket
|
|
+ * @name: hashtable to iterate
|
|
+ * @obj: the type * to use as a loop cursor for each entry
|
|
+ * @member: the name of the hlist_node within the struct
|
|
+ * @key: the key of the objects to iterate over
|
|
+ */
|
|
+#define hash_for_each_possible(name, obj, member, key) \
|
|
+ hlist_for_each_entry(obj, &name[hash_min(key, HASH_BITS(name))], member)
|
|
+
|
|
+/**
|
|
+ * hash_for_each_possible_safe - iterate over all possible objects hashing to the
|
|
+ * same bucket safe against removals
|
|
+ * @name: hashtable to iterate
|
|
+ * @obj: the type * to use as a loop cursor for each entry
|
|
+ * @tmp: a &struct used for temporary storage
|
|
+ * @member: the name of the hlist_node within the struct
|
|
+ * @key: the key of the objects to iterate over
|
|
+ */
|
|
+#define hash_for_each_possible_safe(name, obj, tmp, member, key) \
|
|
+ hlist_for_each_entry_safe(obj, tmp,\
|
|
+ &name[hash_min(key, HASH_BITS(name))], member)
|
|
+
|
|
+#endif
|