e415d48872
Bumping libc files for unsupported architectures, to simplify merging. A bunch of small fixes: * in libutil update * the macro in endian.h * some undefined types due to clear separation from host. * Fix a warning for cdbr.c Some modification which were required for the new build system: * inclusion path for const.h in sconst, still hacky * Removed default malloc.c which conflicts on some occasions.
265 lines
6.7 KiB
C
265 lines
6.7 KiB
C
/* $NetBSD: cdbr.c,v 1.2 2010/06/03 12:40:52 veego Exp $ */
|
|
/*-
|
|
* Copyright (c) 2010 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Joerg Sonnenberger.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#if HAVE_NBTOOL_CONFIG_H
|
|
#include "nbtool_config.h"
|
|
#endif
|
|
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: cdbr.c,v 1.2 2010/06/03 12:40:52 veego Exp $");
|
|
|
|
#include "namespace.h"
|
|
|
|
#include <sys/bitops.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <cdbr.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#ifdef __weak_alias
|
|
__weak_alias(cdbr_close,_cdbr_close)
|
|
__weak_alias(cdbr_find,_cdbr_find)
|
|
__weak_alias(cdbr_get,_cdbr_get)
|
|
__weak_alias(cdbr_open,_cdbr_open)
|
|
#endif
|
|
|
|
struct cdbr {
|
|
uint8_t *mmap_base;
|
|
size_t mmap_size;
|
|
|
|
uint8_t *hash_base;
|
|
uint8_t *offset_base;
|
|
uint8_t *data_base;
|
|
|
|
uint32_t data_size;
|
|
uint32_t entries;
|
|
uint32_t entries_index;
|
|
uint32_t seed;
|
|
|
|
uint8_t offset_size;
|
|
uint8_t index_size;
|
|
|
|
uint32_t entries_m;
|
|
uint32_t entries_index_m;
|
|
uint8_t entries_s1, entries_s2;
|
|
uint8_t entries_index_s1, entries_index_s2;
|
|
};
|
|
|
|
/* ARGSUSED */
|
|
struct cdbr *
|
|
cdbr_open(const char *path, int flags)
|
|
{
|
|
uint8_t buf[40];
|
|
int fd;
|
|
struct cdbr *cdbr;
|
|
struct stat sb;
|
|
|
|
if ((fd = open(path, O_RDONLY)) == -1)
|
|
return NULL;
|
|
|
|
errno = EINVAL;
|
|
if (fstat(fd, &sb) == -1 ||
|
|
read(fd, buf, sizeof(buf)) != sizeof(buf) ||
|
|
memcmp(buf, "NBCDB\n\0\001", 8) ||
|
|
(cdbr = malloc(sizeof(*cdbr))) == NULL) {
|
|
close(fd);
|
|
return NULL;
|
|
}
|
|
|
|
cdbr->data_size = le32dec(buf + 24);
|
|
cdbr->entries = le32dec(buf + 28);
|
|
cdbr->entries_index = le32dec(buf + 32);
|
|
cdbr->seed = le32dec(buf + 36);
|
|
|
|
if (cdbr->data_size < 0x100)
|
|
cdbr->offset_size = 1;
|
|
else if (cdbr->data_size < 0x10000)
|
|
cdbr->offset_size = 2;
|
|
else
|
|
cdbr->offset_size = 4;
|
|
|
|
if (cdbr->entries_index < 0x100)
|
|
cdbr->index_size = 1;
|
|
else if (cdbr->entries_index < 0x10000)
|
|
cdbr->index_size = 2;
|
|
else
|
|
cdbr->index_size = 4;
|
|
|
|
cdbr->mmap_size = (size_t)sb.st_size;
|
|
#ifdef __minix
|
|
if(!(cdbr->mmap_base = malloc(cdbr->mmap_size))) {
|
|
free(cdbr);
|
|
return NULL;
|
|
}
|
|
|
|
if ((size_t)read(fd, cdbr->mmap_base, cdbr->mmap_size) != cdbr->mmap_size)
|
|
{
|
|
free(cdbr->mmap_base);
|
|
free(cdbr);
|
|
return NULL;
|
|
}
|
|
#else /* !__minix */
|
|
cdbr->mmap_base = mmap(NULL, cdbr->mmap_size, PROT_READ, MAP_FILE|MAP_SHARED, fd, 0);
|
|
#endif /* __minix */
|
|
close(fd);
|
|
|
|
if (cdbr->mmap_base == MAP_FAILED) {
|
|
free(cdbr);
|
|
return NULL;
|
|
}
|
|
|
|
cdbr->hash_base = cdbr->mmap_base + 40;
|
|
cdbr->offset_base = cdbr->hash_base + cdbr->entries_index * cdbr->index_size;
|
|
if (cdbr->entries_index * cdbr->index_size % cdbr->offset_size)
|
|
cdbr->offset_base += cdbr->offset_size -
|
|
cdbr->entries_index * cdbr->index_size % cdbr->offset_size;
|
|
cdbr->data_base = cdbr->offset_base + (cdbr->entries + 1) * cdbr->offset_size;
|
|
|
|
if (cdbr->hash_base < cdbr->mmap_base ||
|
|
cdbr->offset_base < cdbr->mmap_base ||
|
|
cdbr->data_base < cdbr->mmap_base ||
|
|
cdbr->data_base + cdbr->data_size < cdbr->mmap_base ||
|
|
cdbr->data_base + cdbr->data_size >
|
|
cdbr->mmap_base + cdbr->mmap_size ||
|
|
cdbr->entries == 0 || cdbr->entries_index == 0) {
|
|
errno = EINVAL;
|
|
cdbr_close(cdbr);
|
|
return NULL;
|
|
}
|
|
|
|
fast_divide32_prepare(cdbr->entries, &cdbr->entries_m,
|
|
&cdbr->entries_s1, &cdbr->entries_s2);
|
|
fast_divide32_prepare(cdbr->entries_index, &cdbr->entries_index_m,
|
|
&cdbr->entries_index_s1, &cdbr->entries_index_s2);
|
|
|
|
return cdbr;
|
|
}
|
|
|
|
static inline uint32_t
|
|
get_uintX(const uint8_t *addr, uint32_t idx, int size)
|
|
{
|
|
addr += idx * size;
|
|
|
|
if (size == 4)
|
|
return /* LINTED */le32toh(*(const uint32_t *)addr);
|
|
else if (size == 2)
|
|
return /* LINTED */le16toh(*(const uint16_t *)addr);
|
|
else
|
|
return *addr;
|
|
}
|
|
|
|
uint32_t
|
|
cdbr_entries(struct cdbr *cdbr)
|
|
{
|
|
|
|
return cdbr->entries;
|
|
}
|
|
|
|
int
|
|
cdbr_get(struct cdbr *cdbr, uint32_t idx, const void **data, size_t *data_len)
|
|
{
|
|
uint32_t start, end;
|
|
|
|
if (idx >= cdbr->entries) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
start = get_uintX(cdbr->offset_base, idx, cdbr->offset_size);
|
|
end = get_uintX(cdbr->offset_base, idx + 1, cdbr->offset_size);
|
|
|
|
if (start > end) {
|
|
errno = EIO;
|
|
return -1;
|
|
}
|
|
|
|
if (end > cdbr->data_size) {
|
|
errno = EIO;
|
|
return -1;
|
|
}
|
|
|
|
*data = cdbr->data_base + start;
|
|
*data_len = end - start;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
cdbr_find(struct cdbr *cdbr, const void *key, size_t key_len,
|
|
const void **data, size_t *data_len)
|
|
{
|
|
uint32_t hashes[3], idx;
|
|
|
|
if (cdbr->entries_index == 0) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
mi_vector_hash(key, key_len, cdbr->seed, hashes);
|
|
|
|
hashes[0] = fast_remainder32(hashes[0], cdbr->entries_index,
|
|
cdbr->entries_index_m, cdbr->entries_index_s1,
|
|
cdbr->entries_index_s2);
|
|
hashes[1] = fast_remainder32(hashes[1], cdbr->entries_index,
|
|
cdbr->entries_index_m, cdbr->entries_index_s1,
|
|
cdbr->entries_index_s2);
|
|
hashes[2] = fast_remainder32(hashes[2], cdbr->entries_index,
|
|
cdbr->entries_index_m, cdbr->entries_index_s1,
|
|
cdbr->entries_index_s2);
|
|
|
|
idx = get_uintX(cdbr->hash_base, hashes[0], cdbr->index_size);
|
|
idx += get_uintX(cdbr->hash_base, hashes[1], cdbr->index_size);
|
|
idx += get_uintX(cdbr->hash_base, hashes[2], cdbr->index_size);
|
|
|
|
return cdbr_get(cdbr, fast_remainder32(idx, cdbr->entries,
|
|
cdbr->entries_m, cdbr->entries_s1, cdbr->entries_s2), data,
|
|
data_len);
|
|
}
|
|
|
|
void
|
|
cdbr_close(struct cdbr *cdbr)
|
|
{
|
|
#ifdef __minix
|
|
free(cdbr->mmap_base);
|
|
#else
|
|
munmap(cdbr->mmap_base, cdbr->mmap_size);
|
|
#endif
|
|
free(cdbr);
|
|
}
|