1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26#ifndef _SYS_FS_UFS_LOG_H 27#define _SYS_FS_UFS_LOG_H 28 29#include <sys/buf.h> 30#include <sys/fs/ufs_trans.h> 31#include <sys/fs/ufs_filio.h> 32#include <sys/fs/ufs_inode.h> 33 34#ifdef __cplusplus 35extern "C" { 36#endif 37 38typedef struct lufs_save { 39 buf_t *sv_bp; 40 size_t sv_nb_left; 41 int sv_error; 42} lufs_save_t; 43 44typedef struct lufs_buf { 45 buf_t lb_buf; 46 void *lb_ptr; 47} lufs_buf_t; 48 49/* 50 * Log space is stored as extents 51 */ 52#define LUFS_EXTENTS (UINT32_C(0)) 53#define LS_SECTORS 2 54 55typedef struct extent { 56 uint32_t lbno; /* Logical block # within the space */ 57 uint32_t pbno; /* Physical block number of extent. */ 58 /* in disk blocks for non-MTB ufs */ 59 /* in frags for MTB ufs */ 60 uint32_t nbno; /* # blocks in this extent */ 61} extent_t; 62 63typedef struct ic_extent { 64 uint32_t ic_lbno; /* Logical block # within the space */ 65 uint32_t ic_nbno; /* # blocks in this extent */ 66 daddr_t ic_pbno; /* Physical block number of extent. */ 67 /* (always in disk blocks) */ 68} ic_extent_t; 69 70typedef struct extent_block { 71 uint32_t type; /* Set to LUFS_EXTENTS to identify */ 72 /* structure on disk. */ 73 int32_t chksum; /* Checksum over entire block. */ 74 uint32_t nextents; /* Size of extents array. */ 75 uint32_t nbytes; /* # bytes mapped by extent_block. */ 76 uint32_t nextbno; /* blkno of next extent_block. */ 77 extent_t extents[1]; 78} extent_block_t; 79 80typedef struct ic_extent_block { 81 uint32_t ic_nextents; /* Size of extents array. */ 82 uint32_t ic_nbytes; /* # bytes mapped by extent_block. */ 83 uint32_t ic_nextbno; /* blkno of next extent_block. */ 84 ic_extent_t ic_extents[1]; 85} ic_extent_block_t; 86 87/* 88 * Don't size the incore buffers too small or too large 89 */ 90#define LDL_MINTRANSFER (UINT32_C(32768)) /* 32 k */ 91#define LDL_MAXTRANSFER (UINT32_C(1048576)) /* 1 M */ 92 93/* 94 * LDL_DIVISOR (ldl_divisor) is the number to calculate the log size 95 * from the file system size according to the calculation in lufs_enable() 96 */ 97#define LDL_DIVISOR 1024 /* 1024 gives 1MB per 1GB */ 98 99/* 100 * This gives the maximum size of log for which the 1MB per 1GB rule 101 * applies. The size of the log will only be greater than this based 102 * on the cylinder group space requirements. 103 */ 104#define LDL_SOFTLOGCAP (256 * 1024 * 1024) 105 106/* 107 * But set reasonable min/max units 108 */ 109#define LDL_MINLOGSIZE (1024 * 1024) 110#define LDL_MAXLOGSIZE (512 * 1024 * 1024) 111 112/* 113 * Log space requirement per cylinder group. This needs to accommodate a 114 * cg delta (inc. header) and have a factor to cover other deltas involved 115 * in a single transaction which could touch all cyl groups in a file system. 116 */ 117#define LDL_CGSIZEREQ(fs) \ 118 ((fs)->fs_cgsize + ((fs)->fs_cgsize >> 1)) 119 120#define LDL_MINBUFSIZE (32 * 1024) 121#define LDL_USABLE_BSIZE (DEV_BSIZE - sizeof (sect_trailer_t)) 122#define NB_LEFT_IN_SECTOR(off) (LDL_USABLE_BSIZE - ((off) - dbtob(btodb(off)))) 123 124typedef struct cirbuf { 125 buf_t *cb_bp; /* buf's with space in circular buf */ 126 buf_t *cb_dirty; /* filling this buffer for log write */ 127 buf_t *cb_free; /* free bufs list */ 128 caddr_t cb_va; /* address of circular buffer */ 129 size_t cb_nb; /* size of circular buffer */ 130 krwlock_t cb_rwlock; /* r/w lock to protect list mgmt. */ 131} cirbuf_t; 132 133#define LUFS_VERSION (UINT32_C(1)) /* Version 1 */ 134#define LUFS_VERSION_LATEST LUFS_VERSION 135 136/* 137 * The old Disksuite unit structure has been split into two parts -- the 138 * incore part which is created at run time and the ondisk structure. To 139 * minimize code changes, the incore structure retains the old name, 140 * ml_unit_t and the ondisk structure is called ml_odunit_t. The ondisk 141 * structure is stored at the beginning of the log. 142 * 143 * This structure must fit into a sector (512b) 144 * 145 */ 146typedef struct ml_odunit { 147 uint32_t od_version; /* version number */ 148 uint32_t od_badlog; /* is the log okay? */ 149 uint32_t od_unused1; 150 151 /* 152 * Important constants 153 */ 154 uint32_t od_maxtransfer; /* max transfer in bytes */ 155 uint32_t od_devbsize; /* device bsize */ 156 int32_t od_bol_lof; /* byte offset to begin of log */ 157 int32_t od_eol_lof; /* byte offset to end of log */ 158 159 /* 160 * The disk space is split into state and circular log 161 */ 162 uint32_t od_requestsize; /* size requested by user */ 163 uint32_t od_statesize; /* size of state area in bytes */ 164 uint32_t od_logsize; /* size of log area in bytes */ 165 int32_t od_statebno; /* first block of state area */ 166 int32_t od_unused2; 167 168 /* 169 * Head and tail of log 170 */ 171 int32_t od_head_lof; /* byte offset of head */ 172 uint32_t od_head_ident; /* head sector id # */ 173 int32_t od_tail_lof; /* byte offset of tail */ 174 uint32_t od_tail_ident; /* tail sector id # */ 175 uint32_t od_chksum; /* checksum to verify ondisk contents */ 176 177 /* 178 * Used for error recovery 179 */ 180 uint32_t od_head_tid; /* used for logscan; set at sethead */ 181 182 /* 183 * Debug bits 184 */ 185 int32_t od_debug; 186 187 /* 188 * Misc 189 */ 190 struct timeval od_timestamp; /* time of last state change */ 191} ml_odunit_t; 192 193typedef struct ml_unit { 194 struct ml_unit *un_next; /* next incore log */ 195 int un_flags; /* Incore state */ 196 buf_t *un_bp; /* contains memory for un_ondisk */ 197 struct ufsvfs *un_ufsvfs; /* backpointer to ufsvfs */ 198 dev_t un_dev; /* for convenience */ 199 ic_extent_block_t *un_ebp; /* block of extents */ 200 size_t un_nbeb; /* # bytes used by *un_ebp */ 201 struct mt_map *un_deltamap; /* deltamap */ 202 struct mt_map *un_logmap; /* logmap includes moby trans stuff */ 203 struct mt_map *un_matamap; /* optional - matamap */ 204 205 /* 206 * Used for managing transactions 207 */ 208 uint32_t un_maxresv; /* maximum reservable space */ 209 uint32_t un_resv; /* reserved byte count for this trans */ 210 uint32_t un_resv_wantin; /* reserved byte count for next trans */ 211 212 /* 213 * Used during logscan 214 */ 215 uint32_t un_tid; 216 217 /* 218 * Read/Write Buffers 219 */ 220 cirbuf_t un_rdbuf; /* read buffer space */ 221 cirbuf_t un_wrbuf; /* write buffer space */ 222 223 /* 224 * Ondisk state 225 */ 226 ml_odunit_t un_ondisk; /* ondisk log information */ 227 228 /* 229 * locks 230 */ 231 kmutex_t un_log_mutex; /* allows one log write at a time */ 232 kmutex_t un_state_mutex; /* only 1 state update at a time */ 233} ml_unit_t; 234 235/* 236 * Macros to allow access to the ondisk elements via the ml_unit_t incore 237 * structure. 238 */ 239 240#define un_version un_ondisk.od_version 241#define un_badlog un_ondisk.od_badlog 242#define un_maxtransfer un_ondisk.od_maxtransfer 243#define un_devbsize un_ondisk.od_devbsize 244#define un_bol_lof un_ondisk.od_bol_lof 245#define un_eol_lof un_ondisk.od_eol_lof 246#define un_statesize un_ondisk.od_statesize 247#define un_logsize un_ondisk.od_logsize 248#define un_statebno un_ondisk.od_statebno 249#define un_requestsize un_ondisk.od_requestsize 250#define un_head_lof un_ondisk.od_head_lof 251#define un_head_ident un_ondisk.od_head_ident 252#define un_tail_lof un_ondisk.od_tail_lof 253#define un_tail_ident un_ondisk.od_tail_ident 254#define un_chksum un_ondisk.od_chksum 255#define un_head_tid un_ondisk.od_head_tid 256#define un_debug un_ondisk.od_debug 257#define un_timestamp un_ondisk.od_timestamp 258 259/* 260 * un_flags 261 */ 262#define LDL_SCAN 0x0001 /* log scan in progress */ 263#define LDL_ERROR 0x0002 /* in error state */ 264#define LDL_NOROLL 0x0004 /* Log Not Yet Rollable */ 265 266typedef struct sect_trailer { 267 uint32_t st_tid; /* transaction id */ 268 uint32_t st_ident; /* unique sector id */ 269} sect_trailer_t; 270 271/* 272 * map block 273 */ 274#define MAPBLOCKSIZE (8192) 275#define MAPBLOCKSHIFT (13) 276#define MAPBLOCKOFF (MAPBLOCKSIZE-1) 277#define MAPBLOCKMASK (~MAPBLOCKOFF) 278#define DEV_BMASK (DEV_BSIZE - 1) 279 280/* 281 * cached roll buffer 282 */ 283typedef struct crb { 284 int64_t c_mof; /* master file offset of buffer */ 285 caddr_t c_buf; /* pointer to cached roll buffer */ 286 uint32_t c_nb; /* size of buffer */ 287 ushort_t c_refcnt; /* reference count on crb */ 288 uchar_t c_invalid; /* crb should not be used */ 289} crb_t; 290 291#define CRB_END ((crb_t *)1) /* must be non zero */ 292 293/* 294 * delta header 295 */ 296struct delta { 297 int64_t d_mof; /* byte offset on device to start writing */ 298 /* delta */ 299 int32_t d_nb; /* # bytes in the delta */ 300 delta_t d_typ; /* Type of delta. Defined in ufs_trans.h */ 301}; 302/* 303 * common map entry 304 */ 305typedef struct mapentry mapentry_t; 306struct mapentry { 307 /* 308 * doubly linked list of all mapentries in map -- MUST BE FIRST 309 */ 310 mapentry_t *me_next; 311 mapentry_t *me_prev; 312 313 mapentry_t *me_hash; 314 mapentry_t *me_agenext; 315 mapentry_t *me_cancel; 316 crb_t *me_crb; 317 int (*me_func)(); 318 ulong_t me_arg; 319 ulong_t me_age; 320 struct delta me_delta; 321 uint32_t me_tid; 322 off_t me_lof; 323 ushort_t me_flags; 324}; 325 326#define me_mof me_delta.d_mof 327#define me_nb me_delta.d_nb 328#define me_dt me_delta.d_typ 329 330/* 331 * me_flags 332 */ 333#define ME_SCAN (0x0001) /* entry from log scan */ 334#define ME_HASH (0x0002) /* on hash list */ 335#define ME_CANCEL (0x0004) /* on cancel list */ 336#define ME_AGE (0x0008) /* on age list */ 337#define ME_LIST (0x0010) /* on list list */ 338#define ME_ROLL (0x0020) /* on pseudo-roll list */ 339#define ME_USER (0x0040) /* User Block DT_CANCEL entry */ 340 341/* 342 * MAP TYPES 343 */ 344enum maptypes { 345 deltamaptype, logmaptype, matamaptype 346}; 347 348/* 349 * MAP 350 */ 351#define DELTAMAP_NHASH (512) 352#define LOGMAP_NHASH (2048) 353#define MAP_INDEX(mof, mtm) \ 354 (((mof) >> MAPBLOCKSHIFT) & (mtm->mtm_nhash-1)) 355#define MAP_HASH(mof, mtm) \ 356 ((mtm)->mtm_hash + MAP_INDEX((mof), (mtm))) 357 358typedef struct mt_map { 359 /* 360 * anchor doubly linked list this map's entries -- MUST BE FIRST 361 */ 362 mapentry_t *mtm_next; 363 mapentry_t *mtm_prev; 364 365 enum maptypes mtm_type; /* map type */ 366 int mtm_flags; /* generic flags */ 367 int mtm_ref; /* PTE like ref bit */ 368 ulong_t mtm_debug; /* set at create time */ 369 ulong_t mtm_age; /* mono-inc; tags mapentries */ 370 mapentry_t *mtm_cancel; /* to be canceled at commit */ 371 ulong_t mtm_nhash; /* # of hash anchors */ 372 mapentry_t **mtm_hash; /* array of singly linked lists */ 373 struct topstats *mtm_tops; /* trans ops - enabled by an ioctl */ 374 long mtm_nme; /* # of mapentries */ 375 long mtm_nmet; /* # of mapentries this transaction */ 376 long mtm_cfrags; /* Canceled frags */ 377 long mtm_cfragmax; /* Maximum canceled frags */ 378 /* 379 * used after logscan to set the log's tail 380 */ 381 off_t mtm_tail_lof; 382 size_t mtm_tail_nb; 383 384 /* 385 * debug field for Scan test 386 */ 387 off_t mtm_trimlof; /* log was trimmed to this lof */ 388 off_t mtm_trimtail; /* tail lof before trimming */ 389 off_t mtm_trimalof; /* lof of last allocation delta */ 390 off_t mtm_trimclof; /* lof of last commit delta */ 391 off_t mtm_trimrlof; /* lof of last rolled delta */ 392 ml_unit_t *mtm_ul; /* log unit for this map */ 393 394 /* 395 * moby trans stuff 396 */ 397 uint32_t mtm_tid; 398 uint32_t mtm_committid; 399 ushort_t mtm_closed; 400 ushort_t mtm_seq; 401 long mtm_wantin; 402 long mtm_active; 403 long mtm_activesync; 404 ulong_t mtm_dirty; 405 kmutex_t mtm_lock; 406 kcondvar_t mtm_cv_commit; 407 kcondvar_t mtm_cv_next; 408 kcondvar_t mtm_cv_eot; 409 410 /* 411 * mutex that protects all the fields in mt_map except 412 * mtm_mapnext and mtm_refcnt 413 */ 414 kmutex_t mtm_mutex; 415 416 /* 417 * logmap only condition variables 418 */ 419 kcondvar_t mtm_to_roll_cv; /* roll log or kill roll thread */ 420 kcondvar_t mtm_from_roll_cv; /* log rolled or thread exiting */ 421 422 /* 423 * rw lock for the agenext mapentry field 424 */ 425 krwlock_t mtm_rwlock; 426 /* 427 * DEBUG: runtestscan 428 */ 429 kmutex_t mtm_scan_mutex; 430 431 /* 432 * logmap only taskq sync count variable, protected by mtm_lock. 433 * keeps track of the number of pending top_issue_sync 434 * dispatches. 435 */ 436 int mtm_taskq_sync_count; 437 438 /* 439 * logmap only condition variable, to synchronize with lufs_unsnarf. 440 */ 441 kcondvar_t mtm_cv; 442} mt_map_t; 443 444/* 445 * mtm_flags 446 */ 447#define MTM_ROLL_EXIT 0x00000001 /* force roll thread to exit */ 448#define MTM_ROLL_RUNNING 0x00000002 /* roll thread is running */ 449#define MTM_FORCE_ROLL 0x00000004 /* force at least one roll cycle */ 450#define MTM_ROLLING 0x00000008 /* currently rolling the log */ 451#define MTM_CANCELED 0x00000010 /* cancel entries were removed */ 452 453/* 454 * Generic range checking macros 455 */ 456#define OVERLAP(sof, snb, dof, dnb) \ 457 (((sof) >= (dof) && (sof) < ((dof) + (dnb))) || \ 458 ((dof) >= (sof) && (dof) < ((sof) + (snb)))) 459#define WITHIN(sof, snb, dof, dnb) \ 460 (((sof) >= (dof)) && (((sof) + (snb)) <= ((dof) + (dnb)))) 461#define DATAoverlapME(mof, hnb, me) \ 462 (OVERLAP((mof), (hnb), (me)->me_mof, (me)->me_nb)) 463#define MEwithinDATA(me, mof, hnb) \ 464 (WITHIN((me)->me_mof, (me)->me_nb, (mof), (hnb))) 465#define DATAwithinME(mof, hnb, me) \ 466 (WITHIN((mof), (hnb), (me)->me_mof, (me)->me_nb)) 467#define DATAwithinCRB(mof, nb, crb) \ 468 (WITHIN((mof), (nb), (crb)->c_mof, (crb)->c_nb)) 469 470/* 471 * TRANSACTION OPS STATS 472 */ 473typedef struct topstats { 474 uint64_t mtm_top_num[TOP_MAX]; 475 uint64_t mtm_top_size_etot[TOP_MAX]; 476 uint64_t mtm_top_size_rtot[TOP_MAX]; 477 uint64_t mtm_top_size_max[TOP_MAX]; 478 uint64_t mtm_top_size_min[TOP_MAX]; 479 uint64_t mtm_delta_num[DT_MAX]; 480} topstats_t; 481 482/* 483 * fio_lufs_stats_t is used by _FIO_GET_TOP_STATS ioctl for getting topstats 484 */ 485typedef struct fio_lufs_stats { 486 uint32_t ls_debug; /* out: un_debug value */ 487 uint32_t _ls_pad; /* make size 64-bit aligned on x86 */ 488 topstats_t ls_topstats; /* out: transaction stats */ 489} fio_lufs_stats_t; 490 491/* 492 * roll buf structure; one per roll buffer 493 */ 494typedef uint16_t rbsecmap_t; 495typedef struct rollbuf { 496 buf_t rb_bh; /* roll buffer header */ 497 struct rollbuf *rb_next; /* link for mof ordered roll bufs */ 498 crb_t *rb_crb; /* cached roll buffer to roll */ 499 mapentry_t *rb_age; /* age list */ 500 rbsecmap_t rb_secmap; /* sector map */ 501} rollbuf_t; 502 503/* 504 * un_debug 505 * MT_TRANSACT - keep per thread accounting of tranactions 506 * MT_MATAMAP - double check deltas and ops against matamap 507 * MT_WRITE_CHECK - check master+deltas against metadata write 508 * MT_LOG_WRITE_CHECK - read after write for log writes 509 * MT_CHECK_MAP - check map after every insert/delete 510 * MT_TRACE - trace transactions (used with MT_TRANSACT) 511 * MT_SIZE - fail on size errors (used with MT_TRANSACT) 512 * MT_NOASYNC - force every op to be sync 513 * MT_FORCEROLL - forcibly roll the log after every commit 514 * MT_SCAN - running runtestscan; special case as needed 515 */ 516#define MT_NONE (0x00000000) 517#define MT_TRANSACT (0x00000001) 518#define MT_MATAMAP (0x00000002) 519#define MT_WRITE_CHECK (0x00000004) 520#define MT_LOG_WRITE_CHECK (0x00000008) 521#define MT_CHECK_MAP (0x00000010) 522#define MT_TRACE (0x00000020) 523#define MT_SIZE (0x00000040) 524#define MT_NOASYNC (0x00000080) 525#define MT_FORCEROLL (0x00000100) 526#define MT_SCAN (0x00000200) 527 528struct logstats { 529 kstat_named_t ls_lreads; /* master reads */ 530 kstat_named_t ls_lwrites; /* master writes */ 531 kstat_named_t ls_lreadsinmem; /* log reads in memory */ 532 kstat_named_t ls_ldlreads; /* log reads */ 533 kstat_named_t ls_ldlwrites; /* log writes */ 534 kstat_named_t ls_mreads; /* log master reads */ 535 kstat_named_t ls_rreads; /* log roll reads */ 536 kstat_named_t ls_rwrites; /* log roll writes */ 537}; 538 539#ifdef _KERNEL 540 541typedef struct threadtrans { 542 ulong_t deltas_size; /* size of deltas this transaction */ 543 uint32_t last_async_tid; /* last async transaction id */ 544 uchar_t any_deltas; /* any deltas done this transaction */ 545#ifdef DEBUG 546 uint_t topid; /* transaction type */ 547 ulong_t esize; /* estimated trans size */ 548 ulong_t rsize; /* real trans size */ 549 dev_t dev; /* device */ 550#endif /* DEBUG */ 551} threadtrans_t; 552 553/* 554 * Log layer protos -- lufs_log.c 555 */ 556extern void ldl_strategy(ml_unit_t *, buf_t *); 557extern void ldl_round_commit(ml_unit_t *); 558extern void ldl_push_commit(ml_unit_t *); 559extern int ldl_need_commit(ml_unit_t *); 560extern int ldl_has_space(ml_unit_t *, mapentry_t *); 561extern void ldl_write(ml_unit_t *, caddr_t, offset_t, mapentry_t *); 562extern void ldl_waito(ml_unit_t *); 563extern int ldl_read(ml_unit_t *, caddr_t, offset_t, off_t, 564 mapentry_t *); 565extern void ldl_sethead(ml_unit_t *, off_t, uint32_t); 566extern void ldl_settail(ml_unit_t *, off_t, size_t); 567extern ulong_t ldl_logscan_nbcommit(off_t); 568extern int ldl_logscan_read(ml_unit_t *, off_t *, size_t, caddr_t); 569extern void ldl_logscan_begin(ml_unit_t *); 570extern void ldl_logscan_end(ml_unit_t *); 571extern int ldl_need_roll(ml_unit_t *); 572extern void ldl_seterror(ml_unit_t *, char *); 573extern size_t ldl_bufsize(ml_unit_t *); 574extern void ldl_savestate(ml_unit_t *); 575extern void free_cirbuf(cirbuf_t *); 576extern void alloc_rdbuf(cirbuf_t *, size_t, size_t); 577extern void alloc_wrbuf(cirbuf_t *, size_t); 578 579/* 580 * trans driver layer -- lufs.c 581 */ 582extern int trans_not_wait(struct buf *cb); 583extern int trans_not_done(struct buf *cb); 584extern int trans_wait(struct buf *cb); 585extern int trans_done(struct buf *cb); 586extern void lufs_strategy(ml_unit_t *, buf_t *); 587extern void lufs_read_strategy(ml_unit_t *, buf_t *); 588extern void lufs_write_strategy(ml_unit_t *, buf_t *); 589extern void lufs_init(void); 590extern uint32_t lufs_hd_genid(const ml_unit_t *); 591extern int lufs_enable(struct vnode *, struct fiolog *, cred_t *); 592extern int lufs_disable(vnode_t *, struct fiolog *); 593 594/* 595 * transaction op layer -- lufs_top.c 596 */ 597extern void _init_top(void); 598extern int top_read_roll(rollbuf_t *, ml_unit_t *); 599 600 601/* 602 * map layer -- lufs_map.c 603 */ 604extern void map_free_entries(mt_map_t *); 605extern int matamap_overlap(mt_map_t *, offset_t, off_t); 606extern int matamap_within(mt_map_t *, offset_t, off_t); 607extern int deltamap_need_commit(mt_map_t *); 608extern void deltamap_add(mt_map_t *, offset_t, off_t, delta_t, 609 int (*)(), ulong_t, threadtrans_t *tp); 610extern mapentry_t *deltamap_remove(mt_map_t *, offset_t, off_t); 611extern void deltamap_del(mt_map_t *, offset_t, off_t); 612extern void deltamap_push(ml_unit_t *); 613extern void logmap_cancel_remove(mt_map_t *); 614extern int logmap_need_commit(mt_map_t *); 615extern int logmap_need_roll_async(mt_map_t *); 616extern int logmap_need_roll_sync(mt_map_t *); 617extern void logmap_start_roll(ml_unit_t *); 618extern void logmap_kill_roll(ml_unit_t *); 619extern void logmap_forceroll(mt_map_t *); 620extern void logmap_forceroll_nowait(mt_map_t *); 621extern int logmap_overlap(mt_map_t *, offset_t, off_t); 622extern void logmap_remove_roll(mt_map_t *, offset_t, off_t); 623extern int logmap_next_roll(mt_map_t *, offset_t *); 624extern int logmap_list_get(mt_map_t *, offset_t, off_t, 625 mapentry_t **); 626extern int logmap_list_get_roll(mt_map_t *, offset_t, rollbuf_t *); 627extern void logmap_list_put(mt_map_t *, mapentry_t *); 628extern void logmap_list_put_roll(mt_map_t *, mapentry_t *); 629extern int logmap_setup_read(mapentry_t *, rollbuf_t *); 630extern void logmap_make_space(struct mt_map *, ml_unit_t *, 631 mapentry_t *); 632extern void logmap_add(ml_unit_t *, char *, offset_t, mapentry_t *); 633extern void logmap_add_buf(ml_unit_t *, char *, offset_t, 634 mapentry_t *, caddr_t, uint32_t); 635extern void logmap_commit(ml_unit_t *, uint32_t); 636extern void logmap_sethead(mt_map_t *, ml_unit_t *); 637extern void logmap_settail(mt_map_t *, ml_unit_t *); 638extern void logmap_roll_dev(ml_unit_t *ul); 639extern void logmap_cancel(ml_unit_t *, offset_t, off_t, int); 640extern void logmap_free_cancel(mt_map_t *, mapentry_t **); 641extern int logmap_iscancel(mt_map_t *, offset_t, off_t); 642extern void logmap_logscan(ml_unit_t *); 643extern mt_map_t *map_put(mt_map_t *); 644extern mt_map_t *map_get(ml_unit_t *, enum maptypes, int); 645extern void _init_map(void); 646 647/* 648 * scan and roll threads -- lufs_thread.c 649 */ 650extern void trans_roll(ml_unit_t *); 651 652/* 653 * DEBUG 654 */ 655#ifdef DEBUG 656extern int map_put_debug(mt_map_t *); 657extern int map_get_debug(ml_unit_t *, mt_map_t *); 658extern int top_write_debug(ml_unit_t *, mapentry_t *, offset_t, off_t); 659extern int matamap_overlap(mt_map_t *, offset_t, off_t); 660extern int ldl_sethead_debug(ml_unit_t *); 661extern int map_check_linkage(mt_map_t *); 662extern int logmap_logscan_debug(mt_map_t *, mapentry_t *); 663extern int map_check_ldl_write(ml_unit_t *, caddr_t, offset_t, 664 mapentry_t *); 665extern int logmap_logscan_commit_debug(off_t, mt_map_t *); 666extern int logmap_logscan_add_debug(struct delta *, mt_map_t *); 667extern int top_delta_debug(ml_unit_t *, offset_t, off_t, delta_t); 668extern int top_begin_debug(ml_unit_t *, top_t, ulong_t); 669extern int top_end_debug(ml_unit_t *, mt_map_t *, top_t, ulong_t); 670extern int top_roll_debug(ml_unit_t *); 671extern int top_init_debug(void); 672extern int lufs_initialize_debug(ml_odunit_t *); 673#endif /* DEBUG */ 674 675extern uint64_t delta_stats[DT_MAX]; 676extern uint64_t roll_stats[DT_MAX]; 677extern struct logstats logstats; 678extern int ufs_crb_enable; 679 680extern uint_t topkey; 681extern uint32_t ufs_ncg_log; 682 683extern uint_t lufs_debug; 684 685#endif /* _KERNEL */ 686 687#ifdef __cplusplus 688} 689#endif 690 691#endif /* _SYS_FS_UFS_LOG_H */ 692