sbin/hammer/ondisk.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sbin/hammer/ondisk.c,v 1.10 2008/02/08 08:30:56 dillon Exp $
  35  */
  36
  37 #include <sys/types.h>
  38 #include <assert.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <stdarg.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <err.h>
  45 #include <fcntl.h>
  46 #include "hammer_util.h"
  47
  48 static void init_fifo_head(hammer_fifo_head_t head, u_int16_t hdr_type);
  49 static hammer_off_t hammer_alloc_fifo(int32_t base_bytes, int32_t ext_bytes,
  50                         struct buffer_info **bufp, u_int16_t hdr_type);
  51 #if 0
  52 static void readhammerbuf(struct volume_info *vol, void *data,
  53                         int64_t offset);
  54 #endif
  55 static void writehammerbuf(struct volume_info *vol, const void *data,
  56                         int64_t offset);
  57
  58
  59 uuid_t Hammer_FSType;
  60 uuid_t Hammer_FSId;
  61 int64_t BootAreaSize;
  62 int64_t MemAreaSize;
  63 int     UsingSuperClusters;
  64 int     NumVolumes;
  65 int     RootVolNo = -1;
  66 struct volume_list VolList = TAILQ_HEAD_INITIALIZER(VolList);
  67
  68 /*
  69  * Lookup the requested information structure and related on-disk buffer.
  70  * Missing structures are created.
  71  */
  72 struct volume_info *
  73 setup_volume(int32_t vol_no, const char *filename, int isnew, int oflags)
  74 {
  75         struct volume_info *vol;
  76         struct volume_info *scan;
  77         struct hammer_volume_ondisk *ondisk;
  78         int n;
  79
  80         /*
  81          * Allocate the volume structure
  82          */
  83         vol = malloc(sizeof(*vol));
  84         bzero(vol, sizeof(*vol));
  85         TAILQ_INIT(&vol->buffer_list);
  86         vol->name = strdup(filename);
  87         vol->fd = open(filename, oflags);
  88         if (vol->fd < 0) {
  89                 free(vol->name);
  90                 free(vol);
  91                 err(1, "setup_volume: %s: Open failed", filename);
  92         }
  93
  94         /*
  95          * Read or initialize the volume header
  96          */
  97         vol->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
  98         if (isnew) {
  99                 bzero(ondisk, HAMMER_BUFSIZE);
 100         } else {
 101                 n = pread(vol->fd, ondisk, HAMMER_BUFSIZE, 0);
 102                 if (n != HAMMER_BUFSIZE) {
 103                         err(1, "setup_volume: %s: Read failed at offset 0",
 104                             filename);
 105                 }
 106                 vol_no = ondisk->vol_no;
 107                 if (RootVolNo < 0) {
 108                         RootVolNo = ondisk->vol_rootvol;
 109                 } else if (RootVolNo != (int)ondisk->vol_rootvol) {
 110                         errx(1, "setup_volume: %s: root volume disagreement: "
 111                                 "%d vs %d",
 112                                 vol->name, RootVolNo, ondisk->vol_rootvol);
 113                 }
 114
 115                 if (bcmp(&Hammer_FSType, &ondisk->vol_fstype, sizeof(Hammer_FSType)) != 0) {
 116                         errx(1, "setup_volume: %s: Header does not indicate "
 117                                 "that this is a hammer volume", vol->name);
 118                 }
 119                 if (TAILQ_EMPTY(&VolList)) {
 120                         Hammer_FSId = vol->ondisk->vol_fsid;
 121                 } else if (bcmp(&Hammer_FSId, &ondisk->vol_fsid, sizeof(Hammer_FSId)) != 0) {
 122                         errx(1, "setup_volume: %s: FSId does match other "
 123                                 "volumes!", vol->name);
 124                 }
 125         }
 126         vol->vol_no = vol_no;
 127
 128         if (isnew) {
 129                 init_fifo_head(&ondisk->head, HAMMER_HEAD_TYPE_VOL);
 130                 vol->cache.modified = 1;
 131         }
 132
 133         /*
 134          * Link the volume structure in
 135          */
 136         TAILQ_FOREACH(scan, &VolList, entry) {
 137                 if (scan->vol_no == vol_no) {
 138                         errx(1, "setup_volume %s: Duplicate volume number %d "
 139                                 "against %s", filename, vol_no, scan->name);
 140                 }
 141         }
 142         TAILQ_INSERT_TAIL(&VolList, vol, entry);
 143         return(vol);
 144 }
 145
 146 struct volume_info *
 147 get_volume(int32_t vol_no)
 148 {
 149         struct volume_info *vol;
 150
 151         TAILQ_FOREACH(vol, &VolList, entry) {
 152                 if (vol->vol_no == vol_no)
 153                         break;
 154         }
 155         if (vol == NULL)
 156                 errx(1, "get_volume: Volume %d does not exist!", vol_no);
 157         ++vol->cache.refs;
 158         /* not added to or removed from hammer cache */
 159         return(vol);
 160 }
 161
 162 void
 163 rel_volume(struct volume_info *volume)
 164 {
 165         /* not added to or removed from hammer cache */
 166         --volume->cache.refs;
 167 }
 168
 169 /*
 170  * Acquire the specified buffer.
 171  */
 172 struct buffer_info *
 173 get_buffer(hammer_off_t buf_offset, int isnew)
 174 {
 175         void *ondisk;
 176         struct buffer_info *buf;
 177         struct volume_info *volume;
 178         int n;
 179         int vol_no;
 180
 181         assert((buf_offset & HAMMER_OFF_ZONE_MASK) == HAMMER_ZONE_RAW_BUFFER);
 182
 183         vol_no = HAMMER_VOL_DECODE(buf_offset);
 184         volume = get_volume(vol_no);
 185         buf_offset &= ~HAMMER_BUFMASK64;
 186
 187         TAILQ_FOREACH(buf, &volume->buffer_list, entry) {
 188                 if (buf->buf_offset == buf_offset)
 189                         break;
 190         }
 191         if (buf == NULL) {
 192                 buf = malloc(sizeof(*buf));
 193                 bzero(buf, sizeof(*buf));
 194                 buf->buf_offset = buf_offset;
 195                 buf->buf_disk_offset = volume->ondisk->vol_buf_beg +
 196                                         (buf_offset & HAMMER_OFF_SHORT_MASK);
 197                 buf->volume = volume;
 198                 TAILQ_INSERT_TAIL(&volume->buffer_list, buf, entry);
 199                 ++volume->cache.refs;
 200                 buf->cache.u.buffer = buf;
 201                 hammer_cache_add(&buf->cache, ISBUFFER);
 202         }
 203         ++buf->cache.refs;
 204         hammer_cache_flush();
 205         if ((ondisk = buf->ondisk) == NULL) {
 206                 buf->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
 207                 if (isnew == 0) {
 208                         n = pread(volume->fd, ondisk, HAMMER_BUFSIZE,
 209                                   buf->buf_disk_offset);
 210                         if (n != HAMMER_BUFSIZE) {
 211                                 err(1, "get_buffer: %s:%016llx Read failed at "
 212                                        "offset %lld",
 213                                     volume->name, buf->buf_offset,
 214                                     buf->buf_disk_offset);
 215                         }
 216                 }
 217         }
 218         if (isnew) {
 219                 bzero(ondisk, HAMMER_BUFSIZE);
 220                 buf->cache.modified = 1;
 221         }
 222         return(buf);
 223 }
 224
 225 void
 226 rel_buffer(struct buffer_info *buffer)
 227 {
 228         struct volume_info *volume;
 229
 230         assert(buffer->cache.refs > 0);
 231         if (--buffer->cache.refs == 0) {
 232                 if (buffer->cache.delete) {
 233                         volume = buffer->volume;
 234                         if (buffer->cache.modified)
 235                                 flush_buffer(buffer);
 236                         TAILQ_REMOVE(&volume->buffer_list, buffer, entry);
 237                         hammer_cache_del(&buffer->cache);
 238                         free(buffer->ondisk);
 239                         free(buffer);
 240                         rel_volume(volume);
 241                 }
 242         }
 243 }
 244
 245 /*
 246  * Retrieve a pointer to a B-Tree node given a cluster offset.  The underlying
 247  * bufp is freed if non-NULL and a referenced buffer is loaded into it.
 248  */
 249 hammer_node_ondisk_t
 250 get_node(hammer_off_t node_offset, struct buffer_info **bufp)
 251 {
 252         struct buffer_info *buf;
 253
 254         if (*bufp)
 255                 rel_buffer(*bufp);
 256         *bufp = buf = get_buffer(node_offset, 0);
 257         return((void *)((char *)buf->ondisk +
 258                         (int32_t)(node_offset & HAMMER_BUFMASK)));
 259 }
 260
 261 /*
 262  * Allocate HAMMER elements - btree nodes, data storage, and record elements
 263  *
 264  * NOTE: hammer_alloc_fifo() initializes the fifo header for the returned
 265  * item and zero's out the remainder, so don't bzero() it.
 266  */
 267 void *
 268 alloc_btree_element(hammer_off_t *offp)
 269 {
 270         struct buffer_info *buf;
 271         void *item;
 272
 273         *offp = hammer_alloc_fifo(sizeof(struct hammer_node_ondisk), 0,
 274                                   &buf, HAMMER_HEAD_TYPE_BTREE);
 275         item = (char *)buf->ondisk + ((int32_t)*offp & HAMMER_BUFMASK);
 276         /* XXX buf not released, ptr remains valid */
 277         return(item);
 278 }
 279
 280 hammer_record_ondisk_t
 281 alloc_record_element(hammer_off_t *offp, u_int8_t rec_type,
 282                      int32_t rec_len, int32_t data_len, void **datap)
 283 {
 284         struct buffer_info *buf;
 285         hammer_record_ondisk_t rec;
 286         int32_t aligned_rec_len;
 287
 288         aligned_rec_len = (rec_len + HAMMER_HEAD_ALIGN_MASK) &
 289                           ~HAMMER_HEAD_ALIGN_MASK;
 290
 291         *offp = hammer_alloc_fifo(aligned_rec_len, data_len, &buf,
 292                                   HAMMER_HEAD_TYPE_RECORD);
 293         rec = (void *)((char *)buf->ondisk + ((int32_t)*offp & HAMMER_BUFMASK));
 294         rec->base.base.rec_type = rec_type;
 295         if (data_len) {
 296                 rec->base.data_off = *offp + aligned_rec_len;
 297                 rec->base.data_len = data_len;
 298                 *datap = (char *)rec + aligned_rec_len;
 299         } else {
 300                 *datap = NULL;
 301         }
 302         /* XXX buf not released, ptr remains valid */
 303         return(rec);
 304 }
 305
 306 /*
 307  * Reserve space from the FIFO.  Make sure that bytes does not cross a
 308  * record boundary.
 309  *
 310  * Initialize the fifo header, keep track of the previous entry's size
 311  * so the reverse poitner can be initialized (using lastBlk), and also
 312  * store a terminator (used by the recovery code) which will be overwritten
 313  * by the next allocation.
 314  */
 315 static
 316 hammer_off_t
 317 hammer_alloc_fifo(int32_t base_bytes, int32_t ext_bytes,
 318                   struct buffer_info **bufp, u_int16_t hdr_type)
 319 {
 320         struct buffer_info *buf;
 321         struct volume_info *volume;
 322         hammer_fifo_head_t head;
 323         hammer_off_t off;
 324         int32_t aligned_bytes;
 325         static u_int32_t lastBlk;
 326
 327         aligned_bytes = (base_bytes + ext_bytes + HAMMER_HEAD_ALIGN_MASK) &
 328                         ~HAMMER_HEAD_ALIGN_MASK;
 329
 330         volume = get_volume(RootVolNo);
 331         off = volume->ondisk->vol0_fifo_end;
 332
 333         /*
 334          * For now don't deal with transitions across buffer boundaries,
 335          * only newfs_hammer uses this function.
 336          */
 337         assert((off & ~HAMMER_BUFMASK64) ==
 338                  ((off + aligned_bytes + sizeof(*head)) & ~HAMMER_BUFMASK));
 339
 340         *bufp = buf = get_buffer(off, 0);
 341
 342         buf->cache.modified = 1;
 343         volume->cache.modified = 1;
 344
 345         head = (void *)((char *)buf->ondisk + ((int32_t)off & HAMMER_BUFMASK));
 346         bzero(head, base_bytes);
 347
 348         head->hdr_type = hdr_type;
 349         head->hdr_rev_link = lastBlk;
 350         head->hdr_fwd_link = aligned_bytes;
 351         head->hdr_seq = volume->ondisk->vol0_next_seq++;
 352         lastBlk = head->hdr_fwd_link;
 353
 354         volume->ondisk->vol0_fifo_end += aligned_bytes;
 355         volume->cache.modified = 1;
 356         head = (void *)((char *)head + aligned_bytes);
 357         head->hdr_signature = HAMMER_HEAD_SIGNATURE;
 358         head->hdr_type = HAMMER_HEAD_TYPE_TERM;
 359         head->hdr_rev_link = lastBlk;
 360         head->hdr_fwd_link = 0;
 361         head->hdr_crc = 0;
 362         head->hdr_seq = volume->ondisk->vol0_next_seq;
 363
 364         rel_volume(volume);
 365
 366         return(off);
 367 }
 368
 369 /*
 370  * Flush various tracking structures to disk
 371  */
 372
 373 /*
 374  * Flush various tracking structures to disk
 375  */
 376 void
 377 flush_all_volumes(void)
 378 {
 379         struct volume_info *vol;
 380
 381         TAILQ_FOREACH(vol, &VolList, entry)
 382                 flush_volume(vol);
 383 }
 384
 385 void
 386 flush_volume(struct volume_info *volume)
 387 {
 388         struct buffer_info *buffer;
 389
 390         TAILQ_FOREACH(buffer, &volume->buffer_list, entry)
 391                 flush_buffer(buffer);
 392         writehammerbuf(volume, volume->ondisk, 0);
 393         volume->cache.modified = 0;
 394 }
 395
 396 void
 397 flush_buffer(struct buffer_info *buffer)
 398 {
 399         writehammerbuf(buffer->volume, buffer->ondisk, buffer->buf_disk_offset);
 400         buffer->cache.modified = 0;
 401 }
 402
 403 /*
 404  * Generic buffer initialization
 405  */
 406 static void
 407 init_fifo_head(hammer_fifo_head_t head, u_int16_t hdr_type)
 408 {
 409         head->hdr_signature = HAMMER_HEAD_SIGNATURE;
 410         head->hdr_type = hdr_type;
 411         head->hdr_rev_link = 0;
 412         head->hdr_fwd_link = 0;
 413         head->hdr_crc = 0;
 414         head->hdr_seq = 0;
 415 }
 416
 417 #if 0
 418 /*
 419  * Core I/O operations
 420  */
 421 static void
 422 readhammerbuf(struct volume_info *vol, void *data, int64_t offset)
 423 {
 424         ssize_t n;
 425
 426         n = pread(vol->fd, data, HAMMER_BUFSIZE, offset);
 427         if (n != HAMMER_BUFSIZE)
 428                 err(1, "Read volume %d (%s)", vol->vol_no, vol->name);
 429 }
 430
 431 #endif
 432
 433 static void
 434 writehammerbuf(struct volume_info *vol, const void *data, int64_t offset)
 435 {
 436         ssize_t n;
 437
 438         n = pwrite(vol->fd, data, HAMMER_BUFSIZE, offset);
 439         if (n != HAMMER_BUFSIZE)
 440                 err(1, "Write volume %d (%s)", vol->vol_no, vol->name);
 441 }
 442
 443 void
 444 panic(const char *ctl, ...)
 445 {
 446         va_list va;
 447
 448         va_start(va, ctl);
 449         vfprintf(stderr, ctl, va);
 450         va_end(va);
 451         fprintf(stderr, "\n");
 452         exit(1);
 453 }
 454