31 static void move_xl_segment(void* base, udb_base* udb, udb_void xl,
77 	udb_base* udb = (udb_base*)xalloc_zero(sizeof(*udb));  in udb_base_create_fd()  local
78 	if(!udb) {  in udb_base_create_fd()
83 	udb->fname = strdup(fname);  in udb_base_create_fd()
84 	if(!udb->fname) {  in udb_base_create_fd()
86 		free(udb);  in udb_base_create_fd()
90 	udb->walkfunc = walkfunc;  in udb_base_create_fd()
91 	udb->walkarg = arg;  in udb_base_create_fd()
92 	udb->fd = fd;  in udb_base_create_fd()
93 	udb->ram_size = 1024;  in udb_base_create_fd()
94 	udb->ram_mask = (int)udb->ram_size - 1;  in udb_base_create_fd()
95 	udb->ram_hash = (udb_ptr**)xalloc_array_zero(sizeof(udb_ptr*),  in udb_base_create_fd()
96 		udb->ram_size);  in udb_base_create_fd()
97 	if(!udb->ram_hash) {  in udb_base_create_fd()
98 		free(udb->fname);  in udb_base_create_fd()
99 		free(udb);  in udb_base_create_fd()
172 	udb->base_size = (size_t)g.fsize;  in udb_base_create_fd()
176 	udb->base = mmap(NULL, (size_t)udb->base_size,  in udb_base_create_fd()
178 		(int)udb->fd, (off_t)0);  in udb_base_create_fd()
180 	udb->base = MAP_FAILED; errno = ENOSYS;  in udb_base_create_fd()
182 	if(udb->base == MAP_FAILED) {  in udb_base_create_fd()
183 		udb->base = NULL;  in udb_base_create_fd()
185 			(unsigned)udb->base_size, strerror(errno));  in udb_base_create_fd()
188 		free(udb->fname);  in udb_base_create_fd()
189 		free(udb->ram_hash);  in udb_base_create_fd()
190 		free(udb);  in udb_base_create_fd()
195 	udb->glob_data = (udb_glob_d*)((char*)udb->base+sizeof(uint64_t));  in udb_base_create_fd()
198 	if(udb->glob_data->dirty_alloc != udb_dirty_clean)  in udb_base_create_fd()
200 	udb->alloc = udb_alloc_create(udb, (udb_alloc_d*)(  in udb_base_create_fd()
201 		(char*)udb->glob_data+sizeof(*udb->glob_data)));  in udb_base_create_fd()
202 	if(!udb->alloc) {  in udb_base_create_fd()
204 		udb_base_free(udb);  in udb_base_create_fd()
209 		udb_alloc_compact(udb, udb->alloc);  in udb_base_create_fd()
210 		udb_base_sync(udb, 1);  in udb_base_create_fd()
212 	udb->glob_data->clean_close = 0;  in udb_base_create_fd()
214 	return udb;  in udb_base_create_fd()
300 udb_base_shrink(udb_base* udb, uint64_t nsize)  in udb_base_shrink()  argument
302 	udb->glob_data->dirty_alloc = udb_dirty_fsize;  in udb_base_shrink()
303 	udb->glob_data->fsize = nsize;  in udb_base_shrink()
307 	msync(udb->base, udb->base_size, MS_ASYNC);  in udb_base_shrink()
309 	if(ftruncate(udb->fd, (off_t)nsize) != 0) {  in udb_base_shrink()
310 		log_msg(LOG_ERR, "%s: ftruncate(%u) %s", udb->fname,  in udb_base_shrink()
313 	udb->glob_data->dirty_alloc = udb_dirty_clean;  in udb_base_shrink()
316 void udb_base_close(udb_base* udb)  in udb_base_close()  argument
318 	if(!udb)  in udb_base_close()
320 	if(udb->fd != -1 && udb->base && udb->alloc) {  in udb_base_close()
321 		uint64_t nsize = udb->alloc->disk->nextgrow;  in udb_base_close()
322 		if(nsize < udb->base_size)  in udb_base_close()
323 			udb_base_shrink(udb, nsize);  in udb_base_close()
325 	if(udb->fd != -1) {  in udb_base_close()
326 		udb->glob_data->clean_close = 1;  in udb_base_close()
327 		close(udb->fd);  in udb_base_close()
328 		udb->fd = -1;  in udb_base_close()
330 	if(udb->base) {  in udb_base_close()
332 		if(munmap(udb->base, udb->base_size) == -1) {  in udb_base_close()
336 		udb->base = NULL;  in udb_base_close()
340 void udb_base_free(udb_base* udb)  in udb_base_free()  argument
342 	if(!udb)  in udb_base_free()
344 	udb_base_close(udb);  in udb_base_free()
345 	udb_alloc_delete(udb->alloc);  in udb_base_free()
346 	free(udb->ram_hash);  in udb_base_free()
347 	free(udb->fname);  in udb_base_free()
348 	free(udb);  in udb_base_free()
351 void udb_base_free_keep_mmap(udb_base* udb)  in udb_base_free_keep_mmap()  argument
353 	if(!udb) return;  in udb_base_free_keep_mmap()
354 	if(udb->fd != -1) {  in udb_base_free_keep_mmap()
355 		close(udb->fd);  in udb_base_free_keep_mmap()
356 		udb->fd = -1;  in udb_base_free_keep_mmap()
358 	udb->base = NULL;  in udb_base_free_keep_mmap()
359 	udb_alloc_delete(udb->alloc);  in udb_base_free_keep_mmap()
360 	free(udb->ram_hash);  in udb_base_free_keep_mmap()
361 	free(udb->fname);  in udb_base_free_keep_mmap()
362 	free(udb);  in udb_base_free_keep_mmap()
365 void udb_base_sync(udb_base* udb, int wait)  in udb_base_sync()  argument
367 	if(!udb) return;  in udb_base_sync()
369 	if(msync(udb->base, udb->base_size, wait?MS_SYNC:MS_ASYNC) != 0) {  in udb_base_sync()
371 			udb->fname, strerror(errno));  in udb_base_sync()
389 int udb_ptr_is_on_bucket(udb_base* udb, udb_ptr* ptr, udb_void to)  in udb_ptr_is_on_bucket()  argument
391 	uint32_t i = chunk_hash_ptr(to) & udb->ram_mask;  in udb_ptr_is_on_bucket()
393 	assert((size_t)i < udb->ram_size);  in udb_ptr_is_on_bucket()
394 	for(p = udb->ram_hash[i]; p; p=p->next) {  in udb_ptr_is_on_bucket()
403 grow_ram_hash(udb_base* udb, udb_ptr** newhash)  in grow_ram_hash()  argument
406 	size_t osize= udb->ram_size;  in grow_ram_hash()
408 	udb_ptr** oldhash = udb->ram_hash;  in grow_ram_hash()
409 	udb->ram_size *= 2;  in grow_ram_hash()
410 	udb->ram_mask <<= 1;  in grow_ram_hash()
411 	udb->ram_mask |= 1;  in grow_ram_hash()
412 	udb->ram_hash = newhash;  in grow_ram_hash()
420 			p->next=newhash[chunk_hash_ptr(p->data)&udb->ram_mask];  in grow_ram_hash()
429 void udb_base_link_ptr(udb_base* udb, udb_ptr* ptr)  in udb_base_link_ptr()  argument
433 	assert(udb_valid_dataptr(udb, ptr->data)); /* must be to whole chunk*/  in udb_base_link_ptr()
435 	udb->ram_num++;  in udb_base_link_ptr()
436 	if(udb->ram_num == udb->ram_size && udb->ram_size<(size_t)0x7fffffff) {  in udb_base_link_ptr()
439 			sizeof(udb_ptr*), udb->ram_size*2);  in udb_base_link_ptr()
441 			grow_ram_hash(udb, newram);  in udb_base_link_ptr()
444 	i = chunk_hash_ptr(ptr->data) & udb->ram_mask;  in udb_base_link_ptr()
445 	assert((size_t)i < udb->ram_size);  in udb_base_link_ptr()
448 	ptr->next = udb->ram_hash[i];  in udb_base_link_ptr()
449 	udb->ram_hash[i] = ptr;  in udb_base_link_ptr()
454 void udb_base_unlink_ptr(udb_base* udb, udb_ptr* ptr)  in udb_base_unlink_ptr()  argument
458 	assert(udb_valid_dataptr(udb, ptr->data)); /* ptr must be inited */  in udb_base_unlink_ptr()
459 	assert(udb_ptr_is_on_bucket(udb, ptr, ptr->data));  in udb_base_unlink_ptr()
461 	udb->ram_num--;  in udb_base_unlink_ptr()
467 		uint32_t i = chunk_hash_ptr(ptr->data) & udb->ram_mask;  in udb_base_unlink_ptr()
468 		assert((size_t)i < udb->ram_size);  in udb_base_unlink_ptr()
469 		udb->ram_hash[i] = ptr->next;  in udb_base_unlink_ptr()
475 udb_base_ram_ptr_edit(udb_base* udb, udb_void old, udb_void newd)  in udb_base_ram_ptr_edit()  argument
477 	uint32_t io = chunk_hash_ptr(old) & udb->ram_mask;  in udb_base_ram_ptr_edit()
480 	p = udb->ram_hash[io];  in udb_base_ram_ptr_edit()
484 			udb_base_unlink_ptr(udb, p);  in udb_base_ram_ptr_edit()
486 			udb_base_link_ptr(udb, p);  in udb_base_ram_ptr_edit()
492 udb_rel_ptr* udb_base_get_userdata(udb_base* udb)  in udb_base_get_userdata()  argument
494 	return &udb->glob_data->user_global;  in udb_base_get_userdata()
497 void udb_base_set_userdata(udb_base* udb, udb_void user)  in udb_base_set_userdata()  argument
500 	if(user) { assert(udb_valid_dataptr(udb, user)); }  in udb_base_set_userdata()
502 	udb_rel_ptr_set(udb->base, &udb->glob_data->user_global, user);  in udb_base_set_userdata()
505 void udb_base_set_userflags(udb_base* udb, uint8_t v)  in udb_base_set_userflags()  argument
507 	udb->glob_data->userflags = v;  in udb_base_set_userflags()
510 uint8_t udb_base_get_userflags(udb_base* udb)  in udb_base_get_userflags()  argument
512 	return udb->glob_data->userflags;  in udb_base_get_userflags()
517 udb_base_remap(udb_base* udb, udb_alloc* alloc, uint64_t nsize)  in udb_base_remap()  argument
523 	nb = mremap(udb->base, udb->base_size, nsize, MREMAP_MAYMOVE);  in udb_base_remap()
526 			udb->fname, (unsigned)nsize, strerror(errno));  in udb_base_remap()
531 	if(munmap(udb->base, udb->base_size) != 0) {  in udb_base_remap()
533 			udb->fname, strerror(errno));  in udb_base_remap()
538 	nb = mmap(udb->base, (size_t)nsize, (int)PROT_READ|PROT_WRITE,  in udb_base_remap()
539 		(int)MAP_SHARED, (int)udb->fd, (off_t)0);  in udb_base_remap()
545 			(int)MAP_SHARED, (int)udb->fd, (off_t)0);  in udb_base_remap()
549 			udb->fname, (unsigned)nsize, strerror(errno));  in udb_base_remap()
550 		udb->base = NULL;  in udb_base_remap()
554 	if(nb != udb->base) {  in udb_base_remap()
557 		udb->base = nb;  in udb_base_remap()
558 		udb->glob_data = (udb_glob_d*)((char*)nb+sizeof(uint64_t));  in udb_base_remap()
561 		alloc->disk = (udb_alloc_d*)((char*)udb->glob_data  in udb_base_remap()
562 			+sizeof(*udb->glob_data));  in udb_base_remap()
564 	udb->base_size = nsize;  in udb_base_remap()
567 	(void)udb; (void)alloc; (void)nsize;  in udb_base_remap()
573 udb_base_remap_process(udb_base* udb)  in udb_base_remap_process()  argument
576 	udb_base_remap(udb, udb->alloc, udb->glob_data->fsize);  in udb_base_remap_process()
581 udb_base_grow_and_remap(udb_base* udb, uint64_t nsize)  argument
589 	udb->glob_data->dirty_alloc = udb_dirty_fsize;
591 	if((w=pwrite(udb->fd, &z, sizeof(z), (off_t)(nsize-1))) == -1) {
593 	if(lseek(udb->fd, (off_t)(nsize-1), SEEK_SET) == -1) {
594 		log_msg(LOG_ERR, "fseek %s: %s", udb->fname, strerror(errno));
597 	if((w=write(udb->fd, &z, sizeof(z))) == -1) {
600 			udb->fname, (unsigned)nsize, strerror(errno));
604 			udb->fname, (unsigned)nsize);
607 	udb->glob_data->fsize = nsize;
608 	udb->glob_data->dirty_alloc = udb_dirty_clean;
609 	return udb_base_remap(udb, udb->alloc, nsize);
670 fsck_fsize(udb_base* udb, udb_alloc* alloc)  argument
673 	log_msg(LOG_WARNING, "udb-fsck %s: file size wrong", udb->fname);
674 	realsize = lseek(udb->fd, (off_t)0, SEEK_END);
676 		log_msg(LOG_ERR, "lseek(%s): %s", udb->fname, strerror(errno));
679 	udb->glob_data->fsize = (uint64_t)realsize;
680 	if(!udb_base_remap(udb, alloc, (uint64_t)realsize))
682 	udb->glob_data->dirty_alloc = udb_dirty_clean;
683 	log_msg(LOG_WARNING, "udb-fsck %s: file size fixed (sync)", udb->fname);
684 	udb_base_sync(udb, 1);
758 regen_its_ptrs(void* base, udb_base* udb, udb_chunk_d* atp,  argument
765 	(*udb->walkfunc)(base, udb->walkarg, atp->type, data, dsz, 
772 regen_ptrlist(void* base, udb_base* udb, udb_alloc* alloc,  argument
775 	udb_void at = alloc->udb->glob_data->hsize;
791 	at = alloc->udb->glob_data->hsize;
800 			regen_its_ptrs(base, udb, atp,
809 			regen_its_ptrs(base, udb, atp,
835 fsck_rb_xl(void* base, udb_base* udb, udb_void rb_old, udb_void rb_new,  argument
855 		move_xl_segment(base, udb, rb_old, rb_new, rb_size, rb_seg);
886 fsck_file(udb_base* udb, udb_alloc* alloc, int moved)  argument
888 	void* base = udb->base;
890 	udb_void at = udb->glob_data->hsize;
891 	udb_void rb_old = udb->glob_data->rb_old;
892 	udb_void rb_new = udb->glob_data->rb_new;
893 	udb_void rb_seg = udb->glob_data->rb_seg;
895 	uint64_t rb_size = udb->glob_data->rb_size;
896 	log_msg(LOG_WARNING, "udb-fsck %s: salvaging", udb->fname);
906 				if(!fsck_rb_xl(base, udb, rb_old, rb_new,
948 	regen_ptrlist(base, udb, alloc, rb_old, rb_new);
951 		udb->fname);
952 	udb->glob_data->rb_old = 0;
953 	udb->glob_data->rb_new = 0;
954 	udb->glob_data->rb_size = 0;
955 	udb->glob_data->dirty_alloc = udb_dirty_clean;
956 	udb_base_sync(udb, 1);
961 udb_alloc* udb_alloc_create(udb_base* udb, udb_alloc_d* disk)  argument
966 	alloc->udb = udb;
970 	if(udb->glob_data->dirty_alloc != udb_dirty_clean) {
971 		if(udb->glob_data->dirty_alloc == udb_dirty_fsize) {
972 			if(fsck_fsize(udb, alloc))
974 		} else if(udb->glob_data->dirty_alloc == udb_dirty_fl) {
975 			if(fsck_file(udb, alloc, 0))
977 		} else if(udb->glob_data->dirty_alloc == udb_dirty_compact) {
978 			if(fsck_file(udb, alloc, 1))
982 			(int)udb->glob_data->dirty_alloc);
1076 		assert(fn <= alloc->udb->base_size);
1090 	alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1106 	assert(alloc->disk->nextgrow <= alloc->udb->base_size);
1107 	alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1135 	uint64_t bsz = alloc->udb->base_size;
1156 	if(alloc->udb->base_size <= 2*1024*1024) {
1159 		if(((size_t)alloc->disk->nextgrow)*3 <= alloc->udb->base_size)
1164 		uint64_t space = alloc->udb->base_size - alloc->disk->nextgrow;
1165 		if(space >= 1024*1024 && (space*4 >= alloc->udb->base_size
1166 			|| alloc->udb->base_size < 4*1024*1024))
1184 	assert(alloc->udb->base_size >= alloc->disk->nextgrow);
1185 	if(grow_end <= alloc->udb->base_size) {
1193 	if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) {
1197 	assert(grow_end <= alloc->udb->base_size);
1198 	assert(alloc->udb->glob_data->fsize == alloc->udb->base_size);
1208 	alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1231 	alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1244 	if(grow_end <= alloc->udb->base_size) {
1250 	if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) {
1254 	assert(grow_end <= alloc->udb->base_size);
1255 	assert(alloc->udb->glob_data->fsize == alloc->udb->base_size);
1296 	void* base = alloc->udb->base;
1305 		alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1316 		alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1323 			alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1341 			alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1386 chunk_fix_ptrs(void* base, udb_base* udb, udb_chunk_d* cp, udb_void data,  argument
1392 	(*udb->walkfunc)(base, udb->walkarg, cp->type, UDB_REL(base, data),
1395 	udb_base_ram_ptr_edit(udb, olddata, data);
1412 	alloc->udb->glob_data->rb_old = f;
1413 	alloc->udb->glob_data->rb_new = res;
1414 	alloc->udb->glob_data->rb_size = esz;
1421 	chunk_fix_ptrs(base, alloc->udb, rp, res+sizeof(udb_chunk_d),
1444 move_xl_segment(void* base, udb_base* udb, udb_void xl, udb_void n,  argument
1453 	udb->glob_data->rb_old = xl;
1454 	udb->glob_data->rb_new = n;
1455 	udb->glob_data->rb_size = sz;
1464 			udb->glob_data->rb_seg = seg;
1487 		move_xl_segment(base, alloc->udb, xl, n, sz, 0);
1488 		chunk_fix_ptrs(base, alloc->udb, UDB_CHUNK(n),
1495 	alloc->udb->glob_data->rb_old = 0;
1496 	alloc->udb->glob_data->rb_new = 0;
1497 	alloc->udb->glob_data->rb_size = 0;
1508 	if(other >= alloc->udb->base_size)
1512 	if(other < alloc->udb->glob_data->hsize)
1569 	if(alloc->udb->inhibit_compact)
1571 	alloc->udb->useful_compact = 0;
1572 	while(at > alloc->udb->glob_data->hsize) {
1595 				alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1598 				alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1616 				alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1620 				alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1627 			alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1637 			alloc->udb->glob_data->rb_old = 0;
1638 			alloc->udb->glob_data->rb_new = 0;
1639 			alloc->udb->glob_data->rb_size = 0;
1640 			alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1672 			alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1675 			alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1682 		udb_base_shrink(alloc->udb, nsize);
1683 		if(!udb_base_remap(alloc->udb, alloc, nsize))
1690 udb_compact(udb_base* udb)  argument
1692 	if(!udb) return 1;
1693 	if(!udb->useful_compact) return 1;
1695 	return udb_alloc_compact(udb->base, udb->alloc);
1698 void udb_compact_inhibited(udb_base* udb, int inhibit)  argument
1700 	if(!udb) return;
1701 	udb->inhibit_compact = inhibit;
1728 	(*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type,
1732 	alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1746 	alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1763 	base = alloc->udb->base;
1780 		if(alloc->udb->inhibit_compact) {
1781 			alloc->udb->useful_compact = 1;
1794 	(*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type,
1799 	alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1825 	alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1827 	if(alloc->udb->inhibit_compact) {
1828 		alloc->udb->useful_compact = 1;
1839 	memcpy(UDB_REL(alloc->udb->base, r), d, sz);
1845 	void* base = alloc->udb->base;
1873 	base = alloc->udb->base;
1880 	chunk_fix_ptrs(base, alloc->udb, np, newd, osz, r);
1898 	assert(want >= alloc->udb->base_size);
1899 	if(!udb_base_grow_and_remap(alloc->udb, want)) {
1908 	void* base = alloc->udb->base;
1917 int udb_valid_offset(udb_base* udb, udb_void to, size_t destsize)  argument
1921 	return ( (to+destsize) <= udb->base_size &&
1922 		to >= (udb->glob_data->hsize-2*sizeof(udb_rel_ptr)) &&
1923 		(to+destsize) <= udb->alloc->disk->nextgrow);
1926 int udb_valid_dataptr(udb_base* udb, udb_void to)  argument
1928 	void* base = udb->base;
1933 	if(!udb_valid_offset(udb, to, sizeof(uint64_t)))
1937 	if(!udb_valid_offset(udb, ch, sizeof(udb_chunk_d)))
1944 		if(!udb_valid_offset(udb, ch, sizeof(udb_xl_chunk_d)))
1947 		if(!udb_valid_offset(udb, ch+xlsz-1, 1))
1960 	if(!udb_valid_offset(udb, ch+esz-1, 1))
1967 int udb_valid_rptr(udb_base* udb, udb_void rptr, udb_void to)  argument
1969 	void* base = udb->base;
1971 	if(!udb_valid_offset(udb, rptr, sizeof(udb_rel_ptr)))
1973 	if(!udb_valid_dataptr(udb, to))
1977 		if(!udb_valid_offset(udb, p, sizeof(udb_rel_ptr)))
2037 udb_check_ptrs_valid(udb_base* udb)  argument
2041 	for(i=0; i<udb->ram_size; i++) {
2043 		for(p=udb->ram_hash[i]; p; p=p->next) {
2045 			assert((size_t)(chunk_hash_ptr(p->data)&udb->ram_mask)
2047 			assert(p->base == &udb->base);
2054 void udb_ptr_init(udb_ptr* ptr, udb_base* udb)  argument
2057 	udb_check_ptrs_valid(udb); /* previous ptrs have been unlinked */
2060 	ptr->base = &udb->base;
2063 void udb_ptr_set(udb_ptr* ptr, udb_base* udb, udb_void newval)  argument
2067 		udb_base_unlink_ptr(udb, ptr);
2070 		udb_base_link_ptr(udb, ptr);
2073 int udb_ptr_alloc_space(udb_ptr* ptr, udb_base* udb, udb_chunk_type type,  argument
2077 	r = udb_alloc_space(udb->alloc, sz);
2079 	udb_alloc_set_type(udb->alloc, r, type);
2080 	udb_ptr_init(ptr, udb);
2081 	udb_ptr_set(ptr, udb, r);
2085 void udb_ptr_free_space(udb_ptr* ptr, udb_base* udb, size_t sz)  argument
2089 		udb_ptr_set(ptr, udb, 0);
2090 		udb_alloc_free(udb->alloc, d, sz);