sys/geom/journal/g_journal.c

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