Fix missing va_end()s
[ccan] / ccan / ntdb / hash.c
1  /*
2    Trivial Database 2: hash handling
3    Copyright (C) Rusty Russell 2010
4
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 3 of the License, or (at your option) any later version.
9
10    This library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 */
18 #include "private.h"
19 #include <ccan/hash/hash.h>
20
21 /* Default hash function. */
22 uint32_t ntdb_jenkins_hash(const void *key, size_t length, uint32_t seed,
23                           void *unused)
24 {
25         return hash_stable((const unsigned char *)key, length, seed);
26 }
27
28 uint32_t ntdb_hash(struct ntdb_context *ntdb, const void *ptr, size_t len)
29 {
30         return ntdb->hash_fn(ptr, len, ntdb->hash_seed, ntdb->hash_data);
31 }
32
33 static ntdb_bool_err key_matches(struct ntdb_context *ntdb,
34                                  const struct ntdb_used_record *rec,
35                                  ntdb_off_t off,
36                                  const NTDB_DATA *key,
37                                  const char **rptr)
38 {
39         ntdb_bool_err ret = false;
40         const char *rkey;
41
42         if (rec_key_length(rec) != key->dsize) {
43                 ntdb->stats.compare_wrong_keylen++;
44                 return ret;
45         }
46
47         rkey = ntdb_access_read(ntdb, off + sizeof(*rec),
48                                 key->dsize + rec_data_length(rec), false);
49         if (NTDB_PTR_IS_ERR(rkey)) {
50                 return (ntdb_bool_err)NTDB_PTR_ERR(rkey);
51         }
52         if (memcmp(rkey, key->dptr, key->dsize) == 0) {
53                 if (rptr) {
54                         *rptr = rkey;
55                 } else {
56                         ntdb_access_release(ntdb, rkey);
57                 }
58                 return true;
59         }
60         ntdb->stats.compare_wrong_keycmp++;
61         ntdb_access_release(ntdb, rkey);
62         return ret;
63 }
64
65 /* Does entry match? */
66 static ntdb_bool_err match(struct ntdb_context *ntdb,
67                            uint32_t hash,
68                            const NTDB_DATA *key,
69                            ntdb_off_t val,
70                            struct ntdb_used_record *rec,
71                            const char **rptr)
72 {
73         ntdb_off_t off;
74         enum NTDB_ERROR ecode;
75
76         ntdb->stats.compares++;
77
78         /* Top bits of offset == next bits of hash. */
79         if (bits_from(hash, ntdb->hash_bits, NTDB_OFF_UPPER_STEAL)
80             != bits_from(val, 64-NTDB_OFF_UPPER_STEAL, NTDB_OFF_UPPER_STEAL)) {
81                 ntdb->stats.compare_wrong_offsetbits++;
82                 return false;
83         }
84
85         off = val & NTDB_OFF_MASK;
86         ecode = ntdb_read_convert(ntdb, off, rec, sizeof(*rec));
87         if (ecode != NTDB_SUCCESS) {
88                 return (ntdb_bool_err)ecode;
89         }
90
91         return key_matches(ntdb, rec, off, key, rptr);
92 }
93
94 static bool is_chain(ntdb_off_t val)
95 {
96         return val & (1ULL << NTDB_OFF_CHAIN_BIT);
97 }
98
99 static ntdb_off_t hbucket_off(ntdb_off_t base, ntdb_len_t idx)
100 {
101         return base + sizeof(struct ntdb_used_record)
102                 + idx * sizeof(ntdb_off_t);
103 }
104
105 /* This is the core routine which searches the hashtable for an entry.
106  * On error, no locks are held and -ve is returned.
107  * Otherwise, hinfo is filled in.
108  * If not found, the return value is 0.
109  * If found, the return value is the offset, and *rec is the record. */
110 ntdb_off_t find_and_lock(struct ntdb_context *ntdb,
111                          NTDB_DATA key,
112                          int ltype,
113                          struct hash_info *h,
114                          struct ntdb_used_record *rec,
115                          const char **rptr)
116 {
117         ntdb_off_t off, val;
118         const ntdb_off_t *arr = NULL;
119         ntdb_len_t i;
120         bool found_empty;
121         enum NTDB_ERROR ecode;
122         struct ntdb_used_record chdr;
123         ntdb_bool_err berr;
124
125         h->h = ntdb_hash(ntdb, key.dptr, key.dsize);
126
127         h->table = NTDB_HASH_OFFSET;
128         h->table_size = 1 << ntdb->hash_bits;
129         h->bucket = bits_from(h->h, 0, ntdb->hash_bits);
130         h->old_val = 0;
131
132         ecode = ntdb_lock_hash(ntdb, h->bucket, ltype);
133         if (ecode != NTDB_SUCCESS) {
134                 return NTDB_ERR_TO_OFF(ecode);
135         }
136
137         off = hbucket_off(h->table, h->bucket);
138         val = ntdb_read_off(ntdb, off);
139         if (NTDB_OFF_IS_ERR(val)) {
140                 ecode = NTDB_OFF_TO_ERR(val);
141                 goto fail;
142         }
143
144         /* Directly in hash table? */
145         if (!likely(is_chain(val))) {
146                 if (val) {
147                         berr = match(ntdb, h->h, &key, val, rec, rptr);
148                         if (berr < 0) {
149                                 ecode = NTDB_OFF_TO_ERR(berr);
150                                 goto fail;
151                         }
152                         if (berr) {
153                                 return val & NTDB_OFF_MASK;
154                         }
155                         /* If you want to insert here, make a chain. */
156                         h->old_val = val;
157                 }
158                 return 0;
159         }
160
161         /* Nope?  Iterate through chain. */
162         h->table = val & NTDB_OFF_MASK;
163
164         ecode = ntdb_read_convert(ntdb, h->table, &chdr, sizeof(chdr));
165         if (ecode != NTDB_SUCCESS) {
166                 goto fail;
167         }
168
169         if (rec_magic(&chdr) != NTDB_CHAIN_MAGIC) {
170                 ecode = ntdb_logerr(ntdb, NTDB_ERR_CORRUPT,
171                                     NTDB_LOG_ERROR,
172                                     "find_and_lock:"
173                                     " corrupt record %#x at %llu",
174                                     rec_magic(&chdr), (long long)off);
175                 goto fail;
176         }
177
178         h->table_size = rec_data_length(&chdr) / sizeof(ntdb_off_t);
179
180         arr = ntdb_access_read(ntdb, hbucket_off(h->table, 0),
181                                rec_data_length(&chdr), true);
182         if (NTDB_PTR_IS_ERR(arr)) {
183                 ecode = NTDB_PTR_ERR(arr);
184                 goto fail;
185         }
186
187         found_empty = false;
188         for (i = 0; i < h->table_size; i++) {
189                 if (arr[i] == 0) {
190                         if (!found_empty) {
191                                 h->bucket = i;
192                                 found_empty = true;
193                         }
194                 } else {
195                         berr = match(ntdb, h->h, &key, arr[i], rec, rptr);
196                         if (berr < 0) {
197                                 ecode = NTDB_OFF_TO_ERR(berr);
198                                 ntdb_access_release(ntdb, arr);
199                                 goto fail;
200                         }
201                         if (berr) {
202                                 /* We found it! */
203                                 h->bucket = i;
204                                 off = arr[i] & NTDB_OFF_MASK;
205                                 ntdb_access_release(ntdb, arr);
206                                 return off;
207                         }
208                 }
209         }
210         if (!found_empty) {
211                 /* Set to any non-zero value */
212                 h->old_val = 1;
213                 h->bucket = i;
214         }
215
216         ntdb_access_release(ntdb, arr);
217         return 0;
218
219 fail:
220         ntdb_unlock_hash(ntdb, h->bucket, ltype);
221         return NTDB_ERR_TO_OFF(ecode);
222 }
223
224 static ntdb_off_t encode_offset(const struct ntdb_context *ntdb,
225                                 ntdb_off_t new_off, uint32_t hash)
226 {
227         ntdb_off_t extra;
228
229         assert((new_off & (1ULL << NTDB_OFF_CHAIN_BIT)) == 0);
230         assert((new_off >> (64 - NTDB_OFF_UPPER_STEAL)) == 0);
231         /* We pack extra hash bits into the upper bits of the offset. */
232         extra = bits_from(hash, ntdb->hash_bits, NTDB_OFF_UPPER_STEAL);
233         extra <<= (64 - NTDB_OFF_UPPER_STEAL);
234
235         return new_off | extra;
236 }
237
238 /* Simply overwrite the hash entry we found before. */
239 enum NTDB_ERROR replace_in_hash(struct ntdb_context *ntdb,
240                                 const struct hash_info *h,
241                                 ntdb_off_t new_off)
242 {
243         return ntdb_write_off(ntdb, hbucket_off(h->table, h->bucket),
244                               encode_offset(ntdb, new_off, h->h));
245 }
246
247 enum NTDB_ERROR delete_from_hash(struct ntdb_context *ntdb,
248                                  const struct hash_info *h)
249 {
250         return ntdb_write_off(ntdb, hbucket_off(h->table, h->bucket), 0);
251 }
252
253
254 enum NTDB_ERROR add_to_hash(struct ntdb_context *ntdb,
255                             const struct hash_info *h,
256                             ntdb_off_t new_off)
257 {
258         enum NTDB_ERROR ecode;
259         ntdb_off_t chain;
260         struct ntdb_used_record chdr;
261         const ntdb_off_t *old;
262         ntdb_off_t *new;
263
264         /* We hit an empty bucket during search?  That's where it goes. */
265         if (!h->old_val) {
266                 return replace_in_hash(ntdb, h, new_off);
267         }
268
269         /* Full at top-level?  Create a 2-element chain. */
270         if (h->table == NTDB_HASH_OFFSET) {
271                 ntdb_off_t pair[2];
272
273                 /* One element is old value, the other is the new value. */
274                 pair[0] = h->old_val;
275                 pair[1] = encode_offset(ntdb, new_off, h->h);
276
277                 chain = alloc(ntdb, 0, sizeof(pair), NTDB_CHAIN_MAGIC, true);
278                 if (NTDB_OFF_IS_ERR(chain)) {
279                         return NTDB_OFF_TO_ERR(chain);
280                 }
281                 ecode = ntdb_write_convert(ntdb,
282                                            chain
283                                            + sizeof(struct ntdb_used_record),
284                                            pair, sizeof(pair));
285                 if (ecode == NTDB_SUCCESS) {
286                         ecode = ntdb_write_off(ntdb,
287                                                hbucket_off(h->table, h->bucket),
288                                                chain
289                                                | (1ULL << NTDB_OFF_CHAIN_BIT));
290                 }
291                 return ecode;
292         }
293
294         /* Full bucket.  Expand. */
295         ecode = ntdb_read_convert(ntdb, h->table, &chdr, sizeof(chdr));
296         if (ecode != NTDB_SUCCESS) {
297                 return ecode;
298         }
299
300         if (rec_extra_padding(&chdr) >= sizeof(new_off)) {
301                 /* Expand in place. */
302                 uint64_t dlen = rec_data_length(&chdr);
303
304                 ecode = set_header(ntdb, &chdr, NTDB_CHAIN_MAGIC, 0,
305                                    dlen + sizeof(new_off),
306                                    dlen + rec_extra_padding(&chdr));
307
308                 if (ecode != NTDB_SUCCESS) {
309                         return ecode;
310                 }
311                 /* find_and_lock set up h to point to last bucket. */
312                 ecode = replace_in_hash(ntdb, h, new_off);
313                 if (ecode != NTDB_SUCCESS) {
314                         return ecode;
315                 }
316                 ecode = ntdb_write_convert(ntdb, h->table, &chdr, sizeof(chdr));
317                 if (ecode != NTDB_SUCCESS) {
318                         return ecode;
319                 }
320                 /* For futureproofing, we always make the first byte of padding
321                  * a zero. */
322                 if (rec_extra_padding(&chdr)) {
323                         ecode = ntdb->io->twrite(ntdb, h->table + sizeof(chdr)
324                                                  + dlen + sizeof(new_off),
325                                                  "", 1);
326                 }
327                 return ecode;
328         }
329
330         /* We need to reallocate the chain. */
331         chain = alloc(ntdb, 0, (h->table_size + 1) * sizeof(ntdb_off_t),
332                       NTDB_CHAIN_MAGIC, true);
333         if (NTDB_OFF_IS_ERR(chain)) {
334                 return NTDB_OFF_TO_ERR(chain);
335         }
336
337         /* Map both and copy across old buckets. */
338         old = ntdb_access_read(ntdb, hbucket_off(h->table, 0),
339                                h->table_size*sizeof(ntdb_off_t), true);
340         if (NTDB_PTR_IS_ERR(old)) {
341                 return NTDB_PTR_ERR(old);
342         }
343         new = ntdb_access_write(ntdb, hbucket_off(chain, 0),
344                                 (h->table_size + 1)*sizeof(ntdb_off_t), true);
345         if (NTDB_PTR_IS_ERR(new)) {
346                 ntdb_access_release(ntdb, old);
347                 return NTDB_PTR_ERR(new);
348         }
349
350         memcpy(new, old, h->bucket * sizeof(ntdb_off_t));
351         new[h->bucket] = encode_offset(ntdb, new_off, h->h);
352         ntdb_access_release(ntdb, old);
353
354         ecode = ntdb_access_commit(ntdb, new);
355         if (ecode != NTDB_SUCCESS) {
356                 return ecode;
357         }
358
359         /* Free the old chain. */
360         ecode = add_free_record(ntdb, h->table,
361                                 sizeof(struct ntdb_used_record)
362                                 + rec_data_length(&chdr)
363                                 + rec_extra_padding(&chdr),
364                                 NTDB_LOCK_WAIT, true);
365
366         /* Replace top-level to point to new chain */
367         return ntdb_write_off(ntdb,
368                               hbucket_off(NTDB_HASH_OFFSET,
369                                           bits_from(h->h, 0, ntdb->hash_bits)),
370                               chain | (1ULL << NTDB_OFF_CHAIN_BIT));
371 }
372
373 /* Traverse support: returns offset of record, or 0 or -ve error. */
374 static ntdb_off_t iterate_chain(struct ntdb_context *ntdb,
375                                 ntdb_off_t val,
376                                 struct hash_info *h)
377 {
378         ntdb_off_t i;
379         enum NTDB_ERROR ecode;
380         struct ntdb_used_record chdr;
381
382         /* First load up chain header. */
383         h->table = val & NTDB_OFF_MASK;
384         ecode = ntdb_read_convert(ntdb, h->table, &chdr, sizeof(chdr));
385         if (ecode != NTDB_SUCCESS) {
386                 return ecode;
387         }
388
389         if (rec_magic(&chdr) != NTDB_CHAIN_MAGIC) {
390                 return ntdb_logerr(ntdb, NTDB_ERR_CORRUPT,
391                                    NTDB_LOG_ERROR,
392                                    "get_table:"
393                                    " corrupt record %#x at %llu",
394                                    rec_magic(&chdr),
395                                    (long long)h->table);
396         }
397
398         /* Chain length is implied by data length. */
399         h->table_size = rec_data_length(&chdr) / sizeof(ntdb_off_t);
400
401         i = ntdb_find_nonzero_off(ntdb, hbucket_off(h->table, 0), h->bucket,
402                                   h->table_size);
403         if (NTDB_OFF_IS_ERR(i)) {
404                 return i;
405         }
406
407         if (i != h->table_size) {
408                 /* Return to next bucket. */
409                 h->bucket = i + 1;
410                 val = ntdb_read_off(ntdb, hbucket_off(h->table, i));
411                 if (NTDB_OFF_IS_ERR(val)) {
412                         return val;
413                 }
414                 return val & NTDB_OFF_MASK;
415         }
416
417         /* Go back up to hash table. */
418         h->table = NTDB_HASH_OFFSET;
419         h->table_size = 1 << ntdb->hash_bits;
420         h->bucket = bits_from(h->h, 0, ntdb->hash_bits) + 1;
421         return 0;
422 }
423
424 /* Keeps hash locked unless returns 0 or error. */
425 static ntdb_off_t lock_and_iterate_hash(struct ntdb_context *ntdb,
426                                         struct hash_info *h)
427 {
428         ntdb_off_t val, i;
429         enum NTDB_ERROR ecode;
430
431         if (h->table != NTDB_HASH_OFFSET) {
432                 /* We're in a chain. */
433                 i = bits_from(h->h, 0, ntdb->hash_bits);
434                 ecode = ntdb_lock_hash(ntdb, i, F_RDLCK);
435                 if (ecode != NTDB_SUCCESS) {
436                         return NTDB_ERR_TO_OFF(ecode);
437                 }
438
439                 /* We dropped lock, bucket might have moved! */
440                 val = ntdb_read_off(ntdb, hbucket_off(NTDB_HASH_OFFSET, i));
441                 if (NTDB_OFF_IS_ERR(val)) {
442                         goto unlock;
443                 }
444
445                 /* We don't remove chains: there should still be one there! */
446                 if (!val || !is_chain(val)) {
447                         ecode = ntdb_logerr(ntdb, NTDB_ERR_CORRUPT,
448                                             NTDB_LOG_ERROR,
449                                             "iterate_hash:"
450                                             " vanished hchain %llu at %llu",
451                                             (long long)val,
452                                             (long long)i);
453                         val = NTDB_ERR_TO_OFF(ecode);
454                         goto unlock;
455                 }
456
457                 /* Find next bucket in the chain. */
458                 val = iterate_chain(ntdb, val, h);
459                 if (NTDB_OFF_IS_ERR(val)) {
460                         goto unlock;
461                 }
462                 if (val != 0) {
463                         return val;
464                 }
465                 ntdb_unlock_hash(ntdb, i, F_RDLCK);
466
467                 /* OK, we've reset h back to top level. */
468         }
469
470         /* We do this unlocked, then re-check. */
471         for (i = ntdb_find_nonzero_off(ntdb, hbucket_off(h->table, 0),
472                                        h->bucket, h->table_size);
473              i != h->table_size;
474              i = ntdb_find_nonzero_off(ntdb, hbucket_off(h->table, 0),
475                                        i+1, h->table_size)) {
476                 ecode = ntdb_lock_hash(ntdb, i, F_RDLCK);
477                 if (ecode != NTDB_SUCCESS) {
478                         return NTDB_ERR_TO_OFF(ecode);
479                 }
480
481                 val = ntdb_read_off(ntdb, hbucket_off(h->table, i));
482                 if (NTDB_OFF_IS_ERR(val)) {
483                         goto unlock;
484                 }
485
486                 /* Lost race, and it's empty? */
487                 if (!val) {
488                         ntdb->stats.traverse_val_vanished++;
489                         ntdb_unlock_hash(ntdb, i, F_RDLCK);
490                         continue;
491                 }
492
493                 if (!is_chain(val)) {
494                         /* So caller knows what lock to free. */
495                         h->h = i;
496                         /* Return to next bucket. */
497                         h->bucket = i + 1;
498                         val &= NTDB_OFF_MASK;
499                         return val;
500                 }
501
502                 /* Start at beginning of chain */
503                 h->bucket = 0;
504                 h->h = i;
505
506                 val = iterate_chain(ntdb, val, h);
507                 if (NTDB_OFF_IS_ERR(val)) {
508                         goto unlock;
509                 }
510                 if (val != 0) {
511                         return val;
512                 }
513
514                 /* Otherwise, bucket has been set to i+1 */
515                 ntdb_unlock_hash(ntdb, i, F_RDLCK);
516         }
517         return 0;
518
519 unlock:
520         ntdb_unlock_hash(ntdb, i, F_RDLCK);
521         return val;
522 }
523
524 /* Return success if we find something, NTDB_ERR_NOEXIST if none. */
525 enum NTDB_ERROR next_in_hash(struct ntdb_context *ntdb,
526                              struct hash_info *h,
527                              NTDB_DATA *kbuf, size_t *dlen)
528 {
529         ntdb_off_t off;
530         struct ntdb_used_record rec;
531         enum NTDB_ERROR ecode;
532
533         off = lock_and_iterate_hash(ntdb, h);
534
535         if (NTDB_OFF_IS_ERR(off)) {
536                 return NTDB_OFF_TO_ERR(off);
537         } else if (off == 0) {
538                 return NTDB_ERR_NOEXIST;
539         }
540
541         /* The hash for this key is still locked. */
542         ecode = ntdb_read_convert(ntdb, off, &rec, sizeof(rec));
543         if (ecode != NTDB_SUCCESS) {
544                 goto unlock;
545         }
546         if (rec_magic(&rec) != NTDB_USED_MAGIC) {
547                 ecode = ntdb_logerr(ntdb, NTDB_ERR_CORRUPT,
548                                     NTDB_LOG_ERROR,
549                                     "next_in_hash:"
550                                     " corrupt record at %llu",
551                                     (long long)off);
552                 goto unlock;
553         }
554
555         kbuf->dsize = rec_key_length(&rec);
556
557         /* They want data as well? */
558         if (dlen) {
559                 *dlen = rec_data_length(&rec);
560                 kbuf->dptr = ntdb_alloc_read(ntdb, off + sizeof(rec),
561                                              kbuf->dsize + *dlen);
562         } else {
563                 kbuf->dptr = ntdb_alloc_read(ntdb, off + sizeof(rec),
564                                              kbuf->dsize);
565         }
566         if (NTDB_PTR_IS_ERR(kbuf->dptr)) {
567                 ecode = NTDB_PTR_ERR(kbuf->dptr);
568                 goto unlock;
569         }
570         ecode = NTDB_SUCCESS;
571
572 unlock:
573         ntdb_unlock_hash(ntdb, bits_from(h->h, 0, ntdb->hash_bits), F_RDLCK);
574         return ecode;
575
576 }
577
578 enum NTDB_ERROR first_in_hash(struct ntdb_context *ntdb,
579                              struct hash_info *h,
580                              NTDB_DATA *kbuf, size_t *dlen)
581 {
582         h->table = NTDB_HASH_OFFSET;
583         h->table_size = 1 << ntdb->hash_bits;
584         h->bucket = 0;
585
586         return next_in_hash(ntdb, h, kbuf, dlen);
587 }
588
589 /* Even if the entry isn't in this hash bucket, you'd have to lock this
590  * bucket to find it. */
591 static enum NTDB_ERROR chainlock(struct ntdb_context *ntdb,
592                                  const NTDB_DATA *key, int ltype)
593 {
594         uint32_t h = ntdb_hash(ntdb, key->dptr, key->dsize);
595
596         return ntdb_lock_hash(ntdb, bits_from(h, 0, ntdb->hash_bits), ltype);
597 }
598
599 /* lock/unlock one hash chain. This is meant to be used to reduce
600    contention - it cannot guarantee how many records will be locked */
601 _PUBLIC_ enum NTDB_ERROR ntdb_chainlock(struct ntdb_context *ntdb, NTDB_DATA key)
602 {
603         return chainlock(ntdb, &key, F_WRLCK);
604 }
605
606 _PUBLIC_ void ntdb_chainunlock(struct ntdb_context *ntdb, NTDB_DATA key)
607 {
608         uint32_t h = ntdb_hash(ntdb, key.dptr, key.dsize);
609
610         ntdb_unlock_hash(ntdb, bits_from(h, 0, ntdb->hash_bits), F_WRLCK);
611 }
612
613 _PUBLIC_ enum NTDB_ERROR ntdb_chainlock_read(struct ntdb_context *ntdb,
614                                              NTDB_DATA key)
615 {
616         return chainlock(ntdb, &key, F_RDLCK);
617 }
618
619 _PUBLIC_ void ntdb_chainunlock_read(struct ntdb_context *ntdb, NTDB_DATA key)
620 {
621         uint32_t h = ntdb_hash(ntdb, key.dptr, key.dsize);
622
623         ntdb_unlock_hash(ntdb, bits_from(h, 0, ntdb->hash_bits), F_RDLCK);
624 }