disklabel64 UFS+HAMMER boot support (was previously just HAMMER boot support)
[dragonfly.git] / lib / libstand / hammerread.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Simon Schubert <corecode@fs.ei.tum.de>
6  * and Matthew Dillon <dillon@backplane.com>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  *
35  * $DragonFly: src/lib/libstand/hammerread.c,v 1.2 2008/10/29 22:14:25 swildner Exp $
36  */
37
38 /*
39  * This file is being used by boot2 and libstand (loader).
40  * Compile with -DTESTING to obtain a binary.
41  */
42
43
44 #if !defined(BOOT2) && !defined(TESTING)
45 #define LIBSTAND        1
46 #endif
47
48 #ifdef BOOT2
49 #include "boot2.h"
50 #else
51 #include <sys/param.h>
52 #include <stddef.h>
53 #include <stdint.h>
54 #endif
55
56 #ifdef TESTING
57 #include <sys/fcntl.h>
58 #include <sys/stat.h>
59 #include <unistd.h>
60 #include <err.h>
61 #include <stdio.h>
62 #include <stdlib.h>
63 #include <string.h>
64 #include <errno.h>
65 #include <dirent.h>
66 #endif
67
68 #ifdef LIBSTAND
69 #include "stand.h"
70 #endif
71
72 #include <vfs/hammer/hammer_disk.h>
73
74 #ifndef BOOT2
75 struct blockentry {
76         hammer_off_t    off;
77         int             use;
78         char            *data;
79 };
80
81 #ifdef TESTING
82 #define NUMCACHE        16
83 #else
84 #define NUMCACHE        6
85 #endif
86
87 struct hfs {
88 #ifdef TESTING
89         int             fd;
90 #else   // libstand
91         struct open_file *f;
92 #endif
93         hammer_off_t    root;
94         int64_t         buf_beg;
95         int             lru;
96         struct blockentry cache[NUMCACHE];
97 };
98
99 static void *
100 hread(struct hfs *hfs, hammer_off_t off)
101 {
102         hammer_off_t boff = off & ~HAMMER_BUFMASK64;
103
104         boff &= HAMMER_OFF_LONG_MASK;
105
106         if (HAMMER_ZONE_DECODE(off) != HAMMER_ZONE_RAW_VOLUME_INDEX)
107                 boff += hfs->buf_beg;
108
109         struct blockentry *be = NULL;
110         for (int i = 0; i < NUMCACHE; i++) {
111                 if (be == NULL || be->use > hfs->cache[i].use)
112                         be = &hfs->cache[i];
113                 if (hfs->cache[i].off == boff) {
114                         be = &hfs->cache[i];
115                         break;
116                 }
117         }
118         if (be->off != boff) {
119                 // Didn't find any match
120                 be->off = boff;
121 #ifdef TESTING
122                 ssize_t res = pread(hfs->fd, be->data, HAMMER_BUFSIZE,
123                                     boff & HAMMER_OFF_SHORT_MASK);
124                 if (res != HAMMER_BUFSIZE)
125                         err(1, "short read on off %llx", boff);
126 #else   // libstand
127                 size_t rlen;
128                 int rv = hfs->f->f_dev->dv_strategy(hfs->f->f_devdata, F_READ,
129                         boff >> DEV_BSHIFT, HAMMER_BUFSIZE,
130                         be->data, &rlen);
131                 if (rv || rlen != HAMMER_BUFSIZE)
132                         return (NULL);
133 #endif
134         }
135
136         be->use = ++hfs->lru;
137         return &be->data[off & HAMMER_BUFMASK];
138 }
139
140 #else   /* BOOT2 */
141
142 struct hammer_dmadat {
143         struct boot2_dmadat boot2;
144         char            buf[HAMMER_BUFSIZE];
145 };
146
147 #define fsdmadat        ((struct hammer_dmadat *)boot2_dmadat)
148
149 struct hfs {
150         hammer_off_t    root;
151         int64_t         buf_beg;
152 };
153
154 static void *
155 hread(struct hfs *hfs, hammer_off_t off)
156 {
157         char *buf = fsdmadat->buf;
158
159         hammer_off_t boff = off & ~HAMMER_BUFMASK64;
160         boff &= HAMMER_OFF_LONG_MASK;
161         if (HAMMER_ZONE_DECODE(off) != HAMMER_ZONE_RAW_VOLUME_INDEX)
162                 boff += hfs->buf_beg;
163         boff &= HAMMER_OFF_SHORT_MASK;
164         boff >>= DEV_BSHIFT;
165         if (dskread(buf, boff, HAMMER_BUFSIZE >> DEV_BSHIFT))
166                 return (NULL);
167         return (&buf[off & HAMMER_BUFMASK]);
168 }
169
170 static void
171 bzero(void *buf, size_t size)
172 {
173         for (size_t i = 0; i < size; i++)
174                 ((char *)buf)[i] = 0;
175 }
176
177 static void
178 bcopy(void *src, void *dst, size_t size)
179 {
180         memcpy(dst, src, size);
181 }
182
183 static size_t
184 strlen(const char *s)
185 {
186         size_t l = 0;
187         for (; *s != 0; s++)
188                 l++;
189         return (l);
190 }
191
192 static int
193 memcmp(const void *a, const void *b, size_t len)
194 {
195         for (size_t p = 0; p < len; p++) {
196                 int r = ((const char *)a)[p] - ((const char *)b)[p];
197                 if (r != 0)
198                         return (r);
199         }
200
201         return (0);
202 }
203
204 #endif
205
206 /*
207  * (from hammer_btree.c)
208  *
209  * Compare two B-Tree elements, return -N, 0, or +N (e.g. similar to strcmp).
210  *
211  * Note that for this particular function a return value of -1, 0, or +1
212  * can denote a match if create_tid is otherwise discounted.  A create_tid
213  * of zero is considered to be 'infinity' in comparisons.
214  *
215  * See also hammer_rec_rb_compare() and hammer_rec_cmp() in hammer_object.c.
216  */
217 static int
218 hammer_btree_cmp(hammer_base_elm_t key1, hammer_base_elm_t key2)
219 {
220         if (key1->localization < key2->localization)
221                 return(-5);
222         if (key1->localization > key2->localization)
223                 return(5);
224
225         if (key1->obj_id < key2->obj_id)
226                 return(-4);
227         if (key1->obj_id > key2->obj_id)
228                 return(4);
229
230         if (key1->rec_type < key2->rec_type)
231                 return(-3);
232         if (key1->rec_type > key2->rec_type)
233                 return(3);
234
235         if (key1->key < key2->key)
236                 return(-2);
237         if (key1->key > key2->key)
238                 return(2);
239
240         /*
241          * A create_tid of zero indicates a record which is undeletable
242          * and must be considered to have a value of positive infinity.
243          */
244         if (key1->create_tid == 0) {
245                 if (key2->create_tid == 0)
246                         return(0);
247                 return(1);
248         }
249         if (key2->create_tid == 0)
250                 return(-1);
251         if (key1->create_tid < key2->create_tid)
252                 return(-1);
253         if (key1->create_tid > key2->create_tid)
254                 return(1);
255         return(0);
256 }
257
258 /*
259  * Heuristical search for the first element whos comparison is <= 1.  May
260  * return an index whos compare result is > 1 but may only return an index
261  * whos compare result is <= 1 if it is the first element with that result.
262  */
263 static int
264 hammer_btree_search_node(hammer_base_elm_t elm, hammer_node_ondisk_t node)
265 {
266         int b;
267         int s;
268         int i;
269         int r;
270
271         /*
272          * Don't bother if the node does not have very many elements
273          */
274         b = 0;
275         s = node->count;
276         while (s - b > 4) {
277                 i = b + (s - b) / 2;
278                 r = hammer_btree_cmp(elm, &node->elms[i].leaf.base);
279                 if (r <= 1) {
280                         s = i;
281                 } else {
282                         b = i;
283                 }
284         }
285         return(b);
286 }
287
288 #if 0
289 /*
290  * (from hammer_subs.c)
291  *
292  * Return a namekey hash.   The 64 bit namekey hash consists of a 32 bit
293  * crc in the MSB and 0 in the LSB.  The caller will use the low bits to
294  * generate a unique key and will scan all entries with the same upper
295  * 32 bits when issuing a lookup.
296  *
297  * We strip bit 63 in order to provide a positive key, this way a seek
298  * offset of 0 will represent the base of the directory.
299  *
300  * This function can never return 0.  We use the MSB-0 space to synthesize
301  * artificial directory entries such as "." and "..".
302  */
303 static int64_t
304 hammer_directory_namekey(const void *name, int len)
305 {
306         int64_t key;
307
308         key = (int64_t)(crc32(name, len) & 0x7FFFFFFF) << 32;
309         if (key == 0)
310                 key |= 0x100000000LL;
311         return(key);
312 }
313 #else
314 static int64_t
315 hammer_directory_namekey(const void *name __unused, int len __unused)
316 {
317         return (0);
318 }
319 #endif
320
321
322 #ifndef BOOT2
323 /*
324  * Misc
325  */
326 static u_int32_t
327 hammer_to_unix_xid(uuid_t *uuid)
328 {
329         return(*(u_int32_t *)&uuid->node[2]);
330 }
331
332 static int
333 hammer_get_dtype(u_int8_t obj_type)
334 {
335         switch(obj_type) {
336         case HAMMER_OBJTYPE_DIRECTORY:
337                 return(DT_DIR);
338         case HAMMER_OBJTYPE_REGFILE:
339                 return(DT_REG);
340         case HAMMER_OBJTYPE_DBFILE:
341                 return(DT_DBF);
342         case HAMMER_OBJTYPE_FIFO:
343                 return(DT_FIFO);
344         case HAMMER_OBJTYPE_SOCKET:
345                 return(DT_SOCK);
346         case HAMMER_OBJTYPE_CDEV:
347                 return(DT_CHR);
348         case HAMMER_OBJTYPE_BDEV:
349                 return(DT_BLK);
350         case HAMMER_OBJTYPE_SOFTLINK:
351                 return(DT_LNK);
352         default:
353                 return(DT_UNKNOWN);
354         }
355         /* not reached */
356 }
357
358 static int
359 hammer_get_mode(u_int8_t obj_type)
360 {
361         switch(obj_type) {
362         case HAMMER_OBJTYPE_DIRECTORY:
363                 return(S_IFDIR);
364         case HAMMER_OBJTYPE_REGFILE:
365                 return(S_IFREG);
366         case HAMMER_OBJTYPE_DBFILE:
367                 return(S_IFDB);
368         case HAMMER_OBJTYPE_FIFO:
369                 return(S_IFIFO);
370         case HAMMER_OBJTYPE_SOCKET:
371                 return(S_IFSOCK);
372         case HAMMER_OBJTYPE_CDEV:
373                 return(S_IFCHR);
374         case HAMMER_OBJTYPE_BDEV:
375                 return(S_IFBLK);
376         case HAMMER_OBJTYPE_SOFTLINK:
377                 return(S_IFLNK);
378         default:
379                 return(0);
380         }
381         /* not reached */
382 }
383
384 #if DEBUG > 1
385 static void
386 hprintb(hammer_base_elm_t e)
387 {
388         printf("%d/", e->localization);
389         if (e->obj_id >> 32 != 0)
390                 printf("%lx%08lx",
391                        (long)(e->obj_id >> 32),
392                        (long)(e->obj_id & 0xffffffff));
393         else
394                 printf("%lx", (long)e->obj_id);
395         printf("/%d/", e->rec_type);
396         if (e->key >> 32 != 0)
397                 printf("%lx%08lx",
398                        (long)(e->key >> 32),
399                        (long)(e->key & 0xffffffff));
400         else
401                 printf("%lx", (long)e->key);
402 #ifdef TESTING
403         printf("/%llx/%llx", e->create_tid, e->delete_tid);
404 #endif
405 }
406 #endif /* DEBUG > 1 */
407 #endif /* !BOOT2 */
408
409 static hammer_btree_leaf_elm_t
410 hfind(struct hfs *hfs, hammer_base_elm_t key, hammer_base_elm_t end)
411 {
412 #if DEBUG > 1
413         printf("searching for ");
414         hprintb(key);
415         printf(" end ");
416         hprintb(end);
417         printf("\n");
418 #endif
419
420         int n;
421         int r;
422         struct hammer_base_elm search = *key;
423         struct hammer_base_elm backtrack;
424         hammer_off_t nodeoff = hfs->root;
425         hammer_node_ondisk_t node;
426         hammer_btree_elm_t e = NULL;
427         int internal;
428
429 loop:
430         node = hread(hfs, nodeoff);
431         if (node == NULL)
432                 return (NULL);
433         internal = node->type == HAMMER_BTREE_TYPE_INTERNAL;
434
435 #if DEBUG > 3
436         for (int i = 0; i < node->count; i++) {
437                 printf("E: ");
438                 hprintb(&node->elms[i].base);
439                 printf("\n");
440         }
441         if (internal) {
442                 printf("B: ");
443                 hprintb(&node->elms[node->count].base);
444                 printf("\n");
445         }
446 #endif
447
448         n = hammer_btree_search_node(&search, node);
449
450         // In internal nodes, we cover the right boundary as well.
451         // If we hit it, we'll backtrack.
452         for (; n < node->count + internal; n++) {
453                 e = &node->elms[n];
454                 r = hammer_btree_cmp(&search, &e->base);
455
456                 if (r < 0)
457                         break;
458         }
459
460         // unless we stopped right on the left side, we need to back off a bit
461         if (n > 0)
462                 e = &node->elms[--n];
463
464 #if DEBUG > 2
465         printf("  found: ");
466         hprintb(&e->base);
467         printf("\n");
468 #endif
469
470         if (internal) {
471                 // If we hit the right boundary, backtrack to
472                 // the next higher level.
473                 if (n == node->count)
474                         goto backtrack;
475                 nodeoff = e->internal.subtree_offset;
476                 backtrack = (e+1)->base;
477                 goto loop;
478         }
479
480         r = hammer_btree_cmp(key, &e->base);
481         // If we're more off than the createtid, take the next elem
482         if (r > 1) {
483                 e++;
484                 n++;
485         }
486
487         // Skip deleted elements
488         while (n < node->count && e->base.delete_tid != 0) {
489                 e++;
490                 n++;
491         }
492
493         // In the unfortunate event when there is no next
494         // element in this node, we repeat the search with
495         // a key beyond the right boundary
496         if (n == node->count) {
497 backtrack:
498                 search = backtrack;
499                 nodeoff = hfs->root;
500
501 #if DEBUG > 2
502                 printf("hit right boundary (%d), resetting search to ",
503                        node->count);
504                 hprintb(&search);
505                 printf("\n");
506 #endif
507                 goto loop;
508         }
509
510 #if DEBUG > 1
511         printf("  result: ");
512         hprintb(&e->base);
513         printf("\n");
514 #endif
515
516         if (end != NULL)
517                 if (hammer_btree_cmp(end, &e->base) < -1)
518                         goto fail;
519
520         return (&e->leaf);
521
522 fail:
523 #if DEBUG > 1
524         printf("  fail.\n");
525 #endif
526         return (NULL);
527 }
528
529 #ifndef BOOT2
530 static int
531 hreaddir(struct hfs *hfs, ino_t ino, int64_t *off, struct dirent *de)
532 {
533         struct hammer_base_elm key, end;
534
535 #if DEBUG > 2
536         printf("%s(%llx, %lld)\n", __FUNCTION__, (long long)ino, *off);
537 #endif
538
539         bzero(&key, sizeof(key));
540         key.obj_id = ino;
541         key.localization = HAMMER_LOCALIZE_MISC;
542         key.rec_type = HAMMER_RECTYPE_DIRENTRY;
543         key.key = *off;
544
545         end = key;
546         end.key = HAMMER_MAX_KEY;
547
548         hammer_btree_leaf_elm_t e;
549
550         e = hfind(hfs, &key, &end);
551         if (e == NULL) {
552                 errno = ENOENT;
553                 return (-1);
554         }
555
556         *off = e->base.key + 1;         // remember next pos
557
558         de->d_namlen = e->data_len - HAMMER_ENTRY_NAME_OFF;
559         de->d_type = hammer_get_dtype(e->base.obj_type);
560         hammer_data_ondisk_t ed = hread(hfs, e->data_offset);
561         if (ed == NULL)
562                 return (-1);
563         de->d_ino = ed->entry.obj_id;
564         bcopy(ed->entry.name, de->d_name, de->d_namlen);
565         de->d_name[de->d_namlen] = 0;
566
567         return (0);
568 }
569 #endif
570
571 static ino_t
572 hresolve(struct hfs *hfs, ino_t dirino, const char *name)
573 {
574         struct hammer_base_elm key, end;
575         size_t namel = strlen(name);
576
577 #if DEBUG > 2
578         printf("%s(%llx, %s)\n", __FUNCTION__, (long long)dirino, name);
579 #endif
580
581         bzero(&key, sizeof(key));
582         key.obj_id = dirino;
583         key.localization = HAMMER_LOCALIZE_MISC;
584         key.key = hammer_directory_namekey(name, namel);
585         key.rec_type = HAMMER_RECTYPE_DIRENTRY;
586         end = key;
587         end.key = HAMMER_MAX_KEY;
588
589         hammer_btree_leaf_elm_t e;
590         while ((e = hfind(hfs, &key, &end)) != NULL) {
591                 key.key = e->base.key + 1;
592
593                 size_t elen = e->data_len - HAMMER_ENTRY_NAME_OFF;
594                 hammer_data_ondisk_t ed = hread(hfs, e->data_offset);
595                 if (ed == NULL)
596                         return (-1);
597 #ifdef BOOT2
598                 if (ls) {
599                         for (int i = 0; i < elen; i++)
600                                 putchar(ed->entry.name[i]);
601                         putchar(' ');
602                         ls = 2;
603                         continue;
604                 }
605 #endif
606                 if (elen == namel && memcmp(ed->entry.name, name, MIN(elen, namel)) == 0)
607                         return (ed->entry.obj_id);
608         }
609
610 #if BOOT2
611         if (ls == 2)
612                 printf("\n");
613 #endif
614
615         return -1;
616 }
617
618 static ino_t
619 hlookup(struct hfs *hfs, const char *path)
620 {
621 #if DEBUG > 2
622         printf("%s(%s)\n", __FUNCTION__, path);
623 #endif
624
625 #ifdef BOOT2
626         ls = 0;
627 #endif
628         ino_t ino = 1;
629         do {
630                 char name[MAXPATHLEN + 1];
631                 while (*path == '/')
632                         path++;
633                 if (*path == 0)
634                         break;
635                 for (char *n = name; *path != 0 && *path != '/'; path++, n++) {
636                         n[0] = *path;
637                         n[1] = 0;
638                 }
639
640 #ifdef BOOT2
641                 // A single ? means "list"
642                 if (name[0] == '?' && name[1] == 0)
643                         ls = 1;
644 #endif
645
646                 ino = hresolve(hfs, ino, name);
647         } while (ino != (ino_t)-1 && *path != 0);
648
649         return (ino);
650 }
651
652
653 #ifndef BOOT2
654 static int
655 hstat(struct hfs *hfs, ino_t ino, struct stat* st)
656 {
657         struct hammer_base_elm key;
658
659 #if DEBUG > 2
660         printf("%s(%llx)\n", __FUNCTION__, (long long)ino);
661 #endif
662
663         bzero(&key, sizeof(key));
664         key.obj_id = ino;
665         key.localization = HAMMER_LOCALIZE_INODE;
666         key.rec_type = HAMMER_RECTYPE_INODE;
667
668         hammer_btree_leaf_elm_t e = hfind(hfs, &key, &key);
669         if (e == NULL) {
670 #ifndef BOOT2
671                 errno = ENOENT;
672 #endif
673                 return -1;
674         }
675
676         hammer_data_ondisk_t ed = hread(hfs, e->data_offset);
677         if (ed == NULL)
678                 return (-1);
679
680         st->st_mode = ed->inode.mode | hammer_get_mode(ed->inode.obj_type);
681         st->st_uid = hammer_to_unix_xid(&ed->inode.uid);
682         st->st_gid = hammer_to_unix_xid(&ed->inode.gid);
683         st->st_size = ed->inode.size;
684
685         return (0);
686 }
687 #endif
688
689 static ssize_t
690 hreadf(struct hfs *hfs, ino_t ino, int64_t off, int64_t len, char *buf)
691 {
692         int64_t startoff = off;
693         struct hammer_base_elm key, end;
694
695         bzero(&key, sizeof(key));
696         key.obj_id = ino;
697         key.localization = HAMMER_LOCALIZE_MISC;
698         key.rec_type = HAMMER_RECTYPE_DATA;
699         end = key;
700         end.key = HAMMER_MAX_KEY;
701
702         while (len > 0) {
703                 key.key = off + 1;
704                 hammer_btree_leaf_elm_t e = hfind(hfs, &key, &end);
705                 int64_t dlen;
706
707                 if (e == NULL || off > e->base.key) {
708                         bzero(buf, len);
709                         off += len;
710                         len = 0;
711                         break;
712                 }
713
714                 int64_t doff = e->base.key - e->data_len;
715                 if (off < doff) {
716                         // sparse file, beginning
717                         dlen = doff - off;
718                         dlen = MIN(dlen, len);
719                         bzero(buf, dlen);
720                 } else {
721                         int64_t boff = off - doff;
722                         hammer_off_t roff = e->data_offset;
723
724                         dlen = e->data_len;
725                         dlen -= boff;
726                         dlen = MIN(dlen, len);
727
728                         while (boff >= HAMMER_BUFSIZE) {
729                                 boff -= HAMMER_BUFSIZE;
730                                 roff += HAMMER_BUFSIZE;
731                         }
732
733                         /*
734                          * boff - relative offset in disk buffer (not aligned)
735                          * roff - base offset of disk buffer     (not aligned)
736                          * dlen - amount of data we think we can copy
737                          *
738                          * hread only reads 16K aligned buffers, check for
739                          * a length overflow and truncate dlen appropriately.
740                          */
741                         if ((roff & ~HAMMER_BUFMASK64) != ((roff + boff + dlen - 1) & ~HAMMER_BUFMASK64))
742                                 dlen = HAMMER_BUFSIZE - ((boff + roff) & HAMMER_BUFMASK);
743                         char *data = hread(hfs, roff);
744                         if (data == NULL)
745                                 return (-1);
746                         bcopy(data + boff, buf, dlen);
747                 }
748
749                 buf += dlen;
750                 off += dlen;
751                 len -= dlen;
752         }
753
754         return (off - startoff);
755 }
756
757 #ifdef BOOT2
758 struct hfs hfs;
759
760 static int
761 boot2_hammer_init(void)
762 {
763         hammer_volume_ondisk_t volhead;
764
765         volhead = hread(&hfs, HAMMER_ZONE_ENCODE(1, 0));
766         if (volhead == NULL)
767                 return (-1);
768         if (volhead->vol_signature != HAMMER_FSBUF_VOLUME)
769                 return (-1);
770         hfs.root = volhead->vol0_btree_root;
771         hfs.buf_beg = volhead->vol_buf_beg;
772         return (0);
773 }
774
775 static boot2_ino_t
776 boot2_hammer_lookup(const char *path)
777 {
778         ino_t ino = hlookup(&hfs, path);
779
780         if (ino == -1)
781                 ino = 0;
782
783         fs_off = 0;
784
785         return (ino);
786 }
787
788 static ssize_t
789 boot2_hammer_read(boot2_ino_t ino, void *buf, size_t len)
790 {
791         ssize_t rlen = hreadf(&hfs, ino, fs_off, len, buf);
792         if (rlen != -1)
793                 fs_off += rlen;
794         return (rlen);
795 }
796
797 const struct boot2_fsapi boot2_hammer_api = {
798         .fsinit = boot2_hammer_init,
799         .fslookup = boot2_hammer_lookup,
800         .fsread = boot2_hammer_read
801 };
802
803 #endif
804
805 #ifndef BOOT2
806 static int
807 hinit(struct hfs *hfs)
808 {
809 #if DEBUG
810         printf("hinit\n");
811 #endif
812         for (int i = 0; i < NUMCACHE; i++) {
813                 hfs->cache[i].data = malloc(HAMMER_BUFSIZE);
814                 hfs->cache[i].off = -1; // invalid
815                 hfs->cache[i].use = 0;
816
817 #if DEBUG
818                 if (hfs->cache[i].data == NULL)
819                         printf("malloc failed\n");
820 #endif
821         }
822         hfs->lru = 0;
823
824         hammer_volume_ondisk_t volhead = hread(hfs, HAMMER_ZONE_ENCODE(1, 0));
825
826 #ifdef TESTING
827         if (volhead) {
828                 printf("signature: %svalid\n",
829                        volhead->vol_signature != HAMMER_FSBUF_VOLUME ?
830                                 "in" :
831                                 "");
832                 printf("name: %s\n", volhead->vol_name);
833         }
834 #endif
835
836         if (volhead == NULL || volhead->vol_signature != HAMMER_FSBUF_VOLUME) {
837                 for (int i = 0; i < NUMCACHE; i++) {
838                         free(hfs->cache[i].data);
839                         hfs->cache[i].data = NULL;
840                 }
841                 errno = ENODEV;
842                 return (-1);
843         }
844
845         hfs->root = volhead->vol0_btree_root;
846         hfs->buf_beg = volhead->vol_buf_beg;
847
848         return (0);
849 }
850
851 static void
852 hclose(struct hfs *hfs)
853 {
854 #if DEBUG
855         printf("hclose\n");
856 #endif
857         for (int i = 0; i < NUMCACHE; i++) {
858                 if (hfs->cache[i].data) {
859                         free(hfs->cache[i].data);
860                         hfs->cache[i].data = NULL;
861                 }
862         }
863 }
864 #endif
865
866 #ifdef LIBSTAND
867 struct hfile {
868         struct hfs      hfs;
869         ino_t           ino;
870         int64_t         fsize;
871 };
872
873 static int
874 hammer_open(const char *path, struct open_file *f)
875 {
876         struct hfile *hf = malloc(sizeof(*hf));
877
878         bzero(hf, sizeof(*hf));
879         f->f_fsdata = hf;
880         hf->hfs.f = f;
881         f->f_offset = 0;
882
883         int rv = hinit(&hf->hfs);
884         if (rv) {
885                 f->f_fsdata = NULL;
886                 free(hf);
887                 return (rv);
888         }
889
890 #if DEBUG
891         printf("hammer_open %s %p %ld\n", path, f);
892 #endif
893
894         hf->ino = hlookup(&hf->hfs, path);
895         if (hf->ino == -1)
896                 goto fail;
897
898         struct stat st;
899         if (hstat(&hf->hfs, hf->ino, &st) == -1)
900                 goto fail;
901         hf->fsize = st.st_size;
902
903 #if DEBUG
904         printf("        %ld\n", (long)hf->fsize);
905 #endif
906
907         return (0);
908
909 fail:
910 #if DEBUG
911         printf("hammer_open fail\n");
912 #endif
913         f->f_fsdata = NULL;
914         hclose(&hf->hfs);
915         free(hf);
916         return (ENOENT);
917 }
918
919 static int
920 hammer_close(struct open_file *f)
921 {
922         struct hfile *hf = f->f_fsdata;
923
924         f->f_fsdata = NULL;
925         if (hf) {
926             hclose(&hf->hfs);
927             free(hf);
928         }
929         return (0);
930 }
931
932 static int
933 hammer_read(struct open_file *f, void *buf, size_t len, size_t *resid)
934 {
935         struct hfile *hf = f->f_fsdata;
936
937 #if DEBUG
938         printf("hammer_read %p %ld %ld\n", f, f->f_offset, len);
939 #endif
940
941         if (f->f_offset >= hf->fsize)
942                 return (EINVAL);
943
944         size_t maxlen = len;
945         if (f->f_offset + len > hf->fsize)
946                 maxlen = hf->fsize - f->f_offset;
947
948         ssize_t rlen = hreadf(&hf->hfs, hf->ino, f->f_offset, maxlen, buf);
949         if (rlen == -1)
950                 return (EINVAL);
951
952         f->f_offset += rlen;
953
954         *resid = len - rlen;
955         return (0);
956 }
957
958 static off_t
959 hammer_seek(struct open_file *f, off_t offset, int whence)
960 {
961         struct hfile *hf = f->f_fsdata;
962
963         switch (whence) {
964         case SEEK_SET:
965                 f->f_offset = offset;
966                 break;
967         case SEEK_CUR:
968                 f->f_offset += offset;
969                 break;
970         case SEEK_END:
971                 f->f_offset = hf->fsize - offset;
972                 break;
973         default:
974                 return (-1);
975         }
976         return (f->f_offset);
977 }
978
979 static int
980 hammer_stat(struct open_file *f, struct stat *st)
981 {
982         struct hfile *hf = f->f_fsdata;
983
984         return (hstat(&hf->hfs, hf->ino, st));
985 }
986
987 static int
988 hammer_readdir(struct open_file *f, struct dirent *d)
989 {
990         struct hfile *hf = f->f_fsdata;
991
992         int64_t off = f->f_offset;
993         int rv = hreaddir(&hf->hfs, hf->ino, &off, d);
994         f->f_offset = off;
995         return (rv);
996 }
997
998 // libstand
999 struct fs_ops hammer_fsops = {
1000         "hammer",
1001         hammer_open,
1002         hammer_close,
1003         hammer_read,
1004         null_write,
1005         hammer_seek,
1006         hammer_stat,
1007         hammer_readdir
1008 };
1009 #endif  // LIBSTAND
1010
1011 #ifdef TESTING
1012 int
1013 main(int argc, char **argv)
1014 {
1015         if (argc < 2) {
1016                 fprintf(stderr, "usage: hammerread <dev>\n");
1017                 return (1);
1018         }
1019
1020         struct hfs hfs;
1021         hfs.fd = open(argv[1], O_RDONLY);
1022         if (hfs.fd == -1)
1023                 err(1, "unable to open %s", argv[1]);
1024
1025         if (hinit(&hfs) == -1)
1026                 err(1, "invalid hammerfs");
1027
1028         for (int i = 2; i < argc; i++) {
1029                 ino_t ino = hlookup(&hfs, argv[i]);
1030                 if (ino == (ino_t)-1) {
1031                         warn("hlookup %s", argv[i]);
1032                         continue;
1033                 }
1034
1035                 struct stat st;
1036                 if (hstat(&hfs, ino, &st)) {
1037                         warn("hstat %s", argv[i]);
1038                         continue;
1039                 }
1040
1041                 printf("%s %d/%d %o %lld\n",
1042                        argv[i],
1043                        st.st_uid, st.st_gid,
1044                        st.st_mode, st.st_size);
1045
1046                 if (S_ISDIR(st.st_mode)) {
1047                         int64_t off = 0;
1048                         struct dirent de;
1049                         while (hreaddir(&hfs, ino, &off, &de) == 0) {
1050                                 printf("%s %d %llx\n",
1051                                        de.d_name, de.d_type, de.d_ino);
1052                         }
1053                 } else if (S_ISREG(st.st_mode)) {
1054                         char *buf = malloc(100000);
1055                         int64_t off = 0;
1056                         while (off < st.st_size) {
1057                                 int64_t len = MIN(100000, st.st_size - off);
1058                                 int64_t rl = hreadf(&hfs, ino, off, len, buf);
1059                                 fwrite(buf, rl, 1, stdout);
1060                                 off += rl;
1061                         }
1062                         free(buf);
1063                 }
1064         }
1065
1066         return 0;
1067 }
1068 #endif