[PATCH 02/10] fs/namei.c: Add hash_string() function

From: George Spelvin
Date: Wed May 25 2016 - 03:22:56 EST


It's not actually used in that file, but goes with hash_name() and
full_name_hash(), so it's simplest to keep it there.

Also simplify the prototype of full_name_hash to be take
a "char *" rather than "unsigned char *". That's consistent
with hash_name().

Signed-off-by: George Spelvin <linux@xxxxxxxxxxxxxxxxxxx>
---
fs/namei.c | 47 +++++++++++++++++++++++++++++++++++++++++++---
include/linux/stringhash.h | 8 ++++++--
2 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/fs/namei.c b/fs/namei.c
index 42f8ca03..ce640d65 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1822,7 +1822,8 @@ static inline unsigned long mix_hash(unsigned long hash)

#endif

-unsigned int full_name_hash(const unsigned char *name, unsigned int len)
+/* Return the hash of a string of known length */
+unsigned int full_name_hash(const char *name, unsigned int len)
{
unsigned long a, hash = 0;

@@ -1842,6 +1843,29 @@ done:
}
EXPORT_SYMBOL(full_name_hash);

+/* Return the "hash_len" (hash and length) of a null-terminated string */
+u64 hash_string(const char *name)
+{
+ unsigned long a, adata, mask, hash, len;
+ const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
+
+ hash = a = 0;
+ len = -sizeof(unsigned long);
+ do {
+ hash = mix_hash(hash + a);
+ len += sizeof(unsigned long);
+ a = load_unaligned_zeropad(name+len);
+ } while (!has_zero(a, &adata, &constants));
+
+ adata = prep_zero_mask(a, adata, &constants);
+ mask = create_zero_mask(adata);
+ hash += a & zero_bytemask(mask);
+ len += find_zero(mask);
+
+ return hashlen_create(fold_hash(hash), len);
+}
+EXPORT_SYMBOL(hash_string);
+
/*
* Calculate the length and hash of the path component, and
* return the "hash_len" as the result.
@@ -1872,15 +1896,32 @@ static inline u64 hash_name(const char *name)

#else

-unsigned int full_name_hash(const unsigned char *name, unsigned int len)
+/* Return the hash of a string of known length */
+unsigned int full_name_hash(const char *name, unsigned int len)
{
unsigned long hash = init_name_hash();
while (len--)
- hash = partial_name_hash(*name++, hash);
+ hash = partial_name_hash((unsigned char)*name++, hash);
return end_name_hash(hash);
}
EXPORT_SYMBOL(full_name_hash);

+/* Return the "hash_len" (hash and length) of a null-terminated string */
+u64 hash_string(const char *name)
+{
+ unsigned long hash = init_name_hash();
+ unsigned long len = 0, c;
+
+ c = (unsigned char)*name;
+ do {
+ len++;
+ hash = partial_name_hash(c, hash);
+ c = (unsigned char)name[len];
+ } while (c);
+ return hashlen_create(end_name_hash(hash), len);
+}
+EXPORT_SYMBOL(hash_string);
+
/*
* We know there's a real path component here of at least
* one character.
diff --git a/include/linux/stringhash.h b/include/linux/stringhash.h
index 144d8c0f..d1c80ba2 100644
--- a/include/linux/stringhash.h
+++ b/include/linux/stringhash.h
@@ -1,7 +1,8 @@
#ifndef __LINUX_STRINGHASH_H
#define __LINUX_STRINGHASH_H

-#include <linux/types.h>
+#include <linux/compiler.h> /* For __pure */
+#include <linux/types.h> /* For u32, u64 */

/*
* Routines for hashing strings of bytes to a 32-bit hash value.
@@ -59,7 +60,7 @@ static inline unsigned long end_name_hash(unsigned long hash)
*
* If not set, this falls back to a wrapper around the preceding.
*/
-extern unsigned int full_name_hash(const unsigned char *, unsigned int);
+extern unsigned int __pure full_name_hash(const char *, unsigned int);

/*
* A hash_len is a u64 with the hash of a string in the low
@@ -69,4 +70,7 @@ extern unsigned int full_name_hash(const unsigned char *, unsigned int);
#define hashlen_len(hashlen) ((u32)((hashlen) >> 32))
#define hashlen_create(hash,len) ((u64)(len)<<32 | (u32)(hash))

+/* Return the "hash_len" (hash and length) of a null-terminated string */
+extern u64 __pure hash_string(const char *name);
+
#endif /* __LINUX_STRINGHASH_H */
--
2.8.1