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