sys/geom/journal/g_journal.c

   1 /*-
   2  * Copyright (c) 2005-2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/kernel.h>
  33 #include <sys/module.h>
  34 #include <sys/limits.h>
  35 #include <sys/lock.h>
  36 #include <sys/mutex.h>
  37 #include <sys/bio.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mount.h>
  41 #include <sys/eventhandler.h>
  42 #include <sys/proc.h>
  43 #include <sys/kthread.h>
  44 #include <sys/sched.h>
  45 #include <sys/taskqueue.h>
  46 #include <sys/vnode.h>
  47 #include <sys/sbuf.h>
  48 #ifdef GJ_MEMDEBUG
  49 #include <sys/stack.h>
  50 #include <sys/kdb.h>
  51 #endif
  52 #include <vm/vm.h>
  53 #include <vm/vm_kern.h>
  54 #include <geom/geom.h>
  55
  56 #include <geom/journal/g_journal.h>
  57
  58 FEATURE(geom_journal, "GEOM journaling support");
  59
  60 /*
  61  * On-disk journal format:
  62  *
  63  * JH - Journal header
  64  * RH - Record header
  65  *
  66  * %%%%%% ****** +------+ +------+     ****** +------+     %%%%%%
  67  * % JH % * RH * | Data | | Data | ... * RH * | Data | ... % JH % ...
  68  * %%%%%% ****** +------+ +------+     ****** +------+     %%%%%%
  69  *
  70  */
  71
  72 CTASSERT(sizeof(struct g_journal_header) <= 512);
  73 CTASSERT(sizeof(struct g_journal_record_header) <= 512);
  74
  75 static MALLOC_DEFINE(M_JOURNAL, "journal_data", "GEOM_JOURNAL Data");
  76 static struct mtx g_journal_cache_mtx;
  77 MTX_SYSINIT(g_journal_cache, &g_journal_cache_mtx, "cache usage", MTX_DEF);
  78
  79 const struct g_journal_desc *g_journal_filesystems[] = {
  80         &g_journal_ufs,
  81         NULL
  82 };
  83
  84 SYSCTL_DECL(_kern_geom);
  85
  86 int g_journal_debug = 0;
  87 static u_int g_journal_switch_time = 10;
  88 static u_int g_journal_force_switch = 70;
  89 static u_int g_journal_parallel_flushes = 16;
  90 static u_int g_journal_parallel_copies = 16;
  91 static u_int g_journal_accept_immediately = 64;
  92 static u_int g_journal_record_entries = GJ_RECORD_HEADER_NENTRIES;
  93 static u_int g_journal_do_optimize = 1;
  94
  95 static SYSCTL_NODE(_kern_geom, OID_AUTO, journal, CTLFLAG_RW, 0,
  96     "GEOM_JOURNAL stuff");
  97 SYSCTL_INT(_kern_geom_journal, OID_AUTO, debug, CTLFLAG_RWTUN, &g_journal_debug, 0,
  98     "Debug level");
  99 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, switch_time, CTLFLAG_RW,
 100     &g_journal_switch_time, 0, "Switch journals every N seconds");
 101 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, force_switch, CTLFLAG_RW,
 102     &g_journal_force_switch, 0, "Force switch when journal is N% full");
 103 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, parallel_flushes, CTLFLAG_RW,
 104     &g_journal_parallel_flushes, 0,
 105     "Number of flush I/O requests to send in parallel");
 106 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, accept_immediately, CTLFLAG_RW,
 107     &g_journal_accept_immediately, 0,
 108     "Number of I/O requests accepted immediately");
 109 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, parallel_copies, CTLFLAG_RW,
 110     &g_journal_parallel_copies, 0,
 111     "Number of copy I/O requests to send in parallel");
 112 static int
 113 g_journal_record_entries_sysctl(SYSCTL_HANDLER_ARGS)
 114 {
 115         u_int entries;
 116         int error;
 117
 118         entries = g_journal_record_entries;
 119         error = sysctl_handle_int(oidp, &entries, 0, req);
 120         if (error != 0 || req->newptr == NULL)
 121                 return (error);
 122         if (entries < 1 || entries > GJ_RECORD_HEADER_NENTRIES)
 123                 return (EINVAL);
 124         g_journal_record_entries = entries;
 125         return (0);
 126 }
 127 SYSCTL_PROC(_kern_geom_journal, OID_AUTO, record_entries,
 128     CTLTYPE_UINT | CTLFLAG_RW, NULL, 0, g_journal_record_entries_sysctl, "I",
 129     "Maximum number of entires in one journal record");
 130 SYSCTL_UINT(_kern_geom_journal, OID_AUTO, optimize, CTLFLAG_RW,
 131     &g_journal_do_optimize, 0, "Try to combine bios on flush and copy");
 132
 133 static u_int g_journal_cache_used = 0;
 134 static u_int g_journal_cache_limit = 64 * 1024 * 1024;
 135 static u_int g_journal_cache_divisor = 2;
 136 static u_int g_journal_cache_switch = 90;
 137 static u_int g_journal_cache_misses = 0;
 138 static u_int g_journal_cache_alloc_failures = 0;
 139 static u_int g_journal_cache_low = 0;
 140
 141 static SYSCTL_NODE(_kern_geom_journal, OID_AUTO, cache, CTLFLAG_RW, 0,
 142     "GEOM_JOURNAL cache");
 143 SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, used, CTLFLAG_RD,
 144     &g_journal_cache_used, 0, "Number of allocated bytes");
 145 static int
 146 g_journal_cache_limit_sysctl(SYSCTL_HANDLER_ARGS)
 147 {
 148         u_int limit;
 149         int error;
 150
 151         limit = g_journal_cache_limit;
 152         error = sysctl_handle_int(oidp, &limit, 0, req);
 153         if (error != 0 || req->newptr == NULL)
 154                 return (error);
 155         g_journal_cache_limit = limit;
 156         g_journal_cache_low = (limit / 100) * g_journal_cache_switch;
 157         return (0);
 158 }
 159 SYSCTL_PROC(_kern_geom_journal_cache, OID_AUTO, limit,
 160     CTLTYPE_UINT | CTLFLAG_RWTUN, NULL, 0, g_journal_cache_limit_sysctl, "I",
 161     "Maximum number of allocated bytes");
 162 SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, divisor, CTLFLAG_RDTUN,
 163     &g_journal_cache_divisor, 0,
 164     "(kmem_size / kern.geom.journal.cache.divisor) == cache size");
 165 static int
 166 g_journal_cache_switch_sysctl(SYSCTL_HANDLER_ARGS)
 167 {
 168         u_int cswitch;
 169         int error;
 170
 171         cswitch = g_journal_cache_switch;
 172         error = sysctl_handle_int(oidp, &cswitch, 0, req);
 173         if (error != 0 || req->newptr == NULL)
 174                 return (error);
 175         if (cswitch > 100)
 176                 return (EINVAL);
 177         g_journal_cache_switch = cswitch;
 178         g_journal_cache_low = (g_journal_cache_limit / 100) * cswitch;
 179         return (0);
 180 }
 181 SYSCTL_PROC(_kern_geom_journal_cache, OID_AUTO, switch,
 182     CTLTYPE_UINT | CTLFLAG_RW, NULL, 0, g_journal_cache_switch_sysctl, "I",
 183     "Force switch when we hit this percent of cache use");
 184 SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, misses, CTLFLAG_RW,
 185     &g_journal_cache_misses, 0, "Number of cache misses");
 186 SYSCTL_UINT(_kern_geom_journal_cache, OID_AUTO, alloc_failures, CTLFLAG_RW,
 187     &g_journal_cache_alloc_failures, 0, "Memory allocation failures");
 188
 189 static u_long g_journal_stats_bytes_skipped = 0;
 190 static u_long g_journal_stats_combined_ios = 0;
 191 static u_long g_journal_stats_switches = 0;
 192 static u_long g_journal_stats_wait_for_copy = 0;
 193 static u_long g_journal_stats_journal_full = 0;
 194 static u_long g_journal_stats_low_mem = 0;
 195
 196 static SYSCTL_NODE(_kern_geom_journal, OID_AUTO, stats, CTLFLAG_RW, 0,
 197     "GEOM_JOURNAL statistics");
 198 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, skipped_bytes, CTLFLAG_RW,
 199     &g_journal_stats_bytes_skipped, 0, "Number of skipped bytes");
 200 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, combined_ios, CTLFLAG_RW,
 201     &g_journal_stats_combined_ios, 0, "Number of combined I/O requests");
 202 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, switches, CTLFLAG_RW,
 203     &g_journal_stats_switches, 0, "Number of journal switches");
 204 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, wait_for_copy, CTLFLAG_RW,
 205     &g_journal_stats_wait_for_copy, 0, "Wait for journal copy on switch");
 206 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, journal_full, CTLFLAG_RW,
 207     &g_journal_stats_journal_full, 0,
 208     "Number of times journal was almost full.");
 209 SYSCTL_ULONG(_kern_geom_journal_stats, OID_AUTO, low_mem, CTLFLAG_RW,
 210     &g_journal_stats_low_mem, 0, "Number of times low_mem hook was called.");
 211
 212 static g_taste_t g_journal_taste;
 213 static g_ctl_req_t g_journal_config;
 214 static g_dumpconf_t g_journal_dumpconf;
 215 static g_init_t g_journal_init;
 216 static g_fini_t g_journal_fini;
 217
 218 struct g_class g_journal_class = {
 219         .name = G_JOURNAL_CLASS_NAME,
 220         .version = G_VERSION,
 221         .taste = g_journal_taste,
 222         .ctlreq = g_journal_config,
 223         .dumpconf = g_journal_dumpconf,
 224         .init = g_journal_init,
 225         .fini = g_journal_fini
 226 };
 227
 228 static int g_journal_destroy(struct g_journal_softc *sc);
 229 static void g_journal_metadata_update(struct g_journal_softc *sc);
 230 static void g_journal_start_switcher(struct g_class *mp);
 231 static void g_journal_stop_switcher(void);
 232 static void g_journal_switch_wait(struct g_journal_softc *sc);
 233
 234 #define GJ_SWITCHER_WORKING     0
 235 #define GJ_SWITCHER_DIE         1
 236 #define GJ_SWITCHER_DIED        2
 237 static struct proc *g_journal_switcher_proc = NULL;
 238 static int g_journal_switcher_state = GJ_SWITCHER_WORKING;
 239 static int g_journal_switcher_wokenup = 0;
 240 static int g_journal_sync_requested = 0;
 241
 242 #ifdef GJ_MEMDEBUG
 243 struct meminfo {
 244         size_t          mi_size;
 245         struct stack    mi_stack;
 246 };
 247 #endif
 248
 249 /*
 250  * We use our own malloc/realloc/free funtions, so we can collect statistics
 251  * and force journal switch when we're running out of cache.
 252  */
 253 static void *
 254 gj_malloc(size_t size, int flags)
 255 {
 256         void *p;
 257 #ifdef GJ_MEMDEBUG
 258         struct meminfo *mi;
 259 #endif
 260
 261         mtx_lock(&g_journal_cache_mtx);
 262         if (g_journal_cache_limit > 0 && !g_journal_switcher_wokenup &&
 263             g_journal_cache_used + size > g_journal_cache_low) {
 264                 GJ_DEBUG(1, "No cache, waking up the switcher.");
 265                 g_journal_switcher_wokenup = 1;
 266                 wakeup(&g_journal_switcher_state);
 267         }
 268         if ((flags & M_NOWAIT) && g_journal_cache_limit > 0 &&
 269             g_journal_cache_used + size > g_journal_cache_limit) {
 270                 mtx_unlock(&g_journal_cache_mtx);
 271                 g_journal_cache_alloc_failures++;
 272                 return (NULL);
 273         }
 274         g_journal_cache_used += size;
 275         mtx_unlock(&g_journal_cache_mtx);
 276         flags &= ~M_NOWAIT;
 277 #ifndef GJ_MEMDEBUG
 278         p = malloc(size, M_JOURNAL, flags | M_WAITOK);
 279 #else
 280         mi = malloc(sizeof(*mi) + size, M_JOURNAL, flags | M_WAITOK);
 281         p = (u_char *)mi + sizeof(*mi);
 282         mi->mi_size = size;
 283         stack_save(&mi->mi_stack);
 284 #endif
 285         return (p);
 286 }
 287
 288 static void
 289 gj_free(void *p, size_t size)
 290 {
 291 #ifdef GJ_MEMDEBUG
 292         struct meminfo *mi;
 293 #endif
 294
 295         KASSERT(p != NULL, ("p=NULL"));
 296         KASSERT(size > 0, ("size=0"));
 297         mtx_lock(&g_journal_cache_mtx);
 298         KASSERT(g_journal_cache_used >= size, ("Freeing too much?"));
 299         g_journal_cache_used -= size;
 300         mtx_unlock(&g_journal_cache_mtx);
 301 #ifdef GJ_MEMDEBUG
 302         mi = p = (void *)((u_char *)p - sizeof(*mi));
 303         if (mi->mi_size != size) {
 304                 printf("GJOURNAL: Size mismatch! %zu != %zu\n", size,
 305                     mi->mi_size);
 306                 printf("GJOURNAL: Alloc backtrace:\n");
 307                 stack_print(&mi->mi_stack);
 308                 printf("GJOURNAL: Free backtrace:\n");
 309                 kdb_backtrace();
 310         }
 311 #endif
 312         free(p, M_JOURNAL);
 313 }
 314
 315 static void *
 316 gj_realloc(void *p, size_t size, size_t oldsize)
 317 {
 318         void *np;
 319
 320 #ifndef GJ_MEMDEBUG
 321         mtx_lock(&g_journal_cache_mtx);
 322         g_journal_cache_used -= oldsize;
 323         g_journal_cache_used += size;
 324         mtx_unlock(&g_journal_cache_mtx);
 325         np = realloc(p, size, M_JOURNAL, M_WAITOK);
 326 #else
 327         np = gj_malloc(size, M_WAITOK);
 328         bcopy(p, np, MIN(oldsize, size));
 329         gj_free(p, oldsize);
 330 #endif
 331         return (np);
 332 }
 333
 334 static void
 335 g_journal_check_overflow(struct g_journal_softc *sc)
 336 {
 337         off_t length, used;
 338
 339         if ((sc->sc_active.jj_offset < sc->sc_inactive.jj_offset &&
 340              sc->sc_journal_offset >= sc->sc_inactive.jj_offset) ||
 341             (sc->sc_active.jj_offset > sc->sc_inactive.jj_offset &&
 342              sc->sc_journal_offset >= sc->sc_inactive.jj_offset &&
 343              sc->sc_journal_offset < sc->sc_active.jj_offset)) {
 344                 panic("Journal overflow "
 345                     "(id = %u joffset=%jd active=%jd inactive=%jd)",
 346                     (unsigned)sc->sc_id,
 347                     (intmax_t)sc->sc_journal_offset,
 348                     (intmax_t)sc->sc_active.jj_offset,
 349                     (intmax_t)sc->sc_inactive.jj_offset);
 350         }
 351         if (sc->sc_active.jj_offset < sc->sc_inactive.jj_offset) {
 352                 length = sc->sc_inactive.jj_offset - sc->sc_active.jj_offset;
 353                 used = sc->sc_journal_offset - sc->sc_active.jj_offset;
 354         } else {
 355                 length = sc->sc_jend - sc->sc_active.jj_offset;
 356                 length += sc->sc_inactive.jj_offset - sc->sc_jstart;
 357                 if (sc->sc_journal_offset >= sc->sc_active.jj_offset)
 358                         used = sc->sc_journal_offset - sc->sc_active.jj_offset;
 359                 else {
 360                         used = sc->sc_jend - sc->sc_active.jj_offset;
 361                         used += sc->sc_journal_offset - sc->sc_jstart;
 362                 }
 363         }
 364         /* Already woken up? */
 365         if (g_journal_switcher_wokenup)
 366                 return;
 367         /*
 368          * If the active journal takes more than g_journal_force_switch precent
 369          * of free journal space, we force journal switch.
 370          */
 371         KASSERT(length > 0,
 372             ("length=%jd used=%jd active=%jd inactive=%jd joffset=%jd",
 373             (intmax_t)length, (intmax_t)used,
 374             (intmax_t)sc->sc_active.jj_offset,
 375             (intmax_t)sc->sc_inactive.jj_offset,
 376             (intmax_t)sc->sc_journal_offset));
 377         if ((used * 100) / length > g_journal_force_switch) {
 378                 g_journal_stats_journal_full++;
 379                 GJ_DEBUG(1, "Journal %s %jd%% full, forcing journal switch.",
 380                     sc->sc_name, (used * 100) / length);
 381                 mtx_lock(&g_journal_cache_mtx);
 382                 g_journal_switcher_wokenup = 1;
 383                 wakeup(&g_journal_switcher_state);
 384                 mtx_unlock(&g_journal_cache_mtx);
 385         }
 386 }
 387
 388 static void
 389 g_journal_orphan(struct g_consumer *cp)
 390 {
 391         struct g_journal_softc *sc;
 392         char name[256];
 393         int error;
 394
 395         g_topology_assert();
 396         sc = cp->geom->softc;
 397         strlcpy(name, cp->provider->name, sizeof(name));
 398         GJ_DEBUG(0, "Lost provider %s.", name);
 399         if (sc == NULL)
 400                 return;
 401         error = g_journal_destroy(sc);
 402         if (error == 0)
 403                 GJ_DEBUG(0, "Journal %s destroyed.", name);
 404         else {
 405                 GJ_DEBUG(0, "Cannot destroy journal %s (error=%d). "
 406                     "Destroy it manually after last close.", sc->sc_name,
 407                     error);
 408         }
 409 }
 410
 411 static int
 412 g_journal_access(struct g_provider *pp, int acr, int acw, int ace)
 413 {
 414         struct g_journal_softc *sc;
 415         int dcr, dcw, dce;
 416
 417         g_topology_assert();
 418         GJ_DEBUG(2, "Access request for %s: r%dw%de%d.", pp->name,
 419             acr, acw, ace);
 420
 421         dcr = pp->acr + acr;
 422         dcw = pp->acw + acw;
 423         dce = pp->ace + ace;
 424
 425         sc = pp->geom->softc;
 426         if (sc == NULL || (sc->sc_flags & GJF_DEVICE_DESTROY)) {
 427                 if (acr <= 0 && acw <= 0 && ace <= 0)
 428                         return (0);
 429                 else
 430                         return (ENXIO);
 431         }
 432         if (pp->acw == 0 && dcw > 0) {
 433                 GJ_DEBUG(1, "Marking %s as dirty.", sc->sc_name);
 434                 sc->sc_flags &= ~GJF_DEVICE_CLEAN;
 435                 g_topology_unlock();
 436                 g_journal_metadata_update(sc);
 437                 g_topology_lock();
 438         } /* else if (pp->acw == 0 && dcw > 0 && JEMPTY(sc)) {
 439                 GJ_DEBUG(1, "Marking %s as clean.", sc->sc_name);
 440                 sc->sc_flags |= GJF_DEVICE_CLEAN;
 441                 g_topology_unlock();
 442                 g_journal_metadata_update(sc);
 443                 g_topology_lock();
 444         } */
 445         return (0);
 446 }
 447
 448 static void
 449 g_journal_header_encode(struct g_journal_header *hdr, u_char *data)
 450 {
 451
 452         bcopy(GJ_HEADER_MAGIC, data, sizeof(GJ_HEADER_MAGIC));
 453         data += sizeof(GJ_HEADER_MAGIC);
 454         le32enc(data, hdr->jh_journal_id);
 455         data += 4;
 456         le32enc(data, hdr->jh_journal_next_id);
 457 }
 458
 459 static int
 460 g_journal_header_decode(const u_char *data, struct g_journal_header *hdr)
 461 {
 462
 463         bcopy(data, hdr->jh_magic, sizeof(hdr->jh_magic));
 464         data += sizeof(hdr->jh_magic);
 465         if (bcmp(hdr->jh_magic, GJ_HEADER_MAGIC, sizeof(GJ_HEADER_MAGIC)) != 0)
 466                 return (EINVAL);
 467         hdr->jh_journal_id = le32dec(data);
 468         data += 4;
 469         hdr->jh_journal_next_id = le32dec(data);
 470         return (0);
 471 }
 472
 473 static void
 474 g_journal_flush_cache(struct g_journal_softc *sc)
 475 {
 476         struct bintime bt;
 477         int error;
 478
 479         if (sc->sc_bio_flush == 0)
 480                 return;
 481         GJ_TIMER_START(1, &bt);
 482         if (sc->sc_bio_flush & GJ_FLUSH_JOURNAL) {
 483                 error = g_io_flush(sc->sc_jconsumer);
 484                 GJ_DEBUG(error == 0 ? 2 : 0, "Flush cache of %s: error=%d.",
 485                     sc->sc_jconsumer->provider->name, error);
 486         }
 487         if (sc->sc_bio_flush & GJ_FLUSH_DATA) {
 488                 /*
 489                  * TODO: This could be called in parallel with the
 490                  *       previous call.
 491                  */
 492                 error = g_io_flush(sc->sc_dconsumer);
 493                 GJ_DEBUG(error == 0 ? 2 : 0, "Flush cache of %s: error=%d.",
 494                     sc->sc_dconsumer->provider->name, error);
 495         }
 496         GJ_TIMER_STOP(1, &bt, "Cache flush time");
 497 }
 498
 499 static int
 500 g_journal_write_header(struct g_journal_softc *sc)
 501 {
 502         struct g_journal_header hdr;
 503         struct g_consumer *cp;
 504         u_char *buf;
 505         int error;
 506
 507         cp = sc->sc_jconsumer;
 508         buf = gj_malloc(cp->provider->sectorsize, M_WAITOK);
 509
 510         strlcpy(hdr.jh_magic, GJ_HEADER_MAGIC, sizeof(hdr.jh_magic));
 511         hdr.jh_journal_id = sc->sc_journal_id;
 512         hdr.jh_journal_next_id = sc->sc_journal_next_id;
 513         g_journal_header_encode(&hdr, buf);
 514         error = g_write_data(cp, sc->sc_journal_offset, buf,
 515             cp->provider->sectorsize);
 516         /* if (error == 0) */
 517         sc->sc_journal_offset += cp->provider->sectorsize;
 518
 519         gj_free(buf, cp->provider->sectorsize);
 520         return (error);
 521 }
 522
 523 /*
 524  * Every journal record has a header and data following it.
 525  * Functions below are used to decode the header before storing it to
 526  * little endian and to encode it after reading to system endianness.
 527  */
 528 static void
 529 g_journal_record_header_encode(struct g_journal_record_header *hdr,
 530     u_char *data)
 531 {
 532         struct g_journal_entry *ent;
 533         u_int i;
 534
 535         bcopy(GJ_RECORD_HEADER_MAGIC, data, sizeof(GJ_RECORD_HEADER_MAGIC));
 536         data += sizeof(GJ_RECORD_HEADER_MAGIC);
 537         le32enc(data, hdr->jrh_journal_id);
 538         data += 8;
 539         le16enc(data, hdr->jrh_nentries);
 540         data += 2;
 541         bcopy(hdr->jrh_sum, data, sizeof(hdr->jrh_sum));
 542         data += 8;
 543         for (i = 0; i < hdr->jrh_nentries; i++) {
 544                 ent = &hdr->jrh_entries[i];
 545                 le64enc(data, ent->je_joffset);
 546                 data += 8;
 547                 le64enc(data, ent->je_offset);
 548                 data += 8;
 549                 le64enc(data, ent->je_length);
 550                 data += 8;
 551         }
 552 }
 553
 554 static int
 555 g_journal_record_header_decode(const u_char *data,
 556     struct g_journal_record_header *hdr)
 557 {
 558         struct g_journal_entry *ent;
 559         u_int i;
 560
 561         bcopy(data, hdr->jrh_magic, sizeof(hdr->jrh_magic));
 562         data += sizeof(hdr->jrh_magic);
 563         if (strcmp(hdr->jrh_magic, GJ_RECORD_HEADER_MAGIC) != 0)
 564                 return (EINVAL);
 565         hdr->jrh_journal_id = le32dec(data);
 566         data += 8;
 567         hdr->jrh_nentries = le16dec(data);
 568         data += 2;
 569         if (hdr->jrh_nentries > GJ_RECORD_HEADER_NENTRIES)
 570                 return (EINVAL);
 571         bcopy(data, hdr->jrh_sum, sizeof(hdr->jrh_sum));
 572         data += 8;
 573         for (i = 0; i < hdr->jrh_nentries; i++) {
 574                 ent = &hdr->jrh_entries[i];
 575                 ent->je_joffset = le64dec(data);
 576                 data += 8;
 577                 ent->je_offset = le64dec(data);
 578                 data += 8;
 579                 ent->je_length = le64dec(data);
 580                 data += 8;
 581         }
 582         return (0);
 583 }
 584
 585 /*
 586  * Function reads metadata from a provider (via the given consumer), decodes
 587  * it to system endianness and verifies its correctness.
 588  */
 589 static int
 590 g_journal_metadata_read(struct g_consumer *cp, struct g_journal_metadata *md)
 591 {
 592         struct g_provider *pp;
 593         u_char *buf;
 594         int error;
 595
 596         g_topology_assert();
 597
 598         error = g_access(cp, 1, 0, 0);
 599         if (error != 0)
 600                 return (error);
 601         pp = cp->provider;
 602         g_topology_unlock();
 603         /* Metadata is stored in last sector. */
 604         buf = g_read_data(cp, pp->mediasize - pp->sectorsize, pp->sectorsize,
 605             &error);
 606         g_topology_lock();
 607         g_access(cp, -1, 0, 0);
 608         if (buf == NULL) {
 609                 GJ_DEBUG(1, "Cannot read metadata from %s (error=%d).",
 610                     cp->provider->name, error);
 611                 return (error);
 612         }
 613
 614         /* Decode metadata. */
 615         error = journal_metadata_decode(buf, md);
 616         g_free(buf);
 617         /* Is this is gjournal provider at all? */
 618         if (strcmp(md->md_magic, G_JOURNAL_MAGIC) != 0)
 619                 return (EINVAL);
 620         /*
 621          * Are we able to handle this version of metadata?
 622          * We only maintain backward compatibility.
 623          */
 624         if (md->md_version > G_JOURNAL_VERSION) {
 625                 GJ_DEBUG(0,
 626                     "Kernel module is too old to handle metadata from %s.",
 627                     cp->provider->name);
 628                 return (EINVAL);
 629         }
 630         /* Is checksum correct? */
 631         if (error != 0) {
 632                 GJ_DEBUG(0, "MD5 metadata hash mismatch for provider %s.",
 633                     cp->provider->name);
 634                 return (error);
 635         }
 636         return (0);
 637 }
 638
 639 /*
 640  * Two functions below are responsible for updating metadata.
 641  * Only metadata on the data provider is updated (we need to update
 642  * information about active journal in there).
 643  */
 644 static void
 645 g_journal_metadata_done(struct bio *bp)
 646 {
 647
 648         /*
 649          * There is not much we can do on error except informing about it.
 650          */
 651         if (bp->bio_error != 0) {
 652                 GJ_LOGREQ(0, bp, "Cannot update metadata (error=%d).",
 653                     bp->bio_error);
 654         } else {
 655                 GJ_LOGREQ(2, bp, "Metadata updated.");
 656         }
 657         gj_free(bp->bio_data, bp->bio_length);
 658         g_destroy_bio(bp);
 659 }
 660
 661 static void
 662 g_journal_metadata_update(struct g_journal_softc *sc)
 663 {
 664         struct g_journal_metadata md;
 665         struct g_consumer *cp;
 666         struct bio *bp;
 667         u_char *sector;
 668
 669         cp = sc->sc_dconsumer;
 670         sector = gj_malloc(cp->provider->sectorsize, M_WAITOK);
 671         strlcpy(md.md_magic, G_JOURNAL_MAGIC, sizeof(md.md_magic));
 672         md.md_version = G_JOURNAL_VERSION;
 673         md.md_id = sc->sc_id;
 674         md.md_type = sc->sc_orig_type;
 675         md.md_jstart = sc->sc_jstart;
 676         md.md_jend = sc->sc_jend;
 677         md.md_joffset = sc->sc_inactive.jj_offset;
 678         md.md_jid = sc->sc_journal_previous_id;
 679         md.md_flags = 0;
 680         if (sc->sc_flags & GJF_DEVICE_CLEAN)
 681                 md.md_flags |= GJ_FLAG_CLEAN;
 682
 683         if (sc->sc_flags & GJF_DEVICE_HARDCODED)
 684                 strlcpy(md.md_provider, sc->sc_name, sizeof(md.md_provider));
 685         else
 686                 bzero(md.md_provider, sizeof(md.md_provider));
 687         md.md_provsize = cp->provider->mediasize;
 688         journal_metadata_encode(&md, sector);
 689
 690         /*
 691          * Flush the cache, so we know all data are on disk.
 692          * We write here informations like "journal is consistent", so we need
 693          * to be sure it is. Without BIO_FLUSH here, we can end up in situation
 694          * where metadata is stored on disk, but not all data.
 695          */
 696         g_journal_flush_cache(sc);
 697
 698         bp = g_alloc_bio();
 699         bp->bio_offset = cp->provider->mediasize - cp->provider->sectorsize;
 700         bp->bio_length = cp->provider->sectorsize;
 701         bp->bio_data = sector;
 702         bp->bio_cmd = BIO_WRITE;
 703         if (!(sc->sc_flags & GJF_DEVICE_DESTROY)) {
 704                 bp->bio_done = g_journal_metadata_done;
 705                 g_io_request(bp, cp);
 706         } else {
 707                 bp->bio_done = NULL;
 708                 g_io_request(bp, cp);
 709                 biowait(bp, "gjmdu");
 710                 g_journal_metadata_done(bp);
 711         }
 712
 713         /*
 714          * Be sure metadata reached the disk.
 715          */
 716         g_journal_flush_cache(sc);
 717 }
 718
 719 /*
 720  * This is where the I/O request comes from the GEOM.
 721  */
 722 static void
 723 g_journal_start(struct bio *bp)
 724 {
 725         struct g_journal_softc *sc;
 726
 727         sc = bp->bio_to->geom->softc;
 728         GJ_LOGREQ(3, bp, "Request received.");
 729
 730         switch (bp->bio_cmd) {
 731         case BIO_READ:
 732         case BIO_WRITE:
 733                 mtx_lock(&sc->sc_mtx);
 734                 bioq_insert_tail(&sc->sc_regular_queue, bp);
 735                 wakeup(sc);
 736                 mtx_unlock(&sc->sc_mtx);
 737                 return;
 738         case BIO_GETATTR:
 739                 if (strcmp(bp->bio_attribute, "GJOURNAL::provider") == 0) {
 740                         strlcpy(bp->bio_data, bp->bio_to->name, bp->bio_length);
 741                         bp->bio_completed = strlen(bp->bio_to->name) + 1;
 742                         g_io_deliver(bp, 0);
 743                         return;
 744                 }
 745                 /* FALLTHROUGH */
 746         case BIO_DELETE:
 747         default:
 748                 g_io_deliver(bp, EOPNOTSUPP);
 749                 return;
 750         }
 751 }
 752
 753 static void
 754 g_journal_std_done(struct bio *bp)
 755 {
 756         struct g_journal_softc *sc;
 757
 758         sc = bp->bio_from->geom->softc;
 759         mtx_lock(&sc->sc_mtx);
 760         bioq_insert_tail(&sc->sc_back_queue, bp);
 761         wakeup(sc);
 762         mtx_unlock(&sc->sc_mtx);
 763 }
 764
 765 static struct bio *
 766 g_journal_new_bio(off_t start, off_t end, off_t joffset, u_char *data,
 767     int flags)
 768 {
 769         struct bio *bp;
 770
 771         bp = g_alloc_bio();
 772         bp->bio_offset = start;
 773         bp->bio_joffset = joffset;
 774         bp->bio_length = end - start;
 775         bp->bio_cmd = BIO_WRITE;
 776         bp->bio_done = g_journal_std_done;
 777         if (data == NULL)
 778                 bp->bio_data = NULL;
 779         else {
 780                 bp->bio_data = gj_malloc(bp->bio_length, flags);
 781                 if (bp->bio_data != NULL)
 782                         bcopy(data, bp->bio_data, bp->bio_length);
 783         }
 784         return (bp);
 785 }
 786
 787 #define g_journal_insert_bio(head, bp, flags)                           \
 788         g_journal_insert((head), (bp)->bio_offset,                      \
 789                 (bp)->bio_offset + (bp)->bio_length, (bp)->bio_joffset, \
 790                 (bp)->bio_data, flags)
 791 /*
 792  * The function below does a lot more than just inserting bio to the queue.
 793  * It keeps the queue sorted by offset and ensures that there are no doubled
 794  * data (it combines bios where ranges overlap).
 795  *
 796  * The function returns the number of bios inserted (as bio can be splitted).
 797  */
 798 static int
 799 g_journal_insert(struct bio **head, off_t nstart, off_t nend, off_t joffset,
 800     u_char *data, int flags)
 801 {
 802         struct bio *nbp, *cbp, *pbp;
 803         off_t cstart, cend;
 804         u_char *tmpdata;
 805         int n;
 806
 807         GJ_DEBUG(3, "INSERT(%p): (%jd, %jd, %jd)", *head, nstart, nend,
 808             joffset);
 809         n = 0;
 810         pbp = NULL;
 811         GJQ_FOREACH(*head, cbp) {
 812                 cstart = cbp->bio_offset;
 813                 cend = cbp->bio_offset + cbp->bio_length;
 814
 815                 if (nstart >= cend) {
 816                         /*
 817                          *  +-------------+
 818                          *  |             |
 819                          *  |   current   |  +-------------+
 820                          *  |     bio     |  |             |
 821                          *  |             |  |     new     |
 822                          *  +-------------+  |     bio     |
 823                          *                   |             |
 824                          *                   +-------------+
 825                          */
 826                         GJ_DEBUG(3, "INSERT(%p): 1", *head);
 827                 } else if (nend <= cstart) {
 828                         /*
 829                          *                   +-------------+
 830                          *                   |             |
 831                          *  +-------------+  |   current   |
 832                          *  |             |  |     bio     |
 833                          *  |     new     |  |             |
 834                          *  |     bio     |  +-------------+
 835                          *  |             |
 836                          *  +-------------+
 837                          */
 838                         nbp = g_journal_new_bio(nstart, nend, joffset, data,
 839                             flags);
 840                         if (pbp == NULL)
 841                                 *head = nbp;
 842                         else
 843                                 pbp->bio_next = nbp;
 844                         nbp->bio_next = cbp;
 845                         n++;
 846                         GJ_DEBUG(3, "INSERT(%p): 2 (nbp=%p pbp=%p)", *head, nbp,
 847                             pbp);
 848                         goto end;
 849                 } else if (nstart <= cstart && nend >= cend) {
 850                         /*
 851                          *      +-------------+      +-------------+
 852                          *      | current bio |      | current bio |
 853                          *  +---+-------------+---+  +-------------+---+
 854                          *  |   |             |   |  |             |   |
 855                          *  |   |             |   |  |             |   |
 856                          *  |   +-------------+   |  +-------------+   |
 857                          *  |       new bio       |  |     new bio     |
 858                          *  +---------------------+  +-----------------+
 859                          *
 860                          *      +-------------+  +-------------+
 861                          *      | current bio |  | current bio |
 862                          *  +---+-------------+  +-------------+
 863                          *  |   |             |  |             |
 864                          *  |   |             |  |             |
 865                          *  |   +-------------+  +-------------+
 866                          *  |     new bio     |  |   new bio   |
 867                          *  +-----------------+  +-------------+
 868                          */
 869                         g_journal_stats_bytes_skipped += cbp->bio_length;
 870                         cbp->bio_offset = nstart;
 871                         cbp->bio_joffset = joffset;
 872                         cbp->bio_length = cend - nstart;
 873                         if (cbp->bio_data != NULL) {
 874                                 gj_free(cbp->bio_data, cend - cstart);
 875                                 cbp->bio_data = NULL;
 876                         }
 877                         if (data != NULL) {
 878                                 cbp->bio_data = gj_malloc(cbp->bio_length,
 879                                     flags);
 880                                 if (cbp->bio_data != NULL) {
 881                                         bcopy(data, cbp->bio_data,
 882                                             cbp->bio_length);
 883                                 }
 884                                 data += cend - nstart;
 885                         }
 886                         joffset += cend - nstart;
 887                         nstart = cend;
 888                         GJ_DEBUG(3, "INSERT(%p): 3 (cbp=%p)", *head, cbp);
 889                 } else if (nstart > cstart && nend >= cend) {
 890                         /*
 891                          *  +-----------------+  +-------------+
 892                          *  |   current bio   |  | current bio |
 893                          *  |   +-------------+  |   +---------+---+
 894                          *  |   |             |  |   |         |   |
 895                          *  |   |             |  |   |         |   |
 896                          *  +---+-------------+  +---+---------+   |
 897                          *      |   new bio   |      |   new bio   |
 898                          *      +-------------+      +-------------+
 899                          */
 900                         g_journal_stats_bytes_skipped += cend - nstart;
 901                         nbp = g_journal_new_bio(nstart, cend, joffset, data,
 902                             flags);
 903                         nbp->bio_next = cbp->bio_next;
 904                         cbp->bio_next = nbp;
 905                         cbp->bio_length = nstart - cstart;
 906                         if (cbp->bio_data != NULL) {
 907                                 cbp->bio_data = gj_realloc(cbp->bio_data,
 908                                     cbp->bio_length, cend - cstart);
 909                         }
 910                         if (data != NULL)
 911                                 data += cend - nstart;
 912                         joffset += cend - nstart;
 913                         nstart = cend;
 914                         n++;
 915                         GJ_DEBUG(3, "INSERT(%p): 4 (cbp=%p)", *head, cbp);
 916                 } else if (nstart > cstart && nend < cend) {
 917                         /*
 918                          *  +---------------------+
 919                          *  |     current bio     |
 920                          *  |   +-------------+   |
 921                          *  |   |             |   |
 922                          *  |   |             |   |
 923                          *  +---+-------------+---+
 924                          *      |   new bio   |
 925                          *      +-------------+
 926                          */
 927                         g_journal_stats_bytes_skipped += nend - nstart;
 928                         nbp = g_journal_new_bio(nstart, nend, joffset, data,
 929                             flags);
 930                         nbp->bio_next = cbp->bio_next;
 931                         cbp->bio_next = nbp;
 932                         if (cbp->bio_data == NULL)
 933                                 tmpdata = NULL;
 934                         else
 935                                 tmpdata = cbp->bio_data + nend - cstart;
 936                         nbp = g_journal_new_bio(nend, cend,
 937                             cbp->bio_joffset + nend - cstart, tmpdata, flags);
 938                         nbp->bio_next = ((struct bio *)cbp->bio_next)->bio_next;
 939                         ((struct bio *)cbp->bio_next)->bio_next = nbp;
 940                         cbp->bio_length = nstart - cstart;
 941                         if (cbp->bio_data != NULL) {
 942                                 cbp->bio_data = gj_realloc(cbp->bio_data,
 943                                     cbp->bio_length, cend - cstart);
 944                         }
 945                         n += 2;
 946                         GJ_DEBUG(3, "INSERT(%p): 5 (cbp=%p)", *head, cbp);
 947                         goto end;
 948                 } else if (nstart <= cstart && nend < cend) {
 949                         /*
 950                          *  +-----------------+      +-------------+
 951                          *  |   current bio   |      | current bio |
 952                          *  +-------------+   |  +---+---------+   |
 953                          *  |             |   |  |   |         |   |
 954                          *  |             |   |  |   |         |   |
 955                          *  +-------------+---+  |   +---------+---+
 956                          *  |   new bio   |      |   new bio   |
 957                          *  +-------------+      +-------------+
 958                          */
 959                         g_journal_stats_bytes_skipped += nend - nstart;
 960                         nbp = g_journal_new_bio(nstart, nend, joffset, data,
 961                             flags);
 962                         if (pbp == NULL)
 963                                 *head = nbp;
 964                         else
 965                                 pbp->bio_next = nbp;
 966                         nbp->bio_next = cbp;
 967                         cbp->bio_offset = nend;
 968                         cbp->bio_length = cend - nend;
 969                         cbp->bio_joffset += nend - cstart;
 970                         tmpdata = cbp->bio_data;
 971                         if (tmpdata != NULL) {
 972                                 cbp->bio_data = gj_malloc(cbp->bio_length,
 973                                     flags);
 974                                 if (cbp->bio_data != NULL) {
 975                                         bcopy(tmpdata + nend - cstart,
 976                                             cbp->bio_data, cbp->bio_length);
 977                                 }
 978                                 gj_free(tmpdata, cend - cstart);
 979                         }
 980                         n++;
 981                         GJ_DEBUG(3, "INSERT(%p): 6 (cbp=%p)", *head, cbp);
 982                         goto end;
 983                 }
 984                 if (nstart == nend)
 985                         goto end;
 986                 pbp = cbp;
 987         }
 988         nbp = g_journal_new_bio(nstart, nend, joffset, data, flags);
 989         if (pbp == NULL)
 990                 *head = nbp;
 991         else
 992                 pbp->bio_next = nbp;
 993         nbp->bio_next = NULL;
 994         n++;
 995         GJ_DEBUG(3, "INSERT(%p): 8 (nbp=%p pbp=%p)", *head, nbp, pbp);
 996 end:
 997         if (g_journal_debug >= 3) {
 998                 GJQ_FOREACH(*head, cbp) {
 999                         GJ_DEBUG(3, "ELEMENT: %p (%jd, %jd, %jd, %p)", cbp,
1000                             (intmax_t)cbp->bio_offset,
1001                             (intmax_t)cbp->bio_length,
1002                             (intmax_t)cbp->bio_joffset, cbp->bio_data);
1003                 }
1004                 GJ_DEBUG(3, "INSERT(%p): DONE %d", *head, n);
1005         }
1006         return (n);
1007 }
1008
1009 /*
1010  * The function combines neighbour bios trying to squeeze as much data as
1011  * possible into one bio.
1012  *
1013  * The function returns the number of bios combined (negative value).
1014  */
1015 static int
1016 g_journal_optimize(struct bio *head)
1017 {
1018         struct bio *cbp, *pbp;
1019         int n;
1020
1021         n = 0;
1022         pbp = NULL;
1023         GJQ_FOREACH(head, cbp) {
1024                 /* Skip bios which has to be read first. */
1025                 if (cbp->bio_data == NULL) {
1026                         pbp = NULL;
1027                         continue;
1028                 }
1029                 /* There is no previous bio yet. */
1030                 if (pbp == NULL) {
1031                         pbp = cbp;
1032                         continue;
1033                 }
1034                 /* Is this a neighbour bio? */
1035                 if (pbp->bio_offset + pbp->bio_length != cbp->bio_offset) {
1036                         /* Be sure that bios queue is sorted. */
1037                         KASSERT(pbp->bio_offset + pbp->bio_length < cbp->bio_offset,
1038                             ("poffset=%jd plength=%jd coffset=%jd",
1039                             (intmax_t)pbp->bio_offset,
1040                             (intmax_t)pbp->bio_length,
1041                             (intmax_t)cbp->bio_offset));
1042                         pbp = cbp;
1043                         continue;
1044                 }
1045                 /* Be sure we don't end up with too big bio. */
1046                 if (pbp->bio_length + cbp->bio_length > MAXPHYS) {
1047                         pbp = cbp;
1048                         continue;
1049                 }
1050                 /* Ok, we can join bios. */
1051                 GJ_LOGREQ(4, pbp, "Join: ");
1052                 GJ_LOGREQ(4, cbp, "and: ");
1053                 pbp->bio_data = gj_realloc(pbp->bio_data,
1054                     pbp->bio_length + cbp->bio_length, pbp->bio_length);
1055                 bcopy(cbp->bio_data, pbp->bio_data + pbp->bio_length,
1056                     cbp->bio_length);
1057                 gj_free(cbp->bio_data, cbp->bio_length);
1058                 pbp->bio_length += cbp->bio_length;
1059                 pbp->bio_next = cbp->bio_next;
1060                 g_destroy_bio(cbp);
1061                 cbp = pbp;
1062                 g_journal_stats_combined_ios++;
1063                 n--;
1064                 GJ_LOGREQ(4, pbp, "Got: ");
1065         }
1066         return (n);
1067 }
1068
1069 /*
1070  * TODO: Update comment.
1071  * These are functions responsible for copying one portion of data from journal
1072  * to the destination provider.
1073  * The order goes like this:
1074  * 1. Read the header, which contains informations about data blocks
1075  *    following it.
1076  * 2. Read the data blocks from the journal.
1077  * 3. Write the data blocks on the data provider.
1078  *
1079  * g_journal_copy_start()
1080  * g_journal_copy_done() - got finished write request, logs potential errors.
1081  */
1082
1083 /*
1084  * When there is no data in cache, this function is used to read it.
1085  */
1086 static void
1087 g_journal_read_first(struct g_journal_softc *sc, struct bio *bp)
1088 {
1089         struct bio *cbp;
1090
1091         /*
1092          * We were short in memory, so data was freed.
1093          * In that case we need to read it back from journal.
1094          */
1095         cbp = g_alloc_bio();
1096         cbp->bio_cflags = bp->bio_cflags;
1097         cbp->bio_parent = bp;
1098         cbp->bio_offset = bp->bio_joffset;
1099         cbp->bio_length = bp->bio_length;
1100         cbp->bio_data = gj_malloc(bp->bio_length, M_WAITOK);
1101         cbp->bio_cmd = BIO_READ;
1102         cbp->bio_done = g_journal_std_done;
1103         GJ_LOGREQ(4, cbp, "READ FIRST");
1104         g_io_request(cbp, sc->sc_jconsumer);
1105         g_journal_cache_misses++;
1106 }
1107
1108 static void
1109 g_journal_copy_send(struct g_journal_softc *sc)
1110 {
1111         struct bio *bioq, *bp, *lbp;
1112
1113         bioq = lbp = NULL;
1114         mtx_lock(&sc->sc_mtx);
1115         for (; sc->sc_copy_in_progress < g_journal_parallel_copies;) {
1116                 bp = GJQ_FIRST(sc->sc_inactive.jj_queue);
1117                 if (bp == NULL)
1118                         break;
1119                 GJQ_REMOVE(sc->sc_inactive.jj_queue, bp);
1120                 sc->sc_copy_in_progress++;
1121                 GJQ_INSERT_AFTER(bioq, bp, lbp);
1122                 lbp = bp;
1123         }
1124         mtx_unlock(&sc->sc_mtx);
1125         if (g_journal_do_optimize)
1126                 sc->sc_copy_in_progress += g_journal_optimize(bioq);
1127         while ((bp = GJQ_FIRST(bioq)) != NULL) {
1128                 GJQ_REMOVE(bioq, bp);
1129                 GJQ_INSERT_HEAD(sc->sc_copy_queue, bp);
1130                 bp->bio_cflags = GJ_BIO_COPY;
1131                 if (bp->bio_data == NULL)
1132                         g_journal_read_first(sc, bp);
1133                 else {
1134                         bp->bio_joffset = 0;
1135                         GJ_LOGREQ(4, bp, "SEND");
1136                         g_io_request(bp, sc->sc_dconsumer);
1137                 }
1138         }
1139 }
1140
1141 static void
1142 g_journal_copy_start(struct g_journal_softc *sc)
1143 {
1144
1145         /*
1146          * Remember in metadata that we're starting to copy journaled data
1147          * to the data provider.
1148          * In case of power failure, we will copy these data once again on boot.
1149          */
1150         if (!sc->sc_journal_copying) {
1151                 sc->sc_journal_copying = 1;
1152                 GJ_DEBUG(1, "Starting copy of journal.");
1153                 g_journal_metadata_update(sc);
1154         }
1155         g_journal_copy_send(sc);
1156 }
1157
1158 /*
1159  * Data block has been read from the journal provider.
1160  */
1161 static int
1162 g_journal_copy_read_done(struct bio *bp)
1163 {
1164         struct g_journal_softc *sc;
1165         struct g_consumer *cp;
1166         struct bio *pbp;
1167
1168         KASSERT(bp->bio_cflags == GJ_BIO_COPY,
1169             ("Invalid bio (%d != %d).", bp->bio_cflags, GJ_BIO_COPY));
1170
1171         sc = bp->bio_from->geom->softc;
1172         pbp = bp->bio_parent;
1173
1174         if (bp->bio_error != 0) {
1175                 GJ_DEBUG(0, "Error while reading data from %s (error=%d).",
1176                     bp->bio_to->name, bp->bio_error);
1177                 /*
1178                  * We will not be able to deliver WRITE request as well.
1179                  */
1180                 gj_free(bp->bio_data, bp->bio_length);
1181                 g_destroy_bio(pbp);
1182                 g_destroy_bio(bp);
1183                 sc->sc_copy_in_progress--;
1184                 return (1);
1185         }
1186         pbp->bio_data = bp->bio_data;
1187         cp = sc->sc_dconsumer;
1188         g_io_request(pbp, cp);
1189         GJ_LOGREQ(4, bp, "READ DONE");
1190         g_destroy_bio(bp);
1191         return (0);
1192 }
1193
1194 /*
1195  * Data block has been written to the data provider.
1196  */
1197 static void
1198 g_journal_copy_write_done(struct bio *bp)
1199 {
1200         struct g_journal_softc *sc;
1201
1202         KASSERT(bp->bio_cflags == GJ_BIO_COPY,
1203             ("Invalid bio (%d != %d).", bp->bio_cflags, GJ_BIO_COPY));
1204
1205         sc = bp->bio_from->geom->softc;
1206         sc->sc_copy_in_progress--;
1207
1208         if (bp->bio_error != 0) {
1209                 GJ_LOGREQ(0, bp, "[copy] Error while writing data (error=%d)",
1210                     bp->bio_error);
1211         }
1212         GJQ_REMOVE(sc->sc_copy_queue, bp);
1213         gj_free(bp->bio_data, bp->bio_length);
1214         GJ_LOGREQ(4, bp, "DONE");
1215         g_destroy_bio(bp);
1216
1217         if (sc->sc_copy_in_progress == 0) {
1218                 /*
1219                  * This was the last write request for this journal.
1220                  */
1221                 GJ_DEBUG(1, "Data has been copied.");
1222                 sc->sc_journal_copying = 0;
1223         }
1224 }
1225
1226 static void g_journal_flush_done(struct bio *bp);
1227
1228 /*
1229  * Flush one record onto active journal provider.
1230  */
1231 static void
1232 g_journal_flush(struct g_journal_softc *sc)
1233 {
1234         struct g_journal_record_header hdr;
1235         struct g_journal_entry *ent;
1236         struct g_provider *pp;
1237         struct bio **bioq;
1238         struct bio *bp, *fbp, *pbp;
1239         off_t joffset, size;
1240         u_char *data, hash[16];
1241         MD5_CTX ctx;
1242         u_int i;
1243
1244         if (sc->sc_current_count == 0)
1245                 return;
1246
1247         size = 0;
1248         pp = sc->sc_jprovider;
1249         GJ_VALIDATE_OFFSET(sc->sc_journal_offset, sc);
1250         joffset = sc->sc_journal_offset;
1251
1252         GJ_DEBUG(2, "Storing %d journal entries on %s at %jd.",
1253             sc->sc_current_count, pp->name, (intmax_t)joffset);
1254
1255         /*
1256          * Store 'journal id', so we know to which journal this record belongs.
1257          */
1258         hdr.jrh_journal_id = sc->sc_journal_id;
1259         /* Could be less than g_journal_record_entries if called due timeout. */
1260         hdr.jrh_nentries = MIN(sc->sc_current_count, g_journal_record_entries);
1261         strlcpy(hdr.jrh_magic, GJ_RECORD_HEADER_MAGIC, sizeof(hdr.jrh_magic));
1262
1263         bioq = &sc->sc_active.jj_queue;
1264         pbp = sc->sc_flush_queue;
1265
1266         fbp = g_alloc_bio();
1267         fbp->bio_parent = NULL;
1268         fbp->bio_cflags = GJ_BIO_JOURNAL;
1269         fbp->bio_offset = -1;
1270         fbp->bio_joffset = joffset;
1271         fbp->bio_length = pp->sectorsize;
1272         fbp->bio_cmd = BIO_WRITE;
1273         fbp->bio_done = g_journal_std_done;
1274         GJQ_INSERT_AFTER(sc->sc_flush_queue, fbp, pbp);
1275         pbp = fbp;
1276         fbp->bio_to = pp;
1277         GJ_LOGREQ(4, fbp, "FLUSH_OUT");
1278         joffset += pp->sectorsize;
1279         sc->sc_flush_count++;
1280         if (sc->sc_flags & GJF_DEVICE_CHECKSUM)
1281                 MD5Init(&ctx);
1282
1283         for (i = 0; i < hdr.jrh_nentries; i++) {
1284                 bp = sc->sc_current_queue;
1285                 KASSERT(bp != NULL, ("NULL bp"));
1286                 bp->bio_to = pp;
1287                 GJ_LOGREQ(4, bp, "FLUSHED");
1288                 sc->sc_current_queue = bp->bio_next;
1289                 bp->bio_next = NULL;
1290                 sc->sc_current_count--;
1291
1292                 /* Add to the header. */
1293                 ent = &hdr.jrh_entries[i];
1294                 ent->je_offset = bp->bio_offset;
1295                 ent->je_joffset = joffset;
1296                 ent->je_length = bp->bio_length;
1297                 size += ent->je_length;
1298
1299                 data = bp->bio_data;
1300                 if (sc->sc_flags & GJF_DEVICE_CHECKSUM)
1301                         MD5Update(&ctx, data, ent->je_length);
1302                 g_reset_bio(bp);
1303                 bp->bio_cflags = GJ_BIO_JOURNAL;
1304                 bp->bio_offset = ent->je_offset;
1305                 bp->bio_joffset = ent->je_joffset;
1306                 bp->bio_length = ent->je_length;
1307                 bp->bio_data = data;
1308                 bp->bio_cmd = BIO_WRITE;
1309                 bp->bio_done = g_journal_std_done;
1310                 GJQ_INSERT_AFTER(sc->sc_flush_queue, bp, pbp);
1311                 pbp = bp;
1312                 bp->bio_to = pp;
1313                 GJ_LOGREQ(4, bp, "FLUSH_OUT");
1314                 joffset += bp->bio_length;
1315                 sc->sc_flush_count++;
1316
1317                 /*
1318                  * Add request to the active sc_journal_queue queue.
1319                  * This is our cache. After journal switch we don't have to
1320                  * read the data from the inactive journal, because we keep
1321                  * it in memory.
1322                  */
1323                 g_journal_insert(bioq, ent->je_offset,
1324                     ent->je_offset + ent->je_length, ent->je_joffset, data,
1325                     M_NOWAIT);
1326         }
1327
1328         /*
1329          * After all requests, store valid header.
1330          */
1331         data = gj_malloc(pp->sectorsize, M_WAITOK);
1332         if (sc->sc_flags & GJF_DEVICE_CHECKSUM) {
1333                 MD5Final(hash, &ctx);
1334                 bcopy(hash, hdr.jrh_sum, sizeof(hdr.jrh_sum));
1335         }
1336         g_journal_record_header_encode(&hdr, data);
1337         fbp->bio_data = data;
1338
1339         sc->sc_journal_offset = joffset;
1340
1341         g_journal_check_overflow(sc);
1342 }
1343
1344 /*
1345  * Flush request finished.
1346  */
1347 static void
1348 g_journal_flush_done(struct bio *bp)
1349 {
1350         struct g_journal_softc *sc;
1351         struct g_consumer *cp;
1352
1353         KASSERT((bp->bio_cflags & GJ_BIO_MASK) == GJ_BIO_JOURNAL,
1354             ("Invalid bio (%d != %d).", bp->bio_cflags, GJ_BIO_JOURNAL));
1355
1356         cp = bp->bio_from;
1357         sc = cp->geom->softc;
1358         sc->sc_flush_in_progress--;
1359
1360         if (bp->bio_error != 0) {
1361                 GJ_LOGREQ(0, bp, "[flush] Error while writing data (error=%d)",
1362                     bp->bio_error);
1363         }
1364         gj_free(bp->bio_data, bp->bio_length);
1365         GJ_LOGREQ(4, bp, "DONE");
1366         g_destroy_bio(bp);
1367 }
1368
1369 static void g_journal_release_delayed(struct g_journal_softc *sc);
1370
1371 static void
1372 g_journal_flush_send(struct g_journal_softc *sc)
1373 {
1374         struct g_consumer *cp;
1375         struct bio *bioq, *bp, *lbp;
1376
1377         cp = sc->sc_jconsumer;
1378         bioq = lbp = NULL;
1379         while (sc->sc_flush_in_progress < g_journal_parallel_flushes) {
1380                 /* Send one flush requests to the active journal. */
1381                 bp = GJQ_FIRST(sc->sc_flush_queue);
1382                 if (bp != NULL) {
1383                         GJQ_REMOVE(sc->sc_flush_queue, bp);
1384                         sc->sc_flush_count--;
1385                         bp->bio_offset = bp->bio_joffset;
1386                         bp->bio_joffset = 0;
1387                         sc->sc_flush_in_progress++;
1388                         GJQ_INSERT_AFTER(bioq, bp, lbp);
1389                         lbp = bp;
1390                 }
1391                 /* Try to release delayed requests. */
1392                 g_journal_release_delayed(sc);
1393                 /* If there are no requests to flush, leave. */
1394                 if (GJQ_FIRST(sc->sc_flush_queue) == NULL)
1395                         break;
1396         }
1397         if (g_journal_do_optimize)
1398                 sc->sc_flush_in_progress += g_journal_optimize(bioq);
1399         while ((bp = GJQ_FIRST(bioq)) != NULL) {
1400                 GJQ_REMOVE(bioq, bp);
1401                 GJ_LOGREQ(3, bp, "Flush request send");
1402                 g_io_request(bp, cp);
1403         }
1404 }
1405
1406 static void
1407 g_journal_add_current(struct g_journal_softc *sc, struct bio *bp)
1408 {
1409         int n;
1410
1411         GJ_LOGREQ(4, bp, "CURRENT %d", sc->sc_current_count);
1412         n = g_journal_insert_bio(&sc->sc_current_queue, bp, M_WAITOK);
1413         sc->sc_current_count += n;
1414         n = g_journal_optimize(sc->sc_current_queue);
1415         sc->sc_current_count += n;
1416         /*
1417          * For requests which are added to the current queue we deliver
1418          * response immediately.
1419          */
1420         bp->bio_completed = bp->bio_length;
1421         g_io_deliver(bp, 0);
1422         if (sc->sc_current_count >= g_journal_record_entries) {
1423                 /*
1424                  * Let's flush one record onto active journal provider.
1425                  */
1426                 g_journal_flush(sc);
1427         }
1428 }
1429
1430 static void
1431 g_journal_release_delayed(struct g_journal_softc *sc)
1432 {
1433         struct bio *bp;
1434
1435         for (;;) {
1436                 /* The flush queue is full, exit. */
1437                 if (sc->sc_flush_count >= g_journal_accept_immediately)
1438                         return;
1439                 bp = bioq_takefirst(&sc->sc_delayed_queue);
1440                 if (bp == NULL)
1441                         return;
1442                 sc->sc_delayed_count--;
1443                 g_journal_add_current(sc, bp);
1444         }
1445 }
1446
1447 /*
1448  * Add I/O request to the current queue. If we have enough requests for one
1449  * journal record we flush them onto active journal provider.
1450  */
1451 static void
1452 g_journal_add_request(struct g_journal_softc *sc, struct bio *bp)
1453 {
1454
1455         /*
1456          * The flush queue is full, we need to delay the request.
1457          */
1458         if (sc->sc_delayed_count > 0 ||
1459             sc->sc_flush_count >= g_journal_accept_immediately) {
1460                 GJ_LOGREQ(4, bp, "DELAYED");
1461                 bioq_insert_tail(&sc->sc_delayed_queue, bp);
1462                 sc->sc_delayed_count++;
1463                 return;
1464         }
1465
1466         KASSERT(TAILQ_EMPTY(&sc->sc_delayed_queue.queue),
1467             ("DELAYED queue not empty."));
1468         g_journal_add_current(sc, bp);
1469 }
1470
1471 static void g_journal_read_done(struct bio *bp);
1472
1473 /*
1474  * Try to find requested data in cache.
1475  */
1476 static struct bio *
1477 g_journal_read_find(struct bio *head, int sorted, struct bio *pbp, off_t ostart,
1478     off_t oend)
1479 {
1480         off_t cstart, cend;
1481         struct bio *bp;
1482
1483         GJQ_FOREACH(head, bp) {
1484                 if (bp->bio_offset == -1)
1485                         continue;
1486                 cstart = MAX(ostart, bp->bio_offset);
1487                 cend = MIN(oend, bp->bio_offset + bp->bio_length);
1488                 if (cend <= ostart)
1489                         continue;
1490                 else if (cstart >= oend) {
1491                         if (!sorted)
1492                                 continue;
1493                         else {
1494                                 bp = NULL;
1495                                 break;
1496                         }
1497                 }
1498                 if (bp->bio_data == NULL)
1499                         break;
1500                 GJ_DEBUG(3, "READ(%p): (%jd, %jd) (bp=%p)", head, cstart, cend,
1501                     bp);
1502                 bcopy(bp->bio_data + cstart - bp->bio_offset,
1503                     pbp->bio_data + cstart - pbp->bio_offset, cend - cstart);
1504                 pbp->bio_completed += cend - cstart;
1505                 if (pbp->bio_completed == pbp->bio_length) {
1506                         /*
1507                          * Cool, the whole request was in cache, deliver happy
1508                          * message.
1509                          */
1510                         g_io_deliver(pbp, 0);
1511                         return (pbp);
1512                 }
1513                 break;
1514         }
1515         return (bp);
1516 }
1517
1518 /*
1519  * Try to find requested data in cache.
1520  */
1521 static struct bio *
1522 g_journal_read_queue_find(struct bio_queue *head, struct bio *pbp, off_t ostart,
1523     off_t oend)
1524 {
1525         off_t cstart, cend;
1526         struct bio *bp;
1527
1528         TAILQ_FOREACH(bp, head, bio_queue) {
1529                 cstart = MAX(ostart, bp->bio_offset);
1530                 cend = MIN(oend, bp->bio_offset + bp->bio_length);
1531                 if (cend <= ostart)
1532                         continue;
1533                 else if (cstart >= oend)
1534                         continue;
1535                 KASSERT(bp->bio_data != NULL,
1536                     ("%s: bio_data == NULL", __func__));
1537                 GJ_DEBUG(3, "READ(%p): (%jd, %jd) (bp=%p)", head, cstart, cend,
1538                     bp);
1539                 bcopy(bp->bio_data + cstart - bp->bio_offset,
1540                     pbp->bio_data + cstart - pbp->bio_offset, cend - cstart);
1541                 pbp->bio_completed += cend - cstart;
1542                 if (pbp->bio_completed == pbp->bio_length) {
1543                         /*
1544                          * Cool, the whole request was in cache, deliver happy
1545                          * message.
1546                          */
1547                         g_io_deliver(pbp, 0);
1548                         return (pbp);
1549                 }
1550                 break;
1551         }
1552         return (bp);
1553 }
1554
1555 /*
1556  * This function is used for colecting data on read.
1557  * The complexity is because parts of the data can be stored in four different
1558  * places:
1559  * - in delayed requests
1560  * - in memory - the data not yet send to the active journal provider
1561  * - in requests which are going to be sent to the active journal
1562  * - in the active journal
1563  * - in the inactive journal
1564  * - in the data provider
1565  */
1566 static void
1567 g_journal_read(struct g_journal_softc *sc, struct bio *pbp, off_t ostart,
1568     off_t oend)
1569 {
1570         struct bio *bp, *nbp, *head;
1571         off_t cstart, cend;
1572         u_int i, sorted = 0;
1573
1574         GJ_DEBUG(3, "READ: (%jd, %jd)", ostart, oend);
1575
1576         cstart = cend = -1;
1577         bp = NULL;
1578         head = NULL;
1579         for (i = 0; i <= 5; i++) {
1580                 switch (i) {
1581                 case 0: /* Delayed requests. */
1582                         head = NULL;
1583                         sorted = 0;
1584                         break;
1585                 case 1: /* Not-yet-send data. */
1586                         head = sc->sc_current_queue;
1587                         sorted = 1;
1588                         break;
1589                 case 2: /* In-flight to the active journal. */
1590                         head = sc->sc_flush_queue;
1591                         sorted = 0;
1592                         break;
1593                 case 3: /* Active journal. */
1594                         head = sc->sc_active.jj_queue;
1595                         sorted = 1;
1596                         break;
1597                 case 4: /* Inactive journal. */
1598                         /*
1599                          * XXX: Here could be a race with g_journal_lowmem().
1600                          */
1601                         head = sc->sc_inactive.jj_queue;
1602                         sorted = 1;
1603                         break;
1604                 case 5: /* In-flight to the data provider. */
1605                         head = sc->sc_copy_queue;
1606                         sorted = 0;
1607                         break;
1608                 default:
1609                         panic("gjournal %s: i=%d", __func__, i);
1610                 }
1611                 if (i == 0)
1612                         bp = g_journal_read_queue_find(&sc->sc_delayed_queue.queue, pbp, ostart, oend);
1613                 else
1614                         bp = g_journal_read_find(head, sorted, pbp, ostart, oend);
1615                 if (bp == pbp) { /* Got the whole request. */
1616                         GJ_DEBUG(2, "Got the whole request from %u.", i);
1617                         return;
1618                 } else if (bp != NULL) {
1619                         cstart = MAX(ostart, bp->bio_offset);
1620                         cend = MIN(oend, bp->bio_offset + bp->bio_length);
1621                         GJ_DEBUG(2, "Got part of the request from %u (%jd-%jd).",
1622                             i, (intmax_t)cstart, (intmax_t)cend);
1623                         break;
1624                 }
1625         }
1626         if (bp != NULL) {
1627                 if (bp->bio_data == NULL) {
1628                         nbp = g_duplicate_bio(pbp);
1629                         nbp->bio_cflags = GJ_BIO_READ;
1630                         nbp->bio_data =
1631                             pbp->bio_data + cstart - pbp->bio_offset;
1632                         nbp->bio_offset =
1633                             bp->bio_joffset + cstart - bp->bio_offset;
1634                         nbp->bio_length = cend - cstart;
1635                         nbp->bio_done = g_journal_read_done;
1636                         g_io_request(nbp, sc->sc_jconsumer);
1637                 }
1638                 /*
1639                  * If we don't have the whole request yet, call g_journal_read()
1640                  * recursively.
1641                  */
1642                 if (ostart < cstart)
1643                         g_journal_read(sc, pbp, ostart, cstart);
1644                 if (oend > cend)
1645                         g_journal_read(sc, pbp, cend, oend);
1646         } else {
1647                 /*
1648                  * No data in memory, no data in journal.
1649                  * Its time for asking data provider.
1650                  */
1651                 GJ_DEBUG(3, "READ(data): (%jd, %jd)", ostart, oend);
1652                 nbp = g_duplicate_bio(pbp);
1653                 nbp->bio_cflags = GJ_BIO_READ;
1654                 nbp->bio_data = pbp->bio_data + ostart - pbp->bio_offset;
1655                 nbp->bio_offset = ostart;
1656                 nbp->bio_length = oend - ostart;
1657                 nbp->bio_done = g_journal_read_done;
1658                 g_io_request(nbp, sc->sc_dconsumer);
1659                 /* We have the whole request, return here. */
1660                 return;
1661         }
1662 }
1663
1664 /*
1665  * Function responsible for handling finished READ requests.
1666  * Actually, g_std_done() could be used here, the only difference is that we
1667  * log error.
1668  */
1669 static void
1670 g_journal_read_done(struct bio *bp)
1671 {
1672         struct bio *pbp;
1673
1674         KASSERT(bp->bio_cflags == GJ_BIO_READ,
1675             ("Invalid bio (%d != %d).", bp->bio_cflags, GJ_BIO_READ));
1676
1677         pbp = bp->bio_parent;
1678         pbp->bio_inbed++;
1679         pbp->bio_completed += bp->bio_length;
1680
1681         if (bp->bio_error != 0) {
1682                 if (pbp->bio_error == 0)
1683                         pbp->bio_error = bp->bio_error;
1684                 GJ_DEBUG(0, "Error while reading data from %s (error=%d).",
1685                     bp->bio_to->name, bp->bio_error);
1686         }
1687         g_destroy_bio(bp);
1688         if (pbp->bio_children == pbp->bio_inbed &&
1689             pbp->bio_completed == pbp->bio_length) {
1690                 /* We're done. */
1691                 g_io_deliver(pbp, 0);
1692         }
1693 }
1694
1695 /*
1696  * Deactive current journal and active next one.
1697  */
1698 static void
1699 g_journal_switch(struct g_journal_softc *sc)
1700 {
1701         struct g_provider *pp;
1702
1703         if (JEMPTY(sc)) {
1704                 GJ_DEBUG(3, "No need for %s switch.", sc->sc_name);
1705                 pp = LIST_FIRST(&sc->sc_geom->provider);
1706                 if (!(sc->sc_flags & GJF_DEVICE_CLEAN) && pp->acw == 0) {
1707                         sc->sc_flags |= GJF_DEVICE_CLEAN;
1708                         GJ_DEBUG(1, "Marking %s as clean.", sc->sc_name);
1709                         g_journal_metadata_update(sc);
1710                 }
1711         } else {
1712                 GJ_DEBUG(3, "Switching journal %s.", sc->sc_geom->name);
1713
1714                 pp = sc->sc_jprovider;
1715
1716                 sc->sc_journal_previous_id = sc->sc_journal_id;
1717
1718                 sc->sc_journal_id = sc->sc_journal_next_id;
1719                 sc->sc_journal_next_id = arc4random();
1720
1721                 GJ_VALIDATE_OFFSET(sc->sc_journal_offset, sc);
1722
1723                 g_journal_write_header(sc);
1724
1725                 sc->sc_inactive.jj_offset = sc->sc_active.jj_offset;
1726                 sc->sc_inactive.jj_queue = sc->sc_active.jj_queue;
1727
1728                 sc->sc_active.jj_offset =
1729                     sc->sc_journal_offset - pp->sectorsize;
1730                 sc->sc_active.jj_queue = NULL;
1731
1732                 /*
1733                  * Switch is done, start copying data from the (now) inactive
1734                  * journal to the data provider.
1735                  */
1736                 g_journal_copy_start(sc);
1737         }
1738         mtx_lock(&sc->sc_mtx);
1739         sc->sc_flags &= ~GJF_DEVICE_SWITCH;
1740         mtx_unlock(&sc->sc_mtx);
1741 }
1742
1743 static void
1744 g_journal_initialize(struct g_journal_softc *sc)
1745 {
1746
1747         sc->sc_journal_id = arc4random();
1748         sc->sc_journal_next_id = arc4random();
1749         sc->sc_journal_previous_id = sc->sc_journal_id;
1750         sc->sc_journal_offset = sc->sc_jstart;
1751         sc->sc_inactive.jj_offset = sc->sc_jstart;
1752         g_journal_write_header(sc);
1753         sc->sc_active.jj_offset = sc->sc_jstart;
1754 }
1755
1756 static void
1757 g_journal_mark_as_dirty(struct g_journal_softc *sc)
1758 {
1759         const struct g_journal_desc *desc;
1760         int i;
1761
1762         GJ_DEBUG(1, "Marking file system %s as dirty.", sc->sc_name);
1763         for (i = 0; (desc = g_journal_filesystems[i]) != NULL; i++)
1764                 desc->jd_dirty(sc->sc_dconsumer);
1765 }
1766
1767 /*
1768  * Function read record header from the given journal.
1769  * It is very simlar to g_read_data(9), but it doesn't allocate memory for bio
1770  * and data on every call.
1771  */
1772 static int
1773 g_journal_sync_read(struct g_consumer *cp, struct bio *bp, off_t offset,
1774     void *data)
1775 {
1776         int error;
1777
1778         g_reset_bio(bp);
1779         bp->bio_cmd = BIO_READ;
1780         bp->bio_done = NULL;
1781         bp->bio_offset = offset;
1782         bp->bio_length = cp->provider->sectorsize;
1783         bp->bio_data = data;
1784         g_io_request(bp, cp);
1785         error = biowait(bp, "gjs_read");
1786         return (error);
1787 }
1788
1789 #if 0
1790 /*
1791  * Function is called when we start the journal device and we detect that
1792  * one of the journals was not fully copied.
1793  * The purpose of this function is to read all records headers from journal
1794  * and placed them in the inactive queue, so we can start journal
1795  * synchronization process and the journal provider itself.
1796  * Design decision was taken to not synchronize the whole journal here as it
1797  * can take too much time. Reading headers only and delaying synchronization
1798  * process until after journal provider is started should be the best choice.
1799  */
1800 #endif
1801
1802 static void
1803 g_journal_sync(struct g_journal_softc *sc)
1804 {
1805         struct g_journal_record_header rhdr;
1806         struct g_journal_entry *ent;
1807         struct g_journal_header jhdr;
1808         struct g_consumer *cp;
1809         struct bio *bp, *fbp, *tbp;
1810         off_t joffset, offset;
1811         u_char *buf, sum[16];
1812         uint64_t id;
1813         MD5_CTX ctx;
1814         int error, found, i;
1815
1816         found = 0;
1817         fbp = NULL;
1818         cp = sc->sc_jconsumer;
1819         bp = g_alloc_bio();
1820         buf = gj_malloc(cp->provider->sectorsize, M_WAITOK);
1821         offset = joffset = sc->sc_inactive.jj_offset = sc->sc_journal_offset;
1822
1823         GJ_DEBUG(2, "Looking for termination at %jd.", (intmax_t)joffset);
1824
1825         /*
1826          * Read and decode first journal header.
1827          */
1828         error = g_journal_sync_read(cp, bp, offset, buf);
1829         if (error != 0) {
1830                 GJ_DEBUG(0, "Error while reading journal header from %s.",
1831                     cp->provider->name);
1832                 goto end;
1833         }
1834         error = g_journal_header_decode(buf, &jhdr);
1835         if (error != 0) {
1836                 GJ_DEBUG(0, "Cannot decode journal header from %s.",
1837                     cp->provider->name);
1838                 goto end;
1839         }
1840         id = sc->sc_journal_id;
1841         if (jhdr.jh_journal_id != sc->sc_journal_id) {
1842                 GJ_DEBUG(1, "Journal ID mismatch at %jd (0x%08x != 0x%08x).",
1843                     (intmax_t)offset, (u_int)jhdr.jh_journal_id, (u_int)id);
1844                 goto end;
1845         }
1846         offset += cp->provider->sectorsize;
1847         id = sc->sc_journal_next_id = jhdr.jh_journal_next_id;
1848
1849         for (;;) {
1850                 /*
1851                  * If the biggest record won't fit, look for a record header or
1852                  * journal header from the beginning.
1853                  */
1854                 GJ_VALIDATE_OFFSET(offset, sc);
1855                 error = g_journal_sync_read(cp, bp, offset, buf);
1856                 if (error != 0) {
1857                         /*
1858                          * Not good. Having an error while reading header
1859                          * means, that we cannot read next headers and in
1860                          * consequence we cannot find termination.
1861                          */
1862                         GJ_DEBUG(0,
1863                             "Error while reading record header from %s.",
1864                             cp->provider->name);
1865                         break;
1866                 }
1867
1868                 error = g_journal_record_header_decode(buf, &rhdr);
1869                 if (error != 0) {
1870                         GJ_DEBUG(2, "Not a record header at %jd (error=%d).",
1871                             (intmax_t)offset, error);
1872                         /*
1873                          * This is not a record header.
1874                          * If we are lucky, this is next journal header.
1875                          */
1876                         error = g_journal_header_decode(buf, &jhdr);
1877                         if (error != 0) {
1878                                 GJ_DEBUG(1, "Not a journal header at %jd (error=%d).",
1879                                     (intmax_t)offset, error);
1880                                 /*
1881                                  * Nope, this is not journal header, which
1882                                  * bascially means that journal is not
1883                                  * terminated properly.
1884                                  */
1885                                 error = ENOENT;
1886                                 break;
1887                         }
1888                         /*
1889                          * Ok. This is header of _some_ journal. Now we need to
1890                          * verify if this is header of the _next_ journal.
1891                          */
1892                         if (jhdr.jh_journal_id != id) {
1893                                 GJ_DEBUG(1, "Journal ID mismatch at %jd "
1894                                     "(0x%08x != 0x%08x).", (intmax_t)offset,
1895                                     (u_int)jhdr.jh_journal_id, (u_int)id);
1896                                 error = ENOENT;
1897                                 break;
1898                         }
1899
1900                         /* Found termination. */
1901                         found++;
1902                         GJ_DEBUG(1, "Found termination at %jd (id=0x%08x).",
1903                             (intmax_t)offset, (u_int)id);
1904                         sc->sc_active.jj_offset = offset;
1905                         sc->sc_journal_offset =
1906                             offset + cp->provider->sectorsize;
1907                         sc->sc_journal_id = id;
1908                         id = sc->sc_journal_next_id = jhdr.jh_journal_next_id;
1909
1910                         while ((tbp = fbp) != NULL) {
1911                                 fbp = tbp->bio_next;
1912                                 GJ_LOGREQ(3, tbp, "Adding request.");
1913                                 g_journal_insert_bio(&sc->sc_inactive.jj_queue,
1914                                     tbp, M_WAITOK);
1915                         }
1916
1917                         /* Skip journal's header. */
1918                         offset += cp->provider->sectorsize;
1919                         continue;
1920                 }
1921
1922                 /* Skip record's header. */
1923                 offset += cp->provider->sectorsize;
1924
1925                 /*
1926                  * Add information about every record entry to the inactive
1927                  * queue.
1928                  */
1929                 if (sc->sc_flags & GJF_DEVICE_CHECKSUM)
1930                         MD5Init(&ctx);
1931                 for (i = 0; i < rhdr.jrh_nentries; i++) {
1932                         ent = &rhdr.jrh_entries[i];
1933                         GJ_DEBUG(3, "Insert entry: %jd %jd.",
1934                             (intmax_t)ent->je_offset, (intmax_t)ent->je_length);
1935                         g_journal_insert(&fbp, ent->je_offset,
1936                             ent->je_offset + ent->je_length, ent->je_joffset,
1937                             NULL, M_WAITOK);
1938                         if (sc->sc_flags & GJF_DEVICE_CHECKSUM) {
1939                                 u_char *buf2;
1940
1941                                 /*
1942                                  * TODO: Should use faster function (like
1943                                  *       g_journal_sync_read()).
1944                                  */
1945                                 buf2 = g_read_data(cp, offset, ent->je_length,
1946                                     NULL);
1947                                 if (buf2 == NULL)
1948                                         GJ_DEBUG(0, "Cannot read data at %jd.",
1949                                             (intmax_t)offset);
1950                                 else {
1951                                         MD5Update(&ctx, buf2, ent->je_length);
1952                                         g_free(buf2);
1953                                 }
1954                         }
1955                         /* Skip entry's data. */
1956                         offset += ent->je_length;
1957                 }
1958                 if (sc->sc_flags & GJF_DEVICE_CHECKSUM) {
1959                         MD5Final(sum, &ctx);
1960                         if (bcmp(sum, rhdr.jrh_sum, sizeof(rhdr.jrh_sum)) != 0) {
1961                                 GJ_DEBUG(0, "MD5 hash mismatch at %jd!",
1962                                     (intmax_t)offset);
1963                         }
1964                 }
1965         }
1966 end:
1967         gj_free(bp->bio_data, cp->provider->sectorsize);
1968         g_destroy_bio(bp);
1969
1970         /* Remove bios from unterminated journal. */
1971         while ((tbp = fbp) != NULL) {
1972                 fbp = tbp->bio_next;
1973                 g_destroy_bio(tbp);
1974         }
1975
1976         if (found < 1 && joffset > 0) {
1977                 GJ_DEBUG(0, "Journal on %s is broken/corrupted. Initializing.",
1978                     sc->sc_name);
1979                 while ((tbp = sc->sc_inactive.jj_queue) != NULL) {
1980                         sc->sc_inactive.jj_queue = tbp->bio_next;
1981                         g_destroy_bio(tbp);
1982                 }
1983                 g_journal_initialize(sc);
1984                 g_journal_mark_as_dirty(sc);
1985         } else {
1986                 GJ_DEBUG(0, "Journal %s consistent.", sc->sc_name);
1987                 g_journal_copy_start(sc);
1988         }
1989 }
1990
1991 /*
1992  * Wait for requests.
1993  * If we have requests in the current queue, flush them after 3 seconds from the
1994  * last flush. In this way we don't wait forever (or for journal switch) with
1995  * storing not full records on journal.
1996  */
1997 static void
1998 g_journal_wait(struct g_journal_softc *sc, time_t last_write)
1999 {
2000         int error, timeout;
2001
2002         GJ_DEBUG(3, "%s: enter", __func__);
2003         if (sc->sc_current_count == 0) {
2004                 if (g_journal_debug < 2)
2005                         msleep(sc, &sc->sc_mtx, PRIBIO | PDROP, "gj:work", 0);
2006                 else {
2007                         /*
2008                          * If we have debug turned on, show number of elements
2009                          * in various queues.
2010                          */
2011                         for (;;) {
2012                                 error = msleep(sc, &sc->sc_mtx, PRIBIO,
2013                                     "gj:work", hz * 3);
2014                                 if (error == 0) {
2015                                         mtx_unlock(&sc->sc_mtx);
2016                                         break;
2017                                 }
2018                                 GJ_DEBUG(3, "Report: current count=%d",
2019                                     sc->sc_current_count);
2020                                 GJ_DEBUG(3, "Report: flush count=%d",
2021                                     sc->sc_flush_count);
2022                                 GJ_DEBUG(3, "Report: flush in progress=%d",
2023                                     sc->sc_flush_in_progress);
2024                                 GJ_DEBUG(3, "Report: copy in progress=%d",
2025                                     sc->sc_copy_in_progress);
2026                                 GJ_DEBUG(3, "Report: delayed=%d",
2027                                     sc->sc_delayed_count);
2028                         }
2029                 }
2030                 GJ_DEBUG(3, "%s: exit 1", __func__);
2031                 return;
2032         }
2033
2034         /*
2035          * Flush even not full records every 3 seconds.
2036          */
2037         timeout = (last_write + 3 - time_second) * hz;
2038         if (timeout <= 0) {
2039                 mtx_unlock(&sc->sc_mtx);
2040                 g_journal_flush(sc);
2041                 g_journal_flush_send(sc);
2042                 GJ_DEBUG(3, "%s: exit 2", __func__);
2043                 return;
2044         }
2045         error = msleep(sc, &sc->sc_mtx, PRIBIO | PDROP, "gj:work", timeout);
2046         if (error == EWOULDBLOCK)
2047                 g_journal_flush_send(sc);
2048         GJ_DEBUG(3, "%s: exit 3", __func__);
2049 }
2050
2051 /*
2052  * Worker thread.
2053  */
2054 static void
2055 g_journal_worker(void *arg)
2056 {
2057         struct g_journal_softc *sc;
2058         struct g_geom *gp;
2059         struct g_provider *pp;
2060         struct bio *bp;
2061         time_t last_write;
2062         int type;
2063
2064         thread_lock(curthread);
2065         sched_prio(curthread, PRIBIO);
2066         thread_unlock(curthread);
2067
2068         sc = arg;
2069         type = 0;       /* gcc */
2070
2071         if (sc->sc_flags & GJF_DEVICE_CLEAN) {
2072                 GJ_DEBUG(0, "Journal %s clean.", sc->sc_name);
2073                 g_journal_initialize(sc);
2074         } else {
2075                 g_journal_sync(sc);
2076         }
2077         /*
2078          * Check if we can use BIO_FLUSH.
2079          */
2080         sc->sc_bio_flush = 0;
2081         if (g_io_flush(sc->sc_jconsumer) == 0) {
2082                 sc->sc_bio_flush |= GJ_FLUSH_JOURNAL;
2083                 GJ_DEBUG(1, "BIO_FLUSH supported by %s.",
2084                     sc->sc_jconsumer->provider->name);
2085         } else {
2086                 GJ_DEBUG(0, "BIO_FLUSH not supported by %s.",
2087                     sc->sc_jconsumer->provider->name);
2088         }
2089         if (sc->sc_jconsumer != sc->sc_dconsumer) {
2090                 if (g_io_flush(sc->sc_dconsumer) == 0) {
2091                         sc->sc_bio_flush |= GJ_FLUSH_DATA;
2092                         GJ_DEBUG(1, "BIO_FLUSH supported by %s.",
2093                             sc->sc_dconsumer->provider->name);
2094                 } else {
2095                         GJ_DEBUG(0, "BIO_FLUSH not supported by %s.",
2096                             sc->sc_dconsumer->provider->name);
2097                 }
2098         }
2099
2100         gp = sc->sc_geom;
2101         g_topology_lock();
2102         pp = g_new_providerf(gp, "%s.journal", sc->sc_name);
2103         pp->mediasize = sc->sc_mediasize;
2104         /*
2105          * There could be a problem when data provider and journal providers
2106          * have different sectorsize, but such scenario is prevented on journal
2107          * creation.
2108          */
2109         pp->sectorsize = sc->sc_sectorsize;
2110         g_error_provider(pp, 0);
2111         g_topology_unlock();
2112         last_write = time_second;
2113
2114         if (sc->sc_rootmount != NULL) {
2115                 GJ_DEBUG(1, "root_mount_rel %p", sc->sc_rootmount);
2116                 root_mount_rel(sc->sc_rootmount);
2117                 sc->sc_rootmount = NULL;
2118         }
2119
2120         for (;;) {
2121                 /* Get first request from the queue. */
2122                 mtx_lock(&sc->sc_mtx);
2123                 bp = bioq_first(&sc->sc_back_queue);
2124                 if (bp != NULL)
2125                         type = (bp->bio_cflags & GJ_BIO_MASK);
2126                 if (bp == NULL) {
2127                         bp = bioq_first(&sc->sc_regular_queue);
2128                         if (bp != NULL)
2129                                 type = GJ_BIO_REGULAR;
2130                 }
2131                 if (bp == NULL) {
2132 try_switch:
2133                         if ((sc->sc_flags & GJF_DEVICE_SWITCH) ||
2134                             (sc->sc_flags & GJF_DEVICE_DESTROY)) {
2135                                 if (sc->sc_current_count > 0) {
2136                                         mtx_unlock(&sc->sc_mtx);
2137                                         g_journal_flush(sc);
2138                                         g_journal_flush_send(sc);
2139                                         continue;
2140                                 }
2141                                 if (sc->sc_flush_in_progress > 0)
2142                                         goto sleep;
2143                                 if (sc->sc_copy_in_progress > 0)
2144                                         goto sleep;
2145                         }
2146                         if (sc->sc_flags & GJF_DEVICE_SWITCH) {
2147                                 mtx_unlock(&sc->sc_mtx);
2148                                 g_journal_switch(sc);
2149                                 wakeup(&sc->sc_journal_copying);
2150                                 continue;
2151                         }
2152                         if (sc->sc_flags & GJF_DEVICE_DESTROY) {
2153                                 GJ_DEBUG(1, "Shutting down worker "
2154                                     "thread for %s.", gp->name);
2155                                 sc->sc_worker = NULL;
2156                                 wakeup(&sc->sc_worker);
2157                                 mtx_unlock(&sc->sc_mtx);
2158                                 kproc_exit(0);
2159                         }
2160 sleep:
2161                         g_journal_wait(sc, last_write);
2162                         continue;
2163                 }
2164                 /*
2165                  * If we're in switch process, we need to delay all new
2166                  * write requests until its done.
2167                  */
2168                 if ((sc->sc_flags & GJF_DEVICE_SWITCH) &&
2169                     type == GJ_BIO_REGULAR && bp->bio_cmd == BIO_WRITE) {
2170                         GJ_LOGREQ(2, bp, "WRITE on SWITCH");
2171                         goto try_switch;
2172                 }
2173                 if (type == GJ_BIO_REGULAR)
2174                         bioq_remove(&sc->sc_regular_queue, bp);
2175                 else
2176                         bioq_remove(&sc->sc_back_queue, bp);
2177                 mtx_unlock(&sc->sc_mtx);
2178                 switch (type) {
2179                 case GJ_BIO_REGULAR:
2180                         /* Regular request. */
2181                         switch (bp->bio_cmd) {
2182                         case BIO_READ:
2183                                 g_journal_read(sc, bp, bp->bio_offset,
2184                                     bp->bio_offset + bp->bio_length);
2185                                 break;
2186                         case BIO_WRITE:
2187                                 last_write = time_second;
2188                                 g_journal_add_request(sc, bp);
2189                                 g_journal_flush_send(sc);
2190                                 break;
2191                         default:
2192                                 panic("Invalid bio_cmd (%d).", bp->bio_cmd);
2193                         }
2194                         break;
2195                 case GJ_BIO_COPY:
2196                         switch (bp->bio_cmd) {
2197                         case BIO_READ:
2198                                 if (g_journal_copy_read_done(bp))
2199                                         g_journal_copy_send(sc);
2200                                 break;
2201                         case BIO_WRITE:
2202                                 g_journal_copy_write_done(bp);
2203                                 g_journal_copy_send(sc);
2204                                 break;
2205                         default:
2206                                 panic("Invalid bio_cmd (%d).", bp->bio_cmd);
2207                         }
2208                         break;
2209                 case GJ_BIO_JOURNAL:
2210                         g_journal_flush_done(bp);
2211                         g_journal_flush_send(sc);
2212                         break;
2213                 case GJ_BIO_READ:
2214                 default:
2215                         panic("Invalid bio (%d).", type);
2216                 }
2217         }
2218 }
2219
2220 static void
2221 g_journal_destroy_event(void *arg, int flags __unused)
2222 {
2223         struct g_journal_softc *sc;
2224
2225         g_topology_assert();
2226         sc = arg;
2227         g_journal_destroy(sc);
2228 }
2229
2230 static void
2231 g_journal_timeout(void *arg)
2232 {
2233         struct g_journal_softc *sc;
2234
2235         sc = arg;
2236         GJ_DEBUG(0, "Timeout. Journal %s cannot be completed.",
2237             sc->sc_geom->name);
2238         g_post_event(g_journal_destroy_event, sc, M_NOWAIT, NULL);
2239 }
2240
2241 static struct g_geom *
2242 g_journal_create(struct g_class *mp, struct g_provider *pp,
2243     const struct g_journal_metadata *md)
2244 {
2245         struct g_journal_softc *sc;
2246         struct g_geom *gp;
2247         struct g_consumer *cp;
2248         int error;
2249
2250         sc = NULL;      /* gcc */
2251
2252         g_topology_assert();
2253         /*
2254          * There are two possibilities:
2255          * 1. Data and both journals are on the same provider.
2256          * 2. Data and journals are all on separated providers.
2257          */
2258         /* Look for journal device with the same ID. */
2259         LIST_FOREACH(gp, &mp->geom, geom) {
2260                 sc = gp->softc;
2261                 if (sc == NULL)
2262                         continue;
2263                 if (sc->sc_id == md->md_id)
2264                         break;
2265         }
2266         if (gp == NULL)
2267                 sc = NULL;
2268         else if (sc != NULL && (sc->sc_type & md->md_type) != 0) {
2269                 GJ_DEBUG(1, "Journal device %u already configured.", sc->sc_id);
2270                 return (NULL);
2271         }
2272         if (md->md_type == 0 || (md->md_type & ~GJ_TYPE_COMPLETE) != 0) {
2273                 GJ_DEBUG(0, "Invalid type on %s.", pp->name);
2274                 return (NULL);
2275         }
2276         if (md->md_type & GJ_TYPE_DATA) {
2277                 GJ_DEBUG(0, "Journal %u: %s contains data.", md->md_id,
2278                     pp->name);
2279         }
2280         if (md->md_type & GJ_TYPE_JOURNAL) {
2281                 GJ_DEBUG(0, "Journal %u: %s contains journal.", md->md_id,
2282                     pp->name);
2283         }
2284
2285         if (sc == NULL) {
2286                 /* Action geom. */
2287                 sc = malloc(sizeof(*sc), M_JOURNAL, M_WAITOK | M_ZERO);
2288                 sc->sc_id = md->md_id;
2289                 sc->sc_type = 0;
2290                 sc->sc_flags = 0;
2291                 sc->sc_worker = NULL;
2292
2293                 gp = g_new_geomf(mp, "gjournal %u", sc->sc_id);
2294                 gp->start = g_journal_start;
2295                 gp->orphan = g_journal_orphan;
2296                 gp->access = g_journal_access;
2297                 gp->softc = sc;
2298                 gp->flags |= G_GEOM_VOLATILE_BIO;
2299                 sc->sc_geom = gp;
2300
2301                 mtx_init(&sc->sc_mtx, "gjournal", NULL, MTX_DEF);
2302
2303                 bioq_init(&sc->sc_back_queue);
2304                 bioq_init(&sc->sc_regular_queue);
2305                 bioq_init(&sc->sc_delayed_queue);
2306                 sc->sc_delayed_count = 0;
2307                 sc->sc_current_queue = NULL;
2308                 sc->sc_current_count = 0;
2309                 sc->sc_flush_queue = NULL;
2310                 sc->sc_flush_count = 0;
2311                 sc->sc_flush_in_progress = 0;
2312                 sc->sc_copy_queue = NULL;
2313                 sc->sc_copy_in_progress = 0;
2314                 sc->sc_inactive.jj_queue = NULL;
2315                 sc->sc_active.jj_queue = NULL;
2316
2317                 sc->sc_rootmount = root_mount_hold("GJOURNAL");
2318                 GJ_DEBUG(1, "root_mount_hold %p", sc->sc_rootmount);
2319
2320                 callout_init(&sc->sc_callout, 1);
2321                 if (md->md_type != GJ_TYPE_COMPLETE) {
2322                         /*
2323                          * Journal and data are on separate providers.
2324                          * At this point we have only one of them.
2325                          * We setup a timeout in case the other part will not
2326                          * appear, so we won't wait forever.
2327                          */
2328                         callout_reset(&sc->sc_callout, 5 * hz,
2329                             g_journal_timeout, sc);
2330                 }
2331         }
2332
2333         /* Remember type of the data provider. */
2334         if (md->md_type & GJ_TYPE_DATA)
2335                 sc->sc_orig_type = md->md_type;
2336         sc->sc_type |= md->md_type;
2337         cp = NULL;
2338
2339         if (md->md_type & GJ_TYPE_DATA) {
2340                 if (md->md_flags & GJ_FLAG_CLEAN)
2341                         sc->sc_flags |= GJF_DEVICE_CLEAN;
2342                 if (md->md_flags & GJ_FLAG_CHECKSUM)
2343                         sc->sc_flags |= GJF_DEVICE_CHECKSUM;
2344                 cp = g_new_consumer(gp);
2345                 error = g_attach(cp, pp);
2346                 KASSERT(error == 0, ("Cannot attach to %s (error=%d).",
2347                     pp->name, error));
2348                 error = g_access(cp, 1, 1, 1);
2349                 if (error != 0) {
2350                         GJ_DEBUG(0, "Cannot access %s (error=%d).", pp->name,
2351                             error);
2352                         g_journal_destroy(sc);
2353                         return (NULL);
2354                 }
2355                 sc->sc_dconsumer = cp;
2356                 sc->sc_mediasize = pp->mediasize - pp->sectorsize;
2357                 sc->sc_sectorsize = pp->sectorsize;
2358                 sc->sc_jstart = md->md_jstart;
2359                 sc->sc_jend = md->md_jend;
2360                 if (md->md_provider[0] != '\0')
2361                         sc->sc_flags |= GJF_DEVICE_HARDCODED;
2362                 sc->sc_journal_offset = md->md_joffset;
2363                 sc->sc_journal_id = md->md_jid;
2364                 sc->sc_journal_previous_id = md->md_jid;
2365         }
2366         if (md->md_type & GJ_TYPE_JOURNAL) {
2367                 if (cp == NULL) {
2368                         cp = g_new_consumer(gp);
2369                         error = g_attach(cp, pp);
2370                         KASSERT(error == 0, ("Cannot attach to %s (error=%d).",
2371                             pp->name, error));
2372                         error = g_access(cp, 1, 1, 1);
2373                         if (error != 0) {
2374                                 GJ_DEBUG(0, "Cannot access %s (error=%d).",
2375                                     pp->name, error);
2376                                 g_journal_destroy(sc);
2377                                 return (NULL);
2378                         }
2379                 } else {
2380                         /*
2381                          * Journal is on the same provider as data, which means
2382                          * that data provider ends where journal starts.
2383                          */
2384                         sc->sc_mediasize = md->md_jstart;
2385                 }
2386                 sc->sc_jconsumer = cp;
2387         }
2388
2389         /* Start switcher kproc if needed. */
2390         if (g_journal_switcher_proc == NULL)
2391                 g_journal_start_switcher(mp);
2392
2393         if ((sc->sc_type & GJ_TYPE_COMPLETE) != GJ_TYPE_COMPLETE) {
2394                 /* Journal is not complete yet. */
2395                 return (gp);
2396         } else {
2397                 /* Journal complete, cancel timeout. */
2398                 callout_drain(&sc->sc_callout);
2399         }
2400
2401         error = kproc_create(g_journal_worker, sc, &sc->sc_worker, 0, 0,
2402             "g_journal %s", sc->sc_name);
2403         if (error != 0) {
2404                 GJ_DEBUG(0, "Cannot create worker thread for %s.journal.",
2405                     sc->sc_name);
2406                 g_journal_destroy(sc);
2407                 return (NULL);
2408         }
2409
2410         return (gp);
2411 }
2412
2413 static void
2414 g_journal_destroy_consumer(void *arg, int flags __unused)
2415 {
2416         struct g_consumer *cp;
2417
2418         g_topology_assert();
2419         cp = arg;
2420         g_detach(cp);
2421         g_destroy_consumer(cp);
2422 }
2423
2424 static int
2425 g_journal_destroy(struct g_journal_softc *sc)
2426 {
2427         struct g_geom *gp;
2428         struct g_provider *pp;
2429         struct g_consumer *cp;
2430
2431         g_topology_assert();
2432
2433         if (sc == NULL)
2434                 return (ENXIO);
2435
2436         gp = sc->sc_geom;
2437         pp = LIST_FIRST(&gp->provider);
2438         if (pp != NULL) {
2439                 if (pp->acr != 0 || pp->acw != 0 || pp->ace != 0) {
2440                         GJ_DEBUG(1, "Device %s is still open (r%dw%de%d).",
2441                             pp->name, pp->acr, pp->acw, pp->ace);
2442                         return (EBUSY);
2443                 }
2444                 g_error_provider(pp, ENXIO);
2445
2446                 g_journal_flush(sc);
2447                 g_journal_flush_send(sc);
2448                 g_journal_switch(sc);
2449         }
2450
2451         sc->sc_flags |= (GJF_DEVICE_DESTROY | GJF_DEVICE_CLEAN);
2452
2453         g_topology_unlock();
2454
2455         if (sc->sc_rootmount != NULL) {
2456                 GJ_DEBUG(1, "root_mount_rel %p", sc->sc_rootmount);
2457                 root_mount_rel(sc->sc_rootmount);
2458                 sc->sc_rootmount = NULL;
2459         }
2460
2461         callout_drain(&sc->sc_callout);
2462         mtx_lock(&sc->sc_mtx);
2463         wakeup(sc);
2464         while (sc->sc_worker != NULL)
2465                 msleep(&sc->sc_worker, &sc->sc_mtx, PRIBIO, "gj:destroy", 0);
2466         mtx_unlock(&sc->sc_mtx);
2467
2468         if (pp != NULL) {
2469                 GJ_DEBUG(1, "Marking %s as clean.", sc->sc_name);
2470                 g_journal_metadata_update(sc);
2471                 g_topology_lock();
2472                 g_wither_provider(pp, ENXIO);
2473         } else {
2474                 g_topology_lock();
2475         }
2476         mtx_destroy(&sc->sc_mtx);
2477
2478         if (sc->sc_current_count != 0) {
2479                 GJ_DEBUG(0, "Warning! Number of current requests %d.",
2480                     sc->sc_current_count);
2481         }
2482
2483         LIST_FOREACH(cp, &gp->consumer, consumer) {
2484                 if (cp->acr + cp->acw + cp->ace > 0)
2485                         g_access(cp, -1, -1, -1);
2486                 /*
2487                  * We keep all consumers open for writting, so if I'll detach
2488                  * and destroy consumer here, I'll get providers for taste, so
2489                  * journal will be started again.
2490                  * Sending an event here, prevents this from happening.
2491                  */
2492                 g_post_event(g_journal_destroy_consumer, cp, M_WAITOK, NULL);
2493         }
2494         gp->softc = NULL;
2495         g_wither_geom(gp, ENXIO);
2496         free(sc, M_JOURNAL);
2497         return (0);
2498 }
2499
2500 static void
2501 g_journal_taste_orphan(struct g_consumer *cp)
2502 {
2503
2504         KASSERT(1 == 0, ("%s called while tasting %s.", __func__,
2505             cp->provider->name));
2506 }
2507
2508 static struct g_geom *
2509 g_journal_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
2510 {
2511         struct g_journal_metadata md;
2512         struct g_consumer *cp;
2513         struct g_geom *gp;
2514         int error;
2515
2516         g_topology_assert();
2517         g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__, mp->name, pp->name);
2518         GJ_DEBUG(2, "Tasting %s.", pp->name);
2519         if (pp->geom->class == mp)
2520                 return (NULL);
2521
2522         gp = g_new_geomf(mp, "journal:taste");
2523         /* This orphan function should be never called. */
2524         gp->orphan = g_journal_taste_orphan;
2525         cp = g_new_consumer(gp);
2526         g_attach(cp, pp);
2527         error = g_journal_metadata_read(cp, &md);
2528         g_detach(cp);
2529         g_destroy_consumer(cp);
2530         g_destroy_geom(gp);
2531         if (error != 0)
2532                 return (NULL);
2533         gp = NULL;
2534
2535         if (md.md_provider[0] != '\0' &&
2536             !g_compare_names(md.md_provider, pp->name))
2537                 return (NULL);
2538         if (md.md_provsize != 0 && md.md_provsize != pp->mediasize)
2539                 return (NULL);
2540         if (g_journal_debug >= 2)
2541                 journal_metadata_dump(&md);
2542
2543         gp = g_journal_create(mp, pp, &md);
2544         return (gp);
2545 }
2546
2547 static struct g_journal_softc *
2548 g_journal_find_device(struct g_class *mp, const char *name)
2549 {
2550         struct g_journal_softc *sc;
2551         struct g_geom *gp;
2552         struct g_provider *pp;
2553
2554         if (strncmp(name, "/dev/", 5) == 0)
2555                 name += 5;
2556         LIST_FOREACH(gp, &mp->geom, geom) {
2557                 sc = gp->softc;
2558                 if (sc == NULL)
2559                         continue;
2560                 if (sc->sc_flags & GJF_DEVICE_DESTROY)
2561                         continue;
2562                 if ((sc->sc_type & GJ_TYPE_COMPLETE) != GJ_TYPE_COMPLETE)
2563                         continue;
2564                 pp = LIST_FIRST(&gp->provider);
2565                 if (strcmp(sc->sc_name, name) == 0)
2566                         return (sc);
2567                 if (pp != NULL && strcmp(pp->name, name) == 0)
2568                         return (sc);
2569         }
2570         return (NULL);
2571 }
2572
2573 static void
2574 g_journal_ctl_destroy(struct gctl_req *req, struct g_class *mp)
2575 {
2576         struct g_journal_softc *sc;
2577         const char *name;
2578         char param[16];
2579         int *nargs;
2580         int error, i;
2581
2582         g_topology_assert();
2583
2584         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
2585         if (nargs == NULL) {
2586                 gctl_error(req, "No '%s' argument.", "nargs");
2587                 return;
2588         }
2589         if (*nargs <= 0) {
2590                 gctl_error(req, "Missing device(s).");
2591                 return;
2592         }
2593
2594         for (i = 0; i < *nargs; i++) {
2595                 snprintf(param, sizeof(param), "arg%d", i);
2596                 name = gctl_get_asciiparam(req, param);
2597                 if (name == NULL) {
2598                         gctl_error(req, "No 'arg%d' argument.", i);
2599                         return;
2600                 }
2601                 sc = g_journal_find_device(mp, name);
2602                 if (sc == NULL) {
2603                         gctl_error(req, "No such device: %s.", name);
2604                         return;
2605                 }
2606                 error = g_journal_destroy(sc);
2607                 if (error != 0) {
2608                         gctl_error(req, "Cannot destroy device %s (error=%d).",
2609                             LIST_FIRST(&sc->sc_geom->provider)->name, error);
2610                         return;
2611                 }
2612         }
2613 }
2614
2615 static void
2616 g_journal_ctl_sync(struct gctl_req *req __unused, struct g_class *mp __unused)
2617 {
2618
2619         g_topology_assert();
2620         g_topology_unlock();
2621         g_journal_sync_requested++;
2622         wakeup(&g_journal_switcher_state);
2623         while (g_journal_sync_requested > 0)
2624                 tsleep(&g_journal_sync_requested, PRIBIO, "j:sreq", hz / 2);
2625         g_topology_lock();
2626 }
2627
2628 static void
2629 g_journal_config(struct gctl_req *req, struct g_class *mp, const char *verb)
2630 {
2631         uint32_t *version;
2632
2633         g_topology_assert();
2634
2635         version = gctl_get_paraml(req, "version", sizeof(*version));
2636         if (version == NULL) {
2637                 gctl_error(req, "No '%s' argument.", "version");
2638                 return;
2639         }
2640         if (*version != G_JOURNAL_VERSION) {
2641                 gctl_error(req, "Userland and kernel parts are out of sync.");
2642                 return;
2643         }
2644
2645         if (strcmp(verb, "destroy") == 0 || strcmp(verb, "stop") == 0) {
2646                 g_journal_ctl_destroy(req, mp);
2647                 return;
2648         } else if (strcmp(verb, "sync") == 0) {
2649                 g_journal_ctl_sync(req, mp);
2650                 return;
2651         }
2652
2653         gctl_error(req, "Unknown verb.");
2654 }
2655
2656 static void
2657 g_journal_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
2658     struct g_consumer *cp, struct g_provider *pp)
2659 {
2660         struct g_journal_softc *sc;
2661
2662         g_topology_assert();
2663
2664         sc = gp->softc;
2665         if (sc == NULL)
2666                 return;
2667         if (pp != NULL) {
2668                 /* Nothing here. */
2669         } else if (cp != NULL) {
2670                 int first = 1;
2671
2672                 sbuf_printf(sb, "%s<Role>", indent);
2673                 if (cp == sc->sc_dconsumer) {
2674                         sbuf_printf(sb, "Data");
2675                         first = 0;
2676                 }
2677                 if (cp == sc->sc_jconsumer) {
2678                         if (!first)
2679                                 sbuf_printf(sb, ",");
2680                         sbuf_printf(sb, "Journal");
2681                 }
2682                 sbuf_printf(sb, "</Role>\n");
2683                 if (cp == sc->sc_jconsumer) {
2684                         sbuf_printf(sb, "<Jstart>%jd</Jstart>\n",
2685                             (intmax_t)sc->sc_jstart);
2686                         sbuf_printf(sb, "<Jend>%jd</Jend>\n",
2687                             (intmax_t)sc->sc_jend);
2688                 }
2689         } else {
2690                 sbuf_printf(sb, "%s<ID>%u</ID>\n", indent, (u_int)sc->sc_id);
2691         }
2692 }
2693
2694 static eventhandler_tag g_journal_event_shutdown = NULL;
2695 static eventhandler_tag g_journal_event_lowmem = NULL;
2696
2697 static void
2698 g_journal_shutdown(void *arg, int howto __unused)
2699 {
2700         struct g_class *mp;
2701         struct g_geom *gp, *gp2;
2702
2703         if (panicstr != NULL)
2704                 return;
2705         mp = arg;
2706         g_topology_lock();
2707         LIST_FOREACH_SAFE(gp, &mp->geom, geom, gp2) {
2708                 if (gp->softc == NULL)
2709                         continue;
2710                 GJ_DEBUG(0, "Shutting down geom %s.", gp->name);
2711                 g_journal_destroy(gp->softc);
2712         }
2713         g_topology_unlock();
2714 }
2715
2716 /*
2717  * Free cached requests from inactive queue in case of low memory.
2718  * We free GJ_FREE_AT_ONCE elements at once.
2719  */
2720 #define GJ_FREE_AT_ONCE 4
2721 static void
2722 g_journal_lowmem(void *arg, int howto __unused)
2723 {
2724         struct g_journal_softc *sc;
2725         struct g_class *mp;
2726         struct g_geom *gp;
2727         struct bio *bp;
2728         u_int nfree = GJ_FREE_AT_ONCE;
2729
2730         g_journal_stats_low_mem++;
2731         mp = arg;
2732         g_topology_lock();
2733         LIST_FOREACH(gp, &mp->geom, geom) {
2734                 sc = gp->softc;
2735                 if (sc == NULL || (sc->sc_flags & GJF_DEVICE_DESTROY))
2736                         continue;
2737                 mtx_lock(&sc->sc_mtx);
2738                 for (bp = sc->sc_inactive.jj_queue; nfree > 0 && bp != NULL;
2739                     nfree--, bp = bp->bio_next) {
2740                         /*
2741                          * This is safe to free the bio_data, because:
2742                          * 1. If bio_data is NULL it will be read from the
2743                          *    inactive journal.
2744                          * 2. If bp is sent down, it is first removed from the
2745                          *    inactive queue, so it's impossible to free the
2746                          *    data from under in-flight bio.
2747                          * On the other hand, freeing elements from the active
2748                          * queue, is not safe.
2749                          */
2750                         if (bp->bio_data != NULL) {
2751                                 GJ_DEBUG(2, "Freeing data from %s.",
2752                                     sc->sc_name);
2753                                 gj_free(bp->bio_data, bp->bio_length);
2754                                 bp->bio_data = NULL;
2755                         }
2756                 }
2757                 mtx_unlock(&sc->sc_mtx);
2758                 if (nfree == 0)
2759                         break;
2760         }
2761         g_topology_unlock();
2762 }
2763
2764 static void g_journal_switcher(void *arg);
2765
2766 static void
2767 g_journal_init(struct g_class *mp)
2768 {
2769
2770         /* Pick a conservative value if provided value sucks. */
2771         if (g_journal_cache_divisor <= 0 ||
2772             (vm_kmem_size / g_journal_cache_divisor == 0)) {
2773                 g_journal_cache_divisor = 5;
2774         }
2775         if (g_journal_cache_limit > 0) {
2776                 g_journal_cache_limit = vm_kmem_size / g_journal_cache_divisor;
2777                 g_journal_cache_low =
2778                     (g_journal_cache_limit / 100) * g_journal_cache_switch;
2779         }
2780         g_journal_event_shutdown = EVENTHANDLER_REGISTER(shutdown_post_sync,
2781             g_journal_shutdown, mp, EVENTHANDLER_PRI_FIRST);
2782         if (g_journal_event_shutdown == NULL)
2783                 GJ_DEBUG(0, "Warning! Cannot register shutdown event.");
2784         g_journal_event_lowmem = EVENTHANDLER_REGISTER(vm_lowmem,
2785             g_journal_lowmem, mp, EVENTHANDLER_PRI_FIRST);
2786         if (g_journal_event_lowmem == NULL)
2787                 GJ_DEBUG(0, "Warning! Cannot register lowmem event.");
2788 }
2789
2790 static void
2791 g_journal_fini(struct g_class *mp)
2792 {
2793
2794         if (g_journal_event_shutdown != NULL) {
2795                 EVENTHANDLER_DEREGISTER(shutdown_post_sync,
2796                     g_journal_event_shutdown);
2797         }
2798         if (g_journal_event_lowmem != NULL)
2799                 EVENTHANDLER_DEREGISTER(vm_lowmem, g_journal_event_lowmem);
2800         g_journal_stop_switcher();
2801 }
2802
2803 DECLARE_GEOM_CLASS(g_journal_class, g_journal);
2804
2805 static const struct g_journal_desc *
2806 g_journal_find_desc(const char *fstype)
2807 {
2808         const struct g_journal_desc *desc;
2809         int i;
2810
2811         for (desc = g_journal_filesystems[i = 0]; desc != NULL;
2812              desc = g_journal_filesystems[++i]) {
2813                 if (strcmp(desc->jd_fstype, fstype) == 0)
2814                         break;
2815         }
2816         return (desc);
2817 }
2818
2819 static void
2820 g_journal_switch_wait(struct g_journal_softc *sc)
2821 {
2822         struct bintime bt;
2823
2824         mtx_assert(&sc->sc_mtx, MA_OWNED);
2825         if (g_journal_debug >= 2) {
2826                 if (sc->sc_flush_in_progress > 0) {
2827                         GJ_DEBUG(2, "%d requests flushing.",
2828                             sc->sc_flush_in_progress);
2829                 }
2830                 if (sc->sc_copy_in_progress > 0) {
2831                         GJ_DEBUG(2, "%d requests copying.",
2832                             sc->sc_copy_in_progress);
2833                 }
2834                 if (sc->sc_flush_count > 0) {
2835                         GJ_DEBUG(2, "%d requests to flush.",
2836                             sc->sc_flush_count);
2837                 }
2838                 if (sc->sc_delayed_count > 0) {
2839                         GJ_DEBUG(2, "%d requests delayed.",
2840                             sc->sc_delayed_count);
2841                 }
2842         }
2843         g_journal_stats_switches++;
2844         if (sc->sc_copy_in_progress > 0)
2845                 g_journal_stats_wait_for_copy++;
2846         GJ_TIMER_START(1, &bt);
2847         sc->sc_flags &= ~GJF_DEVICE_BEFORE_SWITCH;
2848         sc->sc_flags |= GJF_DEVICE_SWITCH;
2849         wakeup(sc);
2850         while (sc->sc_flags & GJF_DEVICE_SWITCH) {
2851                 msleep(&sc->sc_journal_copying, &sc->sc_mtx, PRIBIO,
2852                     "gj:switch", 0);
2853         }
2854         GJ_TIMER_STOP(1, &bt, "Switch time of %s", sc->sc_name);
2855 }
2856
2857 static void
2858 g_journal_do_switch(struct g_class *classp)
2859 {
2860         struct g_journal_softc *sc;
2861         const struct g_journal_desc *desc;
2862         struct g_geom *gp;
2863         struct mount *mp;
2864         struct bintime bt;
2865         char *mountpoint;
2866         int error, save;
2867
2868         g_topology_lock();
2869         LIST_FOREACH(gp, &classp->geom, geom) {
2870                 sc = gp->softc;
2871                 if (sc == NULL)
2872                         continue;
2873                 if (sc->sc_flags & GJF_DEVICE_DESTROY)
2874                         continue;
2875                 if ((sc->sc_type & GJ_TYPE_COMPLETE) != GJ_TYPE_COMPLETE)
2876                         continue;
2877                 mtx_lock(&sc->sc_mtx);
2878                 sc->sc_flags |= GJF_DEVICE_BEFORE_SWITCH;
2879                 mtx_unlock(&sc->sc_mtx);
2880         }
2881         g_topology_unlock();
2882
2883         mtx_lock(&mountlist_mtx);
2884         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
2885                 if (mp->mnt_gjprovider == NULL)
2886                         continue;
2887                 if (mp->mnt_flag & MNT_RDONLY)
2888                         continue;
2889                 desc = g_journal_find_desc(mp->mnt_stat.f_fstypename);
2890                 if (desc == NULL)
2891                         continue;
2892                 if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK))
2893                         continue;
2894                 /* mtx_unlock(&mountlist_mtx) was done inside vfs_busy() */
2895
2896                 g_topology_lock();
2897                 sc = g_journal_find_device(classp, mp->mnt_gjprovider);
2898                 g_topology_unlock();
2899
2900                 if (sc == NULL) {
2901                         GJ_DEBUG(0, "Cannot find journal geom for %s.",
2902                             mp->mnt_gjprovider);
2903                         goto next;
2904                 } else if (JEMPTY(sc)) {
2905                         mtx_lock(&sc->sc_mtx);
2906                         sc->sc_flags &= ~GJF_DEVICE_BEFORE_SWITCH;
2907                         mtx_unlock(&sc->sc_mtx);
2908                         GJ_DEBUG(3, "No need for %s switch.", sc->sc_name);
2909                         goto next;
2910                 }
2911
2912                 mountpoint = mp->mnt_stat.f_mntonname;
2913
2914                 error = vn_start_write(NULL, &mp, V_WAIT);
2915                 if (error != 0) {
2916                         GJ_DEBUG(0, "vn_start_write(%s) failed (error=%d).",
2917                             mountpoint, error);
2918                         goto next;
2919                 }
2920
2921                 save = curthread_pflags_set(TDP_SYNCIO);
2922
2923                 GJ_TIMER_START(1, &bt);
2924                 vfs_msync(mp, MNT_NOWAIT);
2925                 GJ_TIMER_STOP(1, &bt, "Msync time of %s", mountpoint);
2926
2927                 GJ_TIMER_START(1, &bt);
2928                 error = VFS_SYNC(mp, MNT_NOWAIT);
2929                 if (error == 0)
2930                         GJ_TIMER_STOP(1, &bt, "Sync time of %s", mountpoint);
2931                 else {
2932                         GJ_DEBUG(0, "Cannot sync file system %s (error=%d).",
2933                             mountpoint, error);
2934                 }
2935
2936                 curthread_pflags_restore(save);
2937
2938                 vn_finished_write(mp);
2939
2940                 if (error != 0)
2941                         goto next;
2942
2943                 /*
2944                  * Send BIO_FLUSH before freezing the file system, so it can be
2945                  * faster after the freeze.
2946                  */
2947                 GJ_TIMER_START(1, &bt);
2948                 g_journal_flush_cache(sc);
2949                 GJ_TIMER_STOP(1, &bt, "BIO_FLUSH time of %s", sc->sc_name);
2950
2951                 GJ_TIMER_START(1, &bt);
2952                 error = vfs_write_suspend(mp, VS_SKIP_UNMOUNT);
2953                 GJ_TIMER_STOP(1, &bt, "Suspend time of %s", mountpoint);
2954                 if (error != 0) {
2955                         GJ_DEBUG(0, "Cannot suspend file system %s (error=%d).",
2956                             mountpoint, error);
2957                         goto next;
2958                 }
2959
2960                 error = desc->jd_clean(mp);
2961                 if (error != 0)
2962                         goto next;
2963
2964                 mtx_lock(&sc->sc_mtx);
2965                 g_journal_switch_wait(sc);
2966                 mtx_unlock(&sc->sc_mtx);
2967
2968                 vfs_write_resume(mp, 0);
2969 next:
2970                 mtx_lock(&mountlist_mtx);
2971                 vfs_unbusy(mp);
2972         }
2973         mtx_unlock(&mountlist_mtx);
2974
2975         sc = NULL;
2976         for (;;) {
2977                 g_topology_lock();
2978                 LIST_FOREACH(gp, &g_journal_class.geom, geom) {
2979                         sc = gp->softc;
2980                         if (sc == NULL)
2981                                 continue;
2982                         mtx_lock(&sc->sc_mtx);
2983                         if ((sc->sc_type & GJ_TYPE_COMPLETE) == GJ_TYPE_COMPLETE &&
2984                             !(sc->sc_flags & GJF_DEVICE_DESTROY) &&
2985                             (sc->sc_flags & GJF_DEVICE_BEFORE_SWITCH)) {
2986                                 break;
2987                         }
2988                         mtx_unlock(&sc->sc_mtx);
2989                         sc = NULL;
2990                 }
2991                 g_topology_unlock();
2992                 if (sc == NULL)
2993                         break;
2994                 mtx_assert(&sc->sc_mtx, MA_OWNED);
2995                 g_journal_switch_wait(sc);
2996                 mtx_unlock(&sc->sc_mtx);
2997         }
2998 }
2999
3000 static void
3001 g_journal_start_switcher(struct g_class *mp)
3002 {
3003         int error;
3004
3005         g_topology_assert();
3006         MPASS(g_journal_switcher_proc == NULL);
3007         g_journal_switcher_state = GJ_SWITCHER_WORKING;
3008         error = kproc_create(g_journal_switcher, mp, &g_journal_switcher_proc,
3009             0, 0, "g_journal switcher");
3010         KASSERT(error == 0, ("Cannot create switcher thread."));
3011 }
3012
3013 static void
3014 g_journal_stop_switcher(void)
3015 {
3016         g_topology_assert();
3017         MPASS(g_journal_switcher_proc != NULL);
3018         g_journal_switcher_state = GJ_SWITCHER_DIE;
3019         wakeup(&g_journal_switcher_state);
3020         while (g_journal_switcher_state != GJ_SWITCHER_DIED)
3021                 tsleep(&g_journal_switcher_state, PRIBIO, "jfini:wait", hz / 5);
3022         GJ_DEBUG(1, "Switcher died.");
3023         g_journal_switcher_proc = NULL;
3024 }
3025
3026 /*
3027  * TODO: Kill switcher thread on last geom destruction?
3028  */
3029 static void
3030 g_journal_switcher(void *arg)
3031 {
3032         struct g_class *mp;
3033         struct bintime bt;
3034         int error;
3035
3036         mp = arg;
3037         curthread->td_pflags |= TDP_NORUNNINGBUF;
3038         for (;;) {
3039                 g_journal_switcher_wokenup = 0;
3040                 error = tsleep(&g_journal_switcher_state, PRIBIO, "jsw:wait",
3041                     g_journal_switch_time * hz);
3042                 if (g_journal_switcher_state == GJ_SWITCHER_DIE) {
3043                         g_journal_switcher_state = GJ_SWITCHER_DIED;
3044                         GJ_DEBUG(1, "Switcher exiting.");
3045                         wakeup(&g_journal_switcher_state);
3046                         kproc_exit(0);
3047                 }
3048                 if (error == 0 && g_journal_sync_requested == 0) {
3049                         GJ_DEBUG(1, "Out of cache, force switch (used=%u "
3050                             "limit=%u).", g_journal_cache_used,
3051                             g_journal_cache_limit);
3052                 }
3053                 GJ_TIMER_START(1, &bt);
3054                 g_journal_do_switch(mp);
3055                 GJ_TIMER_STOP(1, &bt, "Entire switch time");
3056                 if (g_journal_sync_requested > 0) {
3057                         g_journal_sync_requested = 0;
3058                         wakeup(&g_journal_sync_requested);
3059                 }
3060         }
3061 }