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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 24 * 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 26 * Use is subject to license terms. 27 */ 28 29 #ifndef _SYS_FS_UFS_TRANS_H 30 #define _SYS_FS_UFS_TRANS_H 31 32 #ifdef __cplusplus 33 extern "C" { 34 #endif 35 36 #include <sys/types.h> 37 #include <sys/cred.h> 38 #include <sys/fs/ufs_fs.h> 39 40 /* 41 * Types of deltas 42 */ 43 typedef enum delta_type { 44 DT_NONE, /* 0 no assigned type */ 45 DT_SB, /* 1 superblock */ 46 DT_CG, /* 2 cylinder group */ 47 DT_SI, /* 3 summary info */ 48 DT_AB, /* 4 allocation block */ 49 DT_ABZERO, /* 5 a zero'ed allocation block */ 50 DT_DIR, /* 6 directory */ 51 DT_INODE, /* 7 inode */ 52 DT_FBI, /* 8 fbiwrite */ 53 DT_QR, /* 9 quota record */ 54 DT_COMMIT, /* 10 commit record */ 55 DT_CANCEL, /* 11 cancel record */ 56 DT_BOT, /* 12 begin transaction */ 57 DT_EOT, /* 13 end transaction */ 58 DT_UD, /* 14 userdata */ 59 DT_SUD, /* 15 userdata found during log scan */ 60 DT_SHAD, /* 16 data for a shadow inode */ 61 DT_MAX /* 17 maximum delta type */ 62 } delta_t; 63 64 /* 65 * transaction operation types 66 */ 67 typedef enum top_type { 68 TOP_READ_SYNC, /* 0 */ 69 TOP_WRITE, /* 1 */ 70 TOP_WRITE_SYNC, /* 2 */ 71 TOP_SETATTR, /* 3 */ 72 TOP_CREATE, /* 4 */ 73 TOP_REMOVE, /* 5 */ 74 TOP_LINK, /* 6 */ 75 TOP_RENAME, /* 7 */ 76 TOP_MKDIR, /* 8 */ 77 TOP_RMDIR, /* 9 */ 78 TOP_SYMLINK, /* 10 */ 79 TOP_FSYNC, /* 11 */ 80 TOP_GETPAGE, /* 12 */ 81 TOP_PUTPAGE, /* 13 */ 82 TOP_SBUPDATE_FLUSH, /* 14 */ 83 TOP_SBUPDATE_UPDATE, /* 15 */ 84 TOP_SBUPDATE_UNMOUNT, /* 16 */ 85 TOP_SYNCIP_CLOSEDQ, /* 17 */ 86 TOP_SYNCIP_FLUSHI, /* 18 */ 87 TOP_SYNCIP_HLOCK, /* 19 */ 88 TOP_SYNCIP_SYNC, /* 20 */ 89 TOP_SYNCIP_FREE, /* 21 */ 90 TOP_SBWRITE_RECLAIM, /* 22 */ 91 TOP_SBWRITE_STABLE, /* 23 */ 92 TOP_IFREE, /* 24 */ 93 TOP_IUPDAT, /* 25 */ 94 TOP_MOUNT, /* 26 */ 95 TOP_COMMIT_ASYNC, /* 27 */ 96 TOP_COMMIT_FLUSH, /* 28 */ 97 TOP_COMMIT_UPDATE, /* 29 */ 98 TOP_COMMIT_UNMOUNT, /* 30 */ 99 TOP_SETSECATTR, /* 31 */ 100 TOP_QUOTA, /* 32 */ 101 TOP_ITRUNC, /* 33 */ 102 TOP_ALLOCSP, /* 34 */ 103 TOP_MAX /* 35 TOP_MAX MUST be the last entry */ 104 } top_t; 105 106 struct inode; 107 struct ufsvfs; 108 109 /* 110 * vfs_log == NULL means not logging 111 */ 112 #define TRANS_ISTRANS(ufsvfsp) (ufsvfsp->vfs_log) 113 114 /* 115 * begin a synchronous transaction 116 */ 117 #define TRANS_BEGIN_SYNC(ufsvfsp, vid, vsize, error)\ 118 {\ 119 if (TRANS_ISTRANS(ufsvfsp)) { \ 120 error = 0; \ 121 top_begin_sync(ufsvfsp, vid, vsize, &error); \ 122 } \ 123 } 124 125 /* 126 * begin a asynchronous transaction 127 */ 128 #define TRANS_BEGIN_ASYNC(ufsvfsp, vid, vsize)\ 129 {\ 130 if (TRANS_ISTRANS(ufsvfsp))\ 131 (void) top_begin_async(ufsvfsp, vid, vsize, 0); \ 132 } 133 134 /* 135 * try to begin a asynchronous transaction 136 */ 137 #define TRANS_TRY_BEGIN_ASYNC(ufsvfsp, vid, vsize, err)\ 138 {\ 139 if (TRANS_ISTRANS(ufsvfsp))\ 140 err = top_begin_async(ufsvfsp, vid, vsize, 1); \ 141 else\ 142 err = 0; \ 143 } 144 145 /* 146 * Begin a synchronous or asynchronous transaction. 147 * The lint case is needed because vsize can be a constant. 148 */ 149 #ifndef __lint 150 151 #define TRANS_BEGIN_CSYNC(ufsvfsp, issync, vid, vsize)\ 152 {\ 153 if (TRANS_ISTRANS(ufsvfsp)) {\ 154 if (ufsvfsp->vfs_syncdir) {\ 155 int error = 0; \ 156 ASSERT(vsize); \ 157 top_begin_sync(ufsvfsp, vid, vsize, &error); \ 158 ASSERT(error == 0); \ 159 issync = 1; \ 160 } else {\ 161 (void) top_begin_async(ufsvfsp, vid, vsize, 0); \ 162 issync = 0; \ 163 }\ 164 }\ 165 } 166 167 #else /* __lint */ 168 169 #define TRANS_BEGIN_CSYNC(ufsvfsp, issync, vid, vsize)\ 170 {\ 171 if (TRANS_ISTRANS(ufsvfsp)) {\ 172 if (ufsvfsp->vfs_syncdir) {\ 173 int error = 0; \ 174 top_begin_sync(ufsvfsp, vid, vsize, &error); \ 175 issync = 1; \ 176 } else {\ 177 (void) top_begin_async(ufsvfsp, vid, vsize, 0); \ 178 issync = 0; \ 179 }\ 180 }\ 181 } 182 #endif /* __lint */ 183 184 /* 185 * try to begin a synchronous or asynchronous transaction 186 */ 187 188 #define TRANS_TRY_BEGIN_CSYNC(ufsvfsp, issync, vid, vsize, error)\ 189 {\ 190 if (TRANS_ISTRANS(ufsvfsp)) {\ 191 if (ufsvfsp->vfs_syncdir) {\ 192 ASSERT(vsize); \ 193 top_begin_sync(ufsvfsp, vid, vsize, &error); \ 194 ASSERT(error == 0); \ 195 issync = 1; \ 196 } else {\ 197 error = top_begin_async(ufsvfsp, vid, vsize, 1); \ 198 issync = 0; \ 199 }\ 200 }\ 201 }\ 202 203 204 /* 205 * end a asynchronous transaction 206 */ 207 #define TRANS_END_ASYNC(ufsvfsp, vid, vsize)\ 208 {\ 209 if (TRANS_ISTRANS(ufsvfsp))\ 210 top_end_async(ufsvfsp, vid, vsize); \ 211 } 212 213 /* 214 * end a synchronous transaction 215 */ 216 #define TRANS_END_SYNC(ufsvfsp, error, vid, vsize)\ 217 {\ 218 if (TRANS_ISTRANS(ufsvfsp))\ 219 top_end_sync(ufsvfsp, &error, vid, vsize); \ 220 } 221 222 /* 223 * end a synchronous or asynchronous transaction 224 */ 225 #define TRANS_END_CSYNC(ufsvfsp, error, issync, vid, vsize)\ 226 {\ 227 if (TRANS_ISTRANS(ufsvfsp))\ 228 if (issync)\ 229 top_end_sync(ufsvfsp, &error, vid, vsize); \ 230 else\ 231 top_end_async(ufsvfsp, vid, vsize); \ 232 } 233 /* 234 * record a delta 235 */ 236 #define TRANS_DELTA(ufsvfsp, mof, nb, dtyp, func, arg) \ 237 if (TRANS_ISTRANS(ufsvfsp)) \ 238 top_delta(ufsvfsp, (offset_t)(mof), nb, dtyp, func, arg) 239 240 /* 241 * cancel a delta 242 */ 243 #define TRANS_CANCEL(ufsvfsp, mof, nb, flags) \ 244 if (TRANS_ISTRANS(ufsvfsp)) \ 245 top_cancel(ufsvfsp, (offset_t)(mof), nb, flags) 246 /* 247 * log a delta 248 */ 249 #define TRANS_LOG(ufsvfsp, va, mof, nb, buf, bufsz) \ 250 if (TRANS_ISTRANS(ufsvfsp)) \ 251 top_log(ufsvfsp, va, (offset_t)(mof), nb, buf, bufsz) 252 /* 253 * check if a range is being canceled (converting from metadata into userdata) 254 */ 255 #define TRANS_ISCANCEL(ufsvfsp, mof, nb) \ 256 ((TRANS_ISTRANS(ufsvfsp)) ? \ 257 top_iscancel(ufsvfsp, (offset_t)(mof), nb) : 0) 258 /* 259 * put the log into error state 260 */ 261 #define TRANS_SETERROR(ufsvfsp) \ 262 if (TRANS_ISTRANS(ufsvfsp)) \ 263 top_seterror(ufsvfsp) 264 /* 265 * check if device has had an error 266 */ 267 #define TRANS_ISERROR(ufsvfsp) \ 268 ((TRANS_ISTRANS(ufsvfsp)) ? \ 269 ufsvfsp->vfs_log->un_flags & LDL_ERROR : 0) 270 271 /* 272 * The following macros provide a more readable interface to TRANS_DELTA 273 */ 274 #define TRANS_BUF(ufsvfsp, vof, nb, bp, type) \ 275 TRANS_DELTA(ufsvfsp, \ 276 ldbtob(bp->b_blkno) + (offset_t)(vof), nb, type, \ 277 ufs_trans_push_buf, bp->b_blkno) 278 279 #define TRANS_BUF_ITEM_128(ufsvfsp, item, base, bp, type) \ 280 TRANS_BUF(ufsvfsp, \ 281 (((uintptr_t)&(item)) & ~(128 - 1)) - (uintptr_t)(base), 128, bp, type) 282 283 #define TRANS_INODE(ufsvfsp, ip) \ 284 TRANS_DELTA(ufsvfsp, ip->i_doff, sizeof (struct dinode), \ 285 DT_INODE, ufs_trans_push_inode, ip->i_number) 286 287 /* 288 * If ever parts of an inode except the timestamps are logged using 289 * this macro (or any other technique), bootloader logging support must 290 * be made aware of these changes. 291 */ 292 #define TRANS_INODE_DELTA(ufsvfsp, vof, nb, ip) \ 293 TRANS_DELTA(ufsvfsp, (ip->i_doff + (offset_t)(vof)), \ 294 nb, DT_INODE, ufs_trans_push_inode, ip->i_number) 295 296 #define TRANS_INODE_TIMES(ufsvfsp, ip) \ 297 TRANS_INODE_DELTA(ufsvfsp, (caddr_t)&ip->i_atime - (caddr_t)&ip->i_ic, \ 298 sizeof (struct timeval32) * 3, ip) 299 300 /* 301 * Check if we need to log cylinder group summary info. 302 */ 303 #define TRANS_SI(ufsvfsp, fs, cg) \ 304 if (TRANS_ISTRANS(ufsvfsp)) \ 305 if (ufsvfsp->vfs_nolog_si) \ 306 fs->fs_si = FS_SI_BAD; \ 307 else \ 308 TRANS_DELTA(ufsvfsp, \ 309 ldbtob(fsbtodb(fs, fs->fs_csaddr)) + \ 310 ((caddr_t)&fs->fs_cs(fs, cg) - \ 311 (caddr_t)fs->fs_u.fs_csp), \ 312 sizeof (struct csum), DT_SI, \ 313 ufs_trans_push_si, cg) 314 315 #define TRANS_DIR(ip, offset) \ 316 (TRANS_ISTRANS(ip->i_ufsvfs) ? ufs_trans_dir(ip, offset) : 0) 317 318 #define TRANS_QUOTA(dqp) \ 319 if (TRANS_ISTRANS(dqp->dq_ufsvfsp)) \ 320 ufs_trans_quota(dqp); 321 322 #define TRANS_DQRELE(ufsvfsp, dqp) \ 323 if (TRANS_ISTRANS(ufsvfsp) && \ 324 ((curthread->t_flag & T_DONTBLOCK) == 0)) { \ 325 ufs_trans_dqrele(dqp); \ 326 } else { \ 327 rw_enter(&ufsvfsp->vfs_dqrwlock, RW_READER); \ 328 dqrele(dqp); \ 329 rw_exit(&ufsvfsp->vfs_dqrwlock); \ 330 } 331 332 #define TRANS_ITRUNC(ip, length, flags, cr) \ 333 ufs_trans_itrunc(ip, length, flags, cr); 334 335 #define TRANS_WRITE_RESV(ip, uiop, ulp, resvp, residp) \ 336 if ((TRANS_ISTRANS(ip->i_ufsvfs) != NULL) && (ulp != NULL)) \ 337 ufs_trans_write_resv(ip, uiop, resvp, residp); 338 339 #define TRANS_WRITE(ip, uiop, ioflag, err, ulp, cr, resv, resid) \ 340 if ((TRANS_ISTRANS(ip->i_ufsvfs) != NULL) && (ulp != NULL)) \ 341 err = ufs_trans_write(ip, uiop, ioflag, cr, resv, resid); \ 342 else \ 343 err = wrip(ip, uiop, ioflag, cr); 344 345 /* 346 * These functions "wrap" functions that are not VOP or VFS 347 * entry points but must still use the TRANS_BEGIN/TRANS_END 348 * protocol 349 */ 350 #define TRANS_SBUPDATE(ufsvfsp, vfsp, topid) \ 351 ufs_trans_sbupdate(ufsvfsp, vfsp, topid) 352 #define TRANS_SYNCIP(ip, bflags, iflag, topid) \ 353 ufs_syncip(ip, bflags, iflag, topid) 354 #define TRANS_SBWRITE(ufsvfsp, topid) ufs_trans_sbwrite(ufsvfsp, topid) 355 #define TRANS_IUPDAT(ip, waitfor) ufs_trans_iupdat(ip, waitfor) 356 357 #ifdef DEBUG 358 /* 359 * Test/Debug ops 360 * The following ops maintain the metadata map. 361 * The metadata map is a debug/test feature. 362 * These ops are *not* used in the production product. 363 */ 364 365 /* 366 * Set a flag if meta data checking. 367 */ 368 #define TRANS_DOMATAMAP(ufsvfsp) \ 369 ufsvfsp->vfs_domatamap = \ 370 (TRANS_ISTRANS(ufsvfsp) && \ 371 (ufsvfsp->vfs_log->un_debug & MT_MATAMAP)) 372 373 #define TRANS_MATA_IGET(ufsvfsp, ip) \ 374 if (ufsvfsp->vfs_domatamap) \ 375 ufs_trans_mata_iget(ip) 376 377 #define TRANS_MATA_FREE(ufsvfsp, mof, nb) \ 378 if (ufsvfsp->vfs_domatamap) \ 379 ufs_trans_mata_free(ufsvfsp, (offset_t)(mof), nb) 380 381 #define TRANS_MATA_ALLOC(ufsvfsp, ip, bno, size, zero) \ 382 if (ufsvfsp->vfs_domatamap) \ 383 ufs_trans_mata_alloc(ufsvfsp, ip, bno, size, zero) 384 385 #define TRANS_MATA_MOUNT(ufsvfsp) \ 386 if (ufsvfsp->vfs_domatamap) \ 387 ufs_trans_mata_mount(ufsvfsp) 388 389 #define TRANS_MATA_UMOUNT(ufsvfsp) \ 390 if (ufsvfsp->vfs_domatamap) \ 391 ufs_trans_mata_umount(ufsvfsp) 392 393 #define TRANS_MATA_SI(ufsvfsp, fs) \ 394 if (ufsvfsp->vfs_domatamap) \ 395 ufs_trans_mata_si(ufsvfsp, fs) 396 397 #define TRANS_MATAADD(ufsvfsp, mof, nb) \ 398 top_mataadd(ufsvfsp, (offset_t)(mof), nb) 399 400 #else /* !DEBUG */ 401 402 #define TRANS_DOMATAMAP(ufsvfsp) 403 #define TRANS_MATA_IGET(ufsvfsp, ip) 404 #define TRANS_MATA_FREE(ufsvfsp, mof, nb) 405 #define TRANS_MATA_ALLOC(ufsvfsp, ip, bno, size, zero) 406 #define TRANS_MATA_MOUNT(ufsvfsp) 407 #define TRANS_MATA_UMOUNT(ufsvfsp) 408 #define TRANS_MATA_SI(ufsvfsp, fs) 409 #define TRANS_MATAADD(ufsvfsp, mof, nb) 410 411 #endif /* !DEBUG */ 412 413 #include <sys/fs/ufs_quota.h> 414 #include <sys/fs/ufs_lockfs.h> 415 /* 416 * identifies the type of operation passed into TRANS_BEGIN/END 417 */ 418 #define TOP_SYNC (0x00000001) 419 #define TOP_ASYNC (0x00000002) 420 #define TOP_SYNC_FORCED (0x00000004) /* forced sync transaction */ 421 /* 422 * estimated values 423 */ 424 #define HEADERSIZE (128) 425 #define ALLOCSIZE (160) 426 #define INODESIZE (sizeof (struct dinode) + HEADERSIZE) 427 #define SIZESB ((sizeof (struct fs)) + HEADERSIZE) 428 #define SIZEDIR (DIRBLKSIZ + HEADERSIZE) 429 /* 430 * calculated values 431 */ 432 #define SIZECG(IP) ((IP)->i_fs->fs_cgsize + HEADERSIZE) 433 #define FRAGSIZE(IP) ((IP)->i_fs->fs_fsize + HEADERSIZE) 434 #define ACLSIZE(IP) (((IP)->i_ufsvfs->vfs_maxacl + HEADERSIZE) + \ 435 INODESIZE) 436 #define MAXACLSIZE ((MAX_ACL_ENTRIES << 1) * sizeof (aclent_t)) 437 #define DIRSIZE(IP) (INODESIZE + (4 * ALLOCSIZE) + \ 438 (IP)->i_fs->fs_fsize + HEADERSIZE) 439 #define QUOTASIZE sizeof (struct dquot) + HEADERSIZE 440 /* 441 * size calculations 442 */ 443 #define TOP_CREATE_SIZE(IP) \ 444 (ACLSIZE(IP) + SIZECG(IP) + DIRSIZE(IP) + INODESIZE) 445 #define TOP_REMOVE_SIZE(IP) \ 446 DIRSIZE(IP) + SIZECG(IP) + INODESIZE + SIZESB 447 #define TOP_LINK_SIZE(IP) \ 448 DIRSIZE(IP) + INODESIZE 449 #define TOP_RENAME_SIZE(IP) \ 450 DIRSIZE(IP) + DIRSIZE(IP) + SIZECG(IP) 451 #define TOP_MKDIR_SIZE(IP) \ 452 DIRSIZE(IP) + INODESIZE + DIRSIZE(IP) + INODESIZE + FRAGSIZE(IP) + \ 453 SIZECG(IP) + ACLSIZE(IP) 454 #define TOP_SYMLINK_SIZE(IP) \ 455 DIRSIZE((IP)) + INODESIZE + INODESIZE + SIZECG(IP) 456 #define TOP_GETPAGE_SIZE(IP) \ 457 ALLOCSIZE + ALLOCSIZE + ALLOCSIZE + INODESIZE + SIZECG(IP) 458 #define TOP_SYNCIP_SIZE INODESIZE 459 #define TOP_READ_SIZE INODESIZE 460 #define TOP_RMDIR_SIZE (SIZESB + (INODESIZE * 2) + SIZEDIR) 461 #define TOP_SETQUOTA_SIZE(FS) ((FS)->fs_bsize << 2) 462 #define TOP_QUOTA_SIZE (QUOTASIZE) 463 #define TOP_SETSECATTR_SIZE(IP) (MAXACLSIZE) 464 #define TOP_IUPDAT_SIZE(IP) INODESIZE + SIZECG(IP) 465 #define TOP_SBUPDATE_SIZE (SIZESB) 466 #define TOP_SBWRITE_SIZE (SIZESB) 467 #define TOP_PUTPAGE_SIZE(IP) (INODESIZE + SIZECG(IP)) 468 #define TOP_SETATTR_SIZE(IP) (SIZECG(IP) + INODESIZE + QUOTASIZE + \ 469 ACLSIZE(IP)) 470 #define TOP_IFREE_SIZE(IP) (SIZECG(IP) + INODESIZE + QUOTASIZE) 471 #define TOP_MOUNT_SIZE (SIZESB) 472 #define TOP_COMMIT_SIZE (0) 473 474 /* 475 * The minimum log size is 1M. So we will allow 1 fs operation to 476 * reserve at most 512K of log space. 477 */ 478 #define TOP_MAX_RESV (512 * 1024) 479 480 481 /* 482 * ufs trans function prototypes 483 */ 484 #if defined(_KERNEL) 485 486 extern int ufs_trans_hlock(); 487 extern void ufs_trans_onerror(); 488 extern int ufs_trans_push_inode(struct ufsvfs *, delta_t, ino_t); 489 extern int ufs_trans_push_buf(struct ufsvfs *, delta_t, daddr_t); 490 extern int ufs_trans_push_si(struct ufsvfs *, delta_t, int); 491 extern void ufs_trans_sbupdate(struct ufsvfs *, struct vfs *, 492 top_t); 493 extern void ufs_trans_sbwrite(struct ufsvfs *, top_t); 494 extern void ufs_trans_iupdat(struct inode *, int); 495 extern void ufs_trans_mata_mount(struct ufsvfs *); 496 extern void ufs_trans_mata_umount(struct ufsvfs *); 497 extern void ufs_trans_mata_si(struct ufsvfs *, struct fs *); 498 extern void ufs_trans_mata_iget(struct inode *); 499 extern void ufs_trans_mata_free(struct ufsvfs *, offset_t, off_t); 500 extern void ufs_trans_mata_alloc(struct ufsvfs *, struct inode *, 501 daddr_t, ulong_t, int); 502 extern int ufs_trans_dir(struct inode *, off_t); 503 extern void ufs_trans_quota(struct dquot *); 504 extern void ufs_trans_dqrele(struct dquot *); 505 extern int ufs_trans_itrunc(struct inode *, u_offset_t, int, 506 cred_t *); 507 extern int ufs_trans_write(struct inode *, struct uio *, int, 508 cred_t *, int, long); 509 extern void ufs_trans_write_resv(struct inode *, struct uio *, 510 int *, int *); 511 extern int ufs_trans_check(dev_t); 512 extern void ufs_trans_redev(dev_t odev, dev_t ndev); 513 extern void ufs_trans_trunc_resv(struct inode *, u_offset_t, int *, 514 u_offset_t *); 515 516 /* 517 * transaction prototypes 518 */ 519 void lufs_unsnarf(struct ufsvfs *ufsvfsp); 520 int lufs_snarf(struct ufsvfs *ufsvfsp, struct fs *fs, int ronly); 521 void top_delta(struct ufsvfs *ufsvfsp, offset_t mof, off_t nb, delta_t dtyp, 522 int (*func)(), ulong_t arg); 523 void top_cancel(struct ufsvfs *ufsvfsp, offset_t mof, off_t nb, int flags); 524 int top_iscancel(struct ufsvfs *ufsvfsp, offset_t mof, off_t nb); 525 void top_seterror(struct ufsvfs *ufsvfsp); 526 int top_iserror(struct ufsvfs *ufsvfsp); 527 void top_begin_sync(struct ufsvfs *ufsvfsp, top_t topid, ulong_t size, 528 int *error); 529 int top_begin_async(struct ufsvfs *ufsvfsp, top_t topid, ulong_t size, 530 int tryasync); 531 void top_end_sync(struct ufsvfs *ufsvfsp, int *ep, top_t topid, 532 ulong_t size); 533 void top_end_async(struct ufsvfs *ufsvfsp, top_t topid, ulong_t size); 534 void top_log(struct ufsvfs *ufsvfsp, char *va, offset_t vamof, off_t nb, 535 caddr_t buf, uint32_t bufsz); 536 void top_mataadd(struct ufsvfs *ufsvfsp, offset_t mof, off_t nb); 537 void top_matadel(struct ufsvfs *ufsvfsp, offset_t mof, off_t nb); 538 void top_mataclr(struct ufsvfs *ufsvfsp); 539 540 541 #endif /* defined(_KERNEL) */ 542 543 #ifdef __cplusplus 544 } 545 #endif 546 547 #endif /* _SYS_FS_UFS_TRANS_H */ 548