NAME    [Toc]    [Back]

     hash - general kernel hashing functions

SYNOPSIS    [Toc]    [Back]

     #include <sys/hash.h>

     uint32_t
     hash32_buf(void *buf, size_t len, uint32_t hash);

     uint32_t
     hash32_str(void *buf, uint32_t hash);

     uint32_t
     hash32_strn(void *buf, size_t len, uint32_t hash);

     uint32_t
     hash32_stre(void *buf, int end, char **ep, uint32_t hash);

     uint32_t
     hash32_strne(void *buf, size_t  len,  int  end,  char  **ep,
uint32_t hash);

DESCRIPTION    [Toc]    [Back]

     The  hash32()  functions  are  used to give a consistent and
general interface
 to a decent hashing algorithm within the kernel.  These
functions
     can be used to hash ASCII NUL terminated strings, as well as
blocks of
     memory.

     The hash32_buf() function is used as a general buffer  hashing function.
     The argument buf is used to pass in the location, and len is
the length
     of the buffer.  The argument hash is used to extend  an  existing hash, or
     is passed the initial value HASHINIT to start a new hash.

     The  hash32_str()  function is used to hash a NUL terminated
string passed
     in buf with initial hash value given in hash.

     The hash32_strn() function is like  the  hash32_str()  function, except it
     also  takes  a  len argument, which is the maximal length of
the expected
     string.

     The hash32_stre() and hash32_strne()  functions  are  helper
functions used
     by  the kernel to hash pathname components.  These functions
have the additional
 termination condition of terminating when they find
a character
     given by end in the string to be hashed.  If the argument ep
is not NULL,
     it is set to the point in the buffer at which the hash function terminated
 hashing.

RETURN VALUES    [Toc]    [Back]

     The  hash32()  functions  return  a 32 bit hash value of the
buffer or
     string.

EXAMPLES    [Toc]    [Back]

           LIST_HEAD(head, cache) *hashtbl = NULL;
           u_long mask = 0;

           void
           sample_init(void)
           {
                   hashtbl  =  hashinit(numwanted,  type,  flags,
&mask);
           }

           void
           sample_use(char *str, int len)
           {
                   uint32_t hash;

                   hash = hash32_str(str, HASHINIT);
                   hash = hash32_buf(&len, sizeof(len), hash);
                   hashtbl[hash & mask] = len;
           }

SEE ALSO    [Toc]    [Back]

     free(9), hashinit(9), malloc(9)

LIMITATIONS    [Toc]    [Back]

     The hash32() functions are only 32 bit functions.  They will
prove to
     give poor 64 bit performance,  especially  for  the  top  32
bits.  At the
     current  time,  this  is  not seen as a great limitation, as
these hash values
 are usually used to index into an array.   Should  these
hash values be
     used for other means, this limitation should be revisited.

HISTORY    [Toc]    [Back]

     The  hash functions were first committed to NetBSD 1.6.  The
OpenBSD versions
 were written and massaged for OpenBSD  2.3  by  Tobias
Weingartner,
     and finally committed for OpenBSD 3.2.

OpenBSD      3.6                         December     8,     2001