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 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _SYS_FS_CACHEFS_FS_H 28 #define _SYS_FS_CACHEFS_FS_H 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #include <sys/vnode.h> 33 #include <sys/vfs.h> 34 #include <sys/types.h> 35 #include <sys/types32.h> 36 #include <sys/t_lock.h> 37 #include <sys/thread.h> 38 #include <sys/kmem.h> 39 #include <sys/inttypes.h> 40 #include <sys/time_impl.h> 41 #include <sys/systm.h> 42 43 #ifdef __cplusplus 44 extern "C" { 45 #endif 46 47 #ifdef CFSDEBUG 48 #define CFSDEBUG_ALL 0xffffffff 49 #define CFSDEBUG_NONE 0x0 50 #define CFSDEBUG_GENERAL 0x1 51 #define CFSDEBUG_SUBR 0x2 52 #define CFSDEBUG_CNODE 0x4 53 #define CFSDEBUG_DIR 0x8 54 #define CFSDEBUG_STRICT 0x10 55 #define CFSDEBUG_VOPS 0x20 56 #define CFSDEBUG_VFSOP 0x40 57 #define CFSDEBUG_RESOURCE 0x80 58 #define CFSDEBUG_CHEAT 0x100 59 #define CFSDEBUG_INVALIDATE 0x200 60 #define CFSDEBUG_DLOG 0x400 61 #define CFSDEBUG_FILEGRP 0x800 62 #define CFSDEBUG_IOCTL 0x1000 63 #define CFSDEBUG_FRONT 0x2000 64 #define CFSDEBUG_BACK 0x4000 65 #define CFSDEBUG_ALLOCMAP 0x8000 66 #define CFSDEBUG_ASYNCPOP 0x10000 67 #define CFSDEBUG_VOPS_NFSV4 0x20000 68 69 #define CFSCLEANFLAG 70 71 extern int cachefsdebug; 72 73 #define CFS_DEBUG(N) if (cachefsdebug & (N)) 74 #endif /* DEBUG */ 75 76 #if 0 77 #ifdef CFSDEBUG 78 /* 79 * Testing usage of cd_access and friends. 80 * Note we steal an unused bit in t_flag. 81 * This will certainly bite us later. 82 */ 83 #define CFS_CD_DEBUG 84 #define T_CD_HELD 0x01000 85 #endif 86 #endif 87 88 /* 89 * Note: in an RL debugging kernel, CFSVERSION is augmented by 100 90 * 91 * Version History: 92 * 93 * Beginning -- Solaris 2.3 and 2.4: 1 94 * 95 * In Solaris 2.5 alpha, the size of fid_t changed: 2 96 * 97 * In 2.6: Chart, RL pointers/idents became rl_entry: 3 98 * added which RL list to attrcache header: 4 99 * 100 * Large Files support made version to 6. 101 * 102 * Sequence numbers made version to 7. 103 * 104 * 64-bit on-disk cache will make version 8. Not yet supported. 105 */ 106 107 #if 0 108 #define CFSRLDEBUG 109 #endif 110 111 #ifdef CFSRLDEBUG 112 #define CFSVERSION 110 113 #define CFSVERSION64 111 /* 64-bit cache - not yet used */ 114 #else /* CFSRLDEBUG */ 115 #define CFSVERSION 7 116 #define CFSVERSION64 8 /* 64-bit cache - not yet used */ 117 #endif /* CFSRLDEBUG */ 118 119 /* Some default values */ 120 #define DEF_FILEGRP_SIZE 256 121 #define DEF_POP_SIZE 0x10000 /* 64K */ 122 #define CACHELABEL_NAME ".cfs_label" 123 #define RESOURCE_NAME ".cfs_resource" 124 #define CACHEFS_FSINFO ".cfs_fsinfo" 125 #define ATTRCACHE_NAME ".cfs_attrcache" 126 #define CACHEFS_LOSTFOUND_NAME "lost+found" 127 #define BACKMNT_NAME ".cfs_mnt_points" 128 #define CACHEFS_LOCK_FILE ".cfs_lock" 129 #define CACHEFS_DLOG_FILE ".cfs_dlog" 130 #define CACHEFS_DMAP_FILE ".cfs_dmap" 131 #define CACHEFS_MNT_FILE ".cfs_mnt" 132 #define CACHEFS_UNMNT_FILE ".cfs_unmnt" 133 #define LOG_STATUS_NAME ".cfs_logging" 134 #define NOBACKUP_NAME ".nsr" 135 #define CACHEFS_PREFIX ".cfs_" 136 #define CACHEFS_PREFIX_LEN 5 137 #define ROOTLINK_NAME "root" 138 #define CFS_FRONTFILE_NAME_SIZE 18 139 #define CACHEFS_BASETYPE "cachefs" /* used in statvfs() */ 140 #define CFS_MAXFREECNODES 20 141 #define CACHEFSTAB "/etc/cachefstab" 142 #define CACHEFS_ROOTRUN "/var/run" 143 #define CACHEFS_LOCKDIR_PRE ".cachefs." /* used by mount(1M)/fsck(1M) */ 144 145 /* 146 * The options structure is passed in as part of the mount arguments. 147 * It is stored in the .options file and kept track of in the fscache 148 * structure. 149 */ 150 struct cachefsoptions { 151 uint_t opt_flags; /* mount flags */ 152 int opt_popsize; /* cache population size */ 153 int opt_fgsize; /* filegrp size, default 256 */ 154 }; 155 156 typedef struct cachefscache cachefscache_t; 157 158 /* 159 * all the stuff needed to manage a queue of requests to be processed 160 * by async threads. 161 */ 162 struct cachefs_workq { 163 struct cachefs_req *wq_head; /* head of work q */ 164 struct cachefs_req *wq_tail; /* tail of work q */ 165 int wq_length; /* # of requests on q */ 166 int wq_thread_count; /* # of threads */ 167 int wq_max_len; /* longest queue */ 168 int wq_halt_request; /* halt requested */ 169 unsigned int wq_keepone:1; /* keep one thread */ 170 unsigned int wq_logwork:1; /* write logfile */ 171 kcondvar_t wq_req_cv; /* wait on work to do */ 172 kcondvar_t wq_halt_cv; /* wait/signal halt */ 173 kmutex_t wq_queue_lock; /* protect queue */ 174 cachefscache_t *wq_cachep; /* sometimes NULL */ 175 }; 176 177 /* 178 * cfs_cid is stored on disk, so it needs to be the same 32-bit vs. 64-bit. 179 */ 180 181 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 182 #pragma pack(4) 183 #endif 184 185 /* identifies a file in the cache */ 186 struct cfs_cid { 187 ino64_t cid_fileno; /* fileno */ 188 int cid_flags; /* flags */ 189 }; 190 typedef struct cfs_cid cfs_cid_t; 191 #define CFS_CID_LOCAL 1 /* local file */ 192 193 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 194 #pragma pack() 195 #endif 196 197 /* 198 * XX64 - for now redefine all time_t fields that are used by both kernel 199 * and user space apps as a 32-bit quantity, 200 */ 201 202 #if (defined(_SYSCALL32) && defined(_LP64)) 203 204 /* 205 * The cfs_* types are used to represent on-disk data, since its size is 206 * independent of the kernel memory model (in the LP64 case) 207 */ 208 typedef time32_t cfs_time_t; 209 typedef timestruc32_t cfs_timestruc_t; 210 typedef vattr32_t cfs_vattr_t; 211 typedef fid32_t cfs_fid_t; 212 213 #define cfs_timespec timespec32 214 #define cfs_vattr vattr32 215 #define cfs_fid fid32 216 217 /* 218 * CACHEFS_DEV_COPY copies between two dev_t's. It expands or compresses 219 * them based on type changes (if needed). 220 */ 221 #define CACHEFS_DEV_TO_DEV32_COPY(in_dev, out_dev, error) \ 222 if (cmpldev((dev32_t *)&(out_dev), in_dev) == 0) \ 223 error = EOVERFLOW; 224 225 #define CACHEFS_DEV32_TO_DEV_COPY(in_dev, out_dev) \ 226 out_dev = (dev_t)expldev(in_dev); 227 228 #define TIME_OVERFLOW(tval) \ 229 ((tval) < TIME32_MIN || (tval) > TIME32_MAX) 230 231 /* Set the referred to time value. Set error if overflow */ 232 #define CACHEFS_TIME_TO_TIME32_COPY(in_tval, out_tval, error) \ 233 out_tval = (in_tval); \ 234 if (TIME_OVERFLOW(in_tval)) \ 235 error = EOVERFLOW; 236 237 #define CACHEFS_TIME32_TO_TIME_COPY(in_tval, out_tval) \ 238 out_tval = (in_tval); 239 240 /* Set the cfs_timestruc_t with values from input timestruc_t */ 241 #define CACHEFS_TS_TO_TS32_COPY(in_tsp, out_tsp, error) \ 242 (out_tsp)->tv_nsec = (in_tsp)->tv_nsec; \ 243 CACHEFS_TIME_TO_TIME32_COPY((in_tsp)->tv_sec, (out_tsp)->tv_sec, error) 244 245 #define CACHEFS_TS32_TO_TS_COPY(in_tsp, out_tsp) \ 246 (out_tsp)->tv_nsec = (in_tsp)->tv_nsec; \ 247 CACHEFS_TIME32_TO_TIME_COPY((in_tsp)->tv_sec, (out_tsp)->tv_sec) 248 249 /* CACHEFS_FID_COPY copies between two fids */ 250 #define CACHEFS_FID_COPY(in_fidp, out_fidp) \ 251 (out_fidp)->fid_len = (in_fidp)->fid_len; \ 252 bcopy((in_fidp)->fid_data, (out_fidp)->fid_data, (in_fidp)->fid_len) 253 254 #define CACHEFS_VATTR_TO_VATTR32_COPY(in_vattrp, out_vattrp, error) \ 255 (out_vattrp)->va_mask = (in_vattrp)->va_mask; \ 256 (out_vattrp)->va_type = (in_vattrp)->va_type; \ 257 (out_vattrp)->va_mode = (in_vattrp)->va_mode; \ 258 (out_vattrp)->va_uid = (in_vattrp)->va_uid; \ 259 (out_vattrp)->va_gid = (in_vattrp)->va_gid; \ 260 CACHEFS_DEV_TO_DEV32_COPY((in_vattrp)->va_fsid, \ 261 (out_vattrp)->va_fsid, error); \ 262 (out_vattrp)->va_nodeid = (in_vattrp)->va_nodeid; \ 263 (out_vattrp)->va_nlink = (in_vattrp)->va_nlink; \ 264 (out_vattrp)->va_size = (in_vattrp)->va_size; \ 265 CACHEFS_TS_TO_TS32_COPY(&(in_vattrp)->va_atime, \ 266 &(out_vattrp)->va_atime, error); \ 267 CACHEFS_TS_TO_TS32_COPY(&(in_vattrp)->va_mtime, \ 268 &(out_vattrp)->va_mtime, error); \ 269 CACHEFS_TS_TO_TS32_COPY(&(in_vattrp)->va_ctime, \ 270 &(out_vattrp)->va_ctime, error); \ 271 CACHEFS_DEV_TO_DEV32_COPY((in_vattrp)->va_rdev, \ 272 (out_vattrp)->va_rdev, error); \ 273 (out_vattrp)->va_blksize = (in_vattrp)->va_blksize; \ 274 (out_vattrp)->va_nblocks = (in_vattrp)->va_nblocks; \ 275 (out_vattrp)->va_seq = 0 276 277 #define CACHEFS_VATTR32_TO_VATTR_COPY(in_vattrp, out_vattrp) \ 278 (out_vattrp)->va_mask = (in_vattrp)->va_mask; \ 279 (out_vattrp)->va_type = (in_vattrp)->va_type; \ 280 (out_vattrp)->va_mode = (in_vattrp)->va_mode; \ 281 (out_vattrp)->va_uid = (in_vattrp)->va_uid; \ 282 (out_vattrp)->va_gid = (in_vattrp)->va_gid; \ 283 CACHEFS_DEV32_TO_DEV_COPY((in_vattrp)->va_fsid, \ 284 (out_vattrp)->va_fsid); \ 285 (out_vattrp)->va_nodeid = (in_vattrp)->va_nodeid; \ 286 (out_vattrp)->va_nlink = (in_vattrp)->va_nlink; \ 287 (out_vattrp)->va_size = (in_vattrp)->va_size; \ 288 CACHEFS_TS32_TO_TS_COPY(&(in_vattrp)->va_atime, \ 289 &(out_vattrp)->va_atime); \ 290 CACHEFS_TS32_TO_TS_COPY(&(in_vattrp)->va_mtime, \ 291 &(out_vattrp)->va_mtime); \ 292 CACHEFS_TS32_TO_TS_COPY(&(in_vattrp)->va_ctime, \ 293 &(out_vattrp)->va_ctime); \ 294 CACHEFS_DEV32_TO_DEV_COPY((in_vattrp)->va_rdev, \ 295 (out_vattrp)->va_rdev); \ 296 (out_vattrp)->va_blksize = (in_vattrp)->va_blksize; \ 297 (out_vattrp)->va_nblocks = (in_vattrp)->va_nblocks; \ 298 (out_vattrp)->va_seq = 0 299 300 #else /* not _SYSCALL32 && _LP64 */ 301 302 /* 303 * The cfs_* types are used to represent on-disk data, since its size is 304 * independent of the kernel memory model (in the LP64 case) 305 */ 306 typedef time_t cfs_time_t; 307 typedef timestruc_t cfs_timestruc_t; 308 typedef vattr_t cfs_vattr_t; 309 typedef fid_t cfs_fid_t; 310 311 #define cfs_timespec timespec 312 #define cfs_vattr vattr 313 #define cfs_fid fid 314 315 #define TIME_OVERFLOW(tval) FALSE 316 317 #define CACHEFS_DEV_TO_DEV32_COPY(in_dev, out_dev, error) \ 318 out_dev = (in_dev) 319 320 #define CACHEFS_DEV32_TO_DEV_COPY(in_dev, out_dev) \ 321 out_dev = (in_dev) 322 323 #define CACHEFS_TIME_TO_TIME32_COPY(in_tval, out_tval, error) \ 324 out_tval = (in_tval) 325 326 #define CACHEFS_TIME32_TO_TIME_COPY(in_tval, out_tval) \ 327 out_tval = (in_tval) 328 329 #define CACHEFS_TS_TO_TS32_COPY(in_tsp, out_tsp, error) \ 330 *(out_tsp) = *(in_tsp) 331 332 #define CACHEFS_TS32_TO_TS_COPY(in_tsp, out_tsp) \ 333 *(out_tsp) = *(in_tsp) 334 335 #define CACHEFS_FID_COPY(in_fidp, out_fidp) \ 336 *(out_fidp) = *(in_fidp) 337 338 #define CACHEFS_VATTR_TO_VATTR32_COPY(in_vattrp, out_vattrp, error) \ 339 *(out_vattrp) = *(in_vattrp); \ 340 (out_vattrp)->va_seq = 0 341 342 #define CACHEFS_VATTR32_TO_VATTR_COPY(in_vattrp, out_vattrp) \ 343 *(out_vattrp) = *(in_vattrp); \ 344 (out_vattrp)->va_seq = 0 345 346 #endif /* _SYSCALL32 && _LP64 */ 347 348 /* 349 * The "cfs_*" structs below refer to the on-disk structures. Presently 350 * they are 32-bit based. When they change to 64-bit, we'd have to modify the 351 * macros below accordingly. 352 */ 353 #define CACHEFS_DEV_TO_CFS_DEV_COPY(in_dev, out_dev, error) \ 354 CACHEFS_DEV_TO_DEV32_COPY(in_dev, out_dev, error) 355 356 #define CACHEFS_CFS_DEV_TO_DEV_COPY(in_dev, out_dev) \ 357 CACHEFS_DEV32_TO_DEV_COPY(in_dev, out_dev) 358 359 #define CACHEFS_TIME_TO_CFS_TIME_COPY(in_tval, out_tval, error) \ 360 CACHEFS_TIME_TO_TIME32_COPY(in_tval, out_tval, error) 361 362 #define CACHEFS_CFS_TIME_TO_TIME_COPY(in_tval, out_tval) \ 363 CACHEFS_TIME32_TO_TIME_COPY(in_tval, out_tval) 364 365 #define CACHEFS_TS_TO_CFS_TS_COPY(in_tsp, out_tsp, error) \ 366 CACHEFS_TS_TO_TS32_COPY(in_tsp, out_tsp, error) 367 368 #define CACHEFS_CFS_TS_TO_TS_COPY(in_tsp, out_tsp) \ 369 CACHEFS_TS32_TO_TS_COPY(in_tsp, out_tsp) 370 371 #define CACHEFS_VATTR_TO_CFS_VATTR_COPY(in_vattrp, out_vattrp, error) \ 372 CACHEFS_VATTR_TO_VATTR32_COPY(in_vattrp, out_vattrp, error) 373 374 #define CACHEFS_CFS_VATTR_TO_VATTR_COPY(in_vattrp, out_vattrp) \ 375 CACHEFS_VATTR32_TO_VATTR_COPY(in_vattrp, out_vattrp) 376 377 #include <sys/fs/cachefs_fscache.h> 378 #include <sys/fs/cachefs_filegrp.h> 379 380 /* 381 * One cache_label structure per cache. Contains mainly user defined or 382 * default values for cache resource management. Contents is static. 383 * The value cl_maxfiles is not used any where in cachefs code. If and when 384 * this is really used the cl_maxfiles should be declared as a 64bit value 385 * for large file support. 386 * The maxblks, blkhiwat, blklowat, blocktresh, blockmin, may need to be 387 * 64bit values when we actually start supporting file systems of size 388 * greater than 1 terabyte. 389 */ 390 struct cache_label { 391 int cl_cfsversion; /* cfs version number */ 392 int cl_maxblks; /* max blocks to be used by cache */ 393 int cl_blkhiwat; /* high water-mark for block usage */ 394 int cl_blklowat; /* low water-mark for block usage */ 395 int cl_maxinodes; /* max inodes to be used by cache */ 396 int cl_filehiwat; /* high water-mark for inode usage */ 397 int cl_filelowat; /* low water-mark for indoe usage */ 398 int cl_blocktresh; /* block max usage treshold */ 399 int cl_blockmin; /* block min usage treshold */ 400 int cl_filetresh; /* inode max usage treshold */ 401 int cl_filemin; /* inode min usage treshold */ 402 int cl_maxfiles; /* max cache file size */ 403 }; 404 405 /* 406 * One cache_usage structure per cache. Keeps track of cache usage figures. 407 * Contents gets updated frequently. 408 */ 409 struct cache_usage { 410 int cu_blksused; /* actual number of blocks used */ 411 int cu_filesused; /* actual number of files used */ 412 uint_t cu_flags; /* Cache state flags */ 413 ushort_t cu_unique; /* Fid persistent uniquifier */ 414 }; 415 416 #define CUSAGE_ACTIVE 1 /* Cache is active */ 417 #define CUSAGE_NEED_ADJUST 2 /* Adjust uniquifier before assigning new fid */ 418 419 /* 420 * RL list identifiers. 421 */ 422 enum cachefs_rl_type { 423 CACHEFS_RL_NONE = 0x101, 424 CACHEFS_RL_FREE, 425 CACHEFS_RL_GC, 426 CACHEFS_RL_ACTIVE, 427 CACHEFS_RL_ATTRFILE, 428 CACHEFS_RL_MODIFIED, 429 CACHEFS_RL_PACKED, 430 CACHEFS_RL_PACKED_PENDING, 431 CACHEFS_RL_MF 432 }; 433 #define CACHEFS_RL_START CACHEFS_RL_NONE 434 #define CACHEFS_RL_END CACHEFS_RL_MF 435 #define CACHEFS_RL_CNT (CACHEFS_RL_END - CACHEFS_RL_START + 1) 436 #define CACHEFS_RL_INDEX(X) (X - CACHEFS_RL_START) 437 438 struct cachefs_rl_listhead { 439 uint_t rli_front; /* front of list */ 440 uint_t rli_back; /* back of list */ 441 int rli_blkcnt; /* number of 8k blocks */ 442 int rli_itemcnt; /* number of items on list */ 443 }; 444 typedef struct cachefs_rl_listhead cachefs_rl_listhead_t; 445 446 /* 447 * Resource List information. One per cache. 448 */ 449 struct cachefs_rl_info { 450 uint_t rl_entries; /* number of entries allocated in rl */ 451 cfs_time_t rl_gctime; /* time of item on front of gc list */ 452 453 /* heads of the various lists */ 454 cachefs_rl_listhead_t rl_items[CACHEFS_RL_CNT]; 455 }; 456 typedef struct cachefs_rl_info cachefs_rl_info_t; 457 458 /* 459 * rl_debug and rl_entry are stored on disk, so they need to be 460 * the same 32-bit vs. 64-bit. 461 */ 462 463 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 464 #pragma pack(4) 465 #endif 466 467 #ifdef CFSRLDEBUG 468 /* 469 * RL debugging thingy 470 */ 471 472 #define CACHEFS_RLDB_STACKSIZE 16 473 #define CACHEFS_RLDB_DEF_MAXCOUNT 5 474 475 typedef struct rl_debug { 476 hrtime_t db_hrtime; 477 478 uint_t db_attrc: 1; 479 uint_t db_fsck: 1; 480 ino64_t db_fsid; 481 ino64_t db_fileno; 482 enum cachefs_rl_type db_current; 483 484 int db_stackheight; 485 pc_t db_stack[CACHEFS_RLDB_STACKSIZE]; 486 487 struct rl_debug *db_next; 488 } rl_debug_t; 489 490 extern time_t cachefs_dbvalid; 491 extern struct kmem_cache *cachefs_rl_debug_cache; 492 extern kmutex_t cachefs_rl_debug_mutex; 493 #endif /* CFSRLDEBUG */ 494 495 /* 496 * RL Entry type. 497 */ 498 499 typedef struct rl_entry { 500 uint_t rl_attrc: 1; 501 uint_t rl_fsck: 1; /* used by fsck; true => rl_current is correct */ 502 uint_t rl_local: 1; /* 1 means a local file */ 503 504 #ifdef CFSRLDEBUG 505 cfs_time_t rl_dbvalid; /* this == cachefs_dbvalid => trust rl_debug */ 506 rl_debug_t *rl_debug; 507 #endif /* CFSRLDEBUG */ 508 509 ino64_t rl_fsid; 510 ino64_t rl_fileno; 511 512 enum cachefs_rl_type rl_current; 513 uint_t rl_fwd_idx; 514 uint_t rl_bkwd_idx; 515 } rl_entry_t; 516 517 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 518 #pragma pack() 519 #endif 520 521 /* 522 * rl entries per MAXBSIZE chunk. rl_entry_t's size need not divide 523 * MAXBSIZE, as long as this constant is an integer (through integer 524 * division) (see cachefs_rl_entry_get()). 525 */ 526 527 #define CACHEFS_RLPMBS (MAXBSIZE / (uint_t)sizeof (rl_entry_t)) 528 529 /* 530 * struct cache contains cache-wide information, and provides access 531 * to lower level info. There is one cache structure per cache. 532 */ 533 struct cachefscache { 534 struct cachefscache *c_next; /* list of caches */ 535 uint_t c_flags; /* misc flags */ 536 struct cache_label c_label; /* cache resource info */ 537 struct cache_usage c_usage; /* cache usage info */ 538 struct cachefs_rl_info c_rlinfo; /* rl global pointers */ 539 struct vnode *c_resfilevp; /* resource file vp */ 540 uint_t c_rl_window; /* window mapped in */ 541 rl_entry_t *c_rl_entries; /* mapping for rl entries */ 542 struct vnode *c_dirvp; /* cache directory vp */ 543 struct vnode *c_lockvp; /* lock file vp */ 544 struct vnode *c_lostfoundvp; /* lost+found directory vp */ 545 int c_refcnt; /* active fs ref count */ 546 struct fscache *c_fslist; /* fscache list head */ 547 struct cachefs_workq c_workq; /* async work */ 548 kmutex_t c_contentslock; /* protect cache struct */ 549 kmutex_t c_fslistlock; /* protect fscache list */ 550 kmutex_t c_mflock; /* protect modified fixes */ 551 ushort_t c_unique; /* In core fid uniquifier */ 552 kcondvar_t c_cwcv; /* gc wait on work to do */ 553 kcondvar_t c_cwhaltcv; /* wait on gc thread exit */ 554 uint_t c_gc_count; /* garbage collection count */ 555 time_t c_gc_time; /* last garbage collection */ 556 time_t c_gc_before; /* atime of front before gc */ 557 time_t c_gc_after; /* atime of front after gc */ 558 uint_t c_apop_inqueue; /* # async pops queued */ 559 pid_t c_rootdaemonid; /* pid of root cachefsd */ 560 struct cachefs_log_cookie 561 *c_log; /* in-core logging stuff */ 562 struct cachefs_log_control 563 *c_log_ctl; /* on-disk logging stuff */ 564 kmutex_t c_log_mutex; /* protects c_log* */ 565 }; 566 567 extern struct kmem_cache *cachefs_cache_kmcache; 568 569 #define CACHEFS_MAX_APOP_INQUEUE 50 /* default value for below */ 570 extern uint_t cachefs_max_apop_inqueue; /* max populations pending */ 571 572 /* 573 * Various cache structure flags. 574 */ 575 #define CACHE_NOCACHE 0x1 /* all cache refs go to back fs */ 576 #define CACHE_ALLOC_PENDING 0x4 /* Allocation pending */ 577 #define CACHE_NOFILL 0x8 /* No fill mode */ 578 #define CACHE_GARBAGE_COLLECT 0x10 /* Garbage collect in progress */ 579 #define CACHE_CACHEW_THREADRUN 0x20 /* Cachep worker thread is alive */ 580 #define CACHE_CACHEW_THREADEXIT 0x40 /* cachew thread should exit */ 581 #define CACHE_DIRTY 0x80 582 #define CACHE_PACKED_PENDING 0x100 /* Packed pending work to do */ 583 #define CACHE_CHECK_RLTYPE 0x200 /* double-check with resource lists */ 584 585 /* 586 * Values for the mount options flag, opt_flags. 587 */ 588 /* 589 * Mount options 590 */ 591 #define CFS_WRITE_AROUND 0x01 /* write-around */ 592 #define CFS_NONSHARED 0x02 /* write to cache and back file */ 593 #define CFS_NOCONST_MODE 0x08 /* no-op consistency mode */ 594 #define CFS_ACCESS_BACKFS 0x10 /* pass VOP_ACCESS to backfs */ 595 #define CFS_CODCONST_MODE 0x80 /* cod consistency mode */ 596 #define CFS_DISCONNECTABLE 0x100 /* server not reponding option */ 597 #define CFS_SOFT 0x200 /* soft mounted */ 598 #define CFS_NOACL 0x400 /* ACLs are disabled in this fs */ 599 #define CFS_LLOCK 0x800 /* use local file/record locks */ 600 #define CFS_SLIDE 0x1000 /* slide backfs under cachefs */ 601 #define CFS_NOFILL 0x2000 /* start in nofill mode */ 602 #define CFS_BACKFS_NFSV4 0x4000 /* back filesystem is NFSv4 */ 603 604 #define MAXCOOKIE_SIZE 36 605 606 #define C_BACK_CHECK 0x2 607 608 /* 609 * Macro to determine if this is a snr error where we should do a 610 * state transition. 611 */ 612 613 #define CFS_TIMEOUT(FSCP, ERROR) \ 614 (ERROR && CFS_ISFS_SNR(FSCP) && \ 615 (((ERROR) == ETIMEDOUT) || ((ERROR) == EIO))) 616 617 /* 618 * Macros to assert that cachefs fscache and cnode are in 619 * sync with NFSv4. Note that NFSv4 always passes-through 620 * the vnode calls directly to the backfilesystem. For 621 * this to work: 622 * (1) cachefs is always setup for connected operation, 623 * (2) cachefs options (example disconnectable (snr), nonshared, etc) 624 * are disabled, and 625 * (3) the back filesystem vnode pointer always exists 626 * (except after a remove operation) 627 * (4) the front filesystem vnode pointer is always NULL. 628 */ 629 #ifdef DEBUG 630 #define CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp) \ 631 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { \ 632 ASSERT((fscp)->fs_info.fi_mntflags == CFS_BACKFS_NFSV4); \ 633 ASSERT((fscp)->fs_cdconnected == CFS_CD_CONNECTED); \ 634 } 635 #define CFS_BACKFS_NFSV4_ASSERT_CNODE(cp) \ 636 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { \ 637 if (MUTEX_HELD(&cp->c_statelock)) { \ 638 ASSERT((cp)->c_backvp != NULL || \ 639 ((cp)->c_flags & CN_DESTROY) != 0); \ 640 ASSERT((cp)->c_frontvp == NULL); \ 641 } else { \ 642 mutex_enter(&(cp)->c_statelock); \ 643 ASSERT((cp)->c_backvp != NULL || \ 644 ((cp)->c_flags & CN_DESTROY) != 0); \ 645 ASSERT((cp)->c_frontvp == NULL); \ 646 mutex_exit(&cp->c_statelock); \ 647 } \ 648 } 649 #else 650 #define CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp) 651 #define CFS_BACKFS_NFSV4_ASSERT_CNODE(cp) 652 #endif /* DEBUG */ 653 654 #ifdef CFSDEBUG 655 #define CFS_DPRINT_BACKFS_NFSV4(fscp, x) \ 656 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { \ 657 CFS_DEBUG(CFSDEBUG_VOPS_NFSV4) \ 658 printf x; \ 659 } 660 #else 661 #define CFS_DPRINT_BACKFS_NFSV4(fscp, x) 662 #endif /* CFSDEBUG */ 663 664 /* 665 * cachefs_allocmap and cfs_cachefs_metadata are stored on disk, 666 * so they need to be the same 32-bit vs. 64-bit. 667 */ 668 669 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 670 #pragma pack(4) 671 #endif 672 673 /* 674 * Large file support. The start offset of the cached file can be 675 * greater than 2GB and by coelescing the different chunks we may 676 * end up having a chunk of siz3 > 2GB. 677 */ 678 679 struct cachefs_allocmap { 680 u_offset_t am_start_off; /* Start offset of this chunk */ 681 u_offset_t am_size; /* size of this chunk */ 682 }; 683 684 #define C_MAX_ALLOCINFO_SLOTS 32 685 686 /* 687 * CFS fastsymlinks. For symlink of size < C_FSL_SIZE, the symlink 688 * is stored in the cnode allocmap array. 689 */ 690 #define C_FSL_SIZE (sizeof (struct cachefs_allocmap) * \ 691 C_MAX_ALLOCINFO_SLOTS) 692 693 /* 694 * Structure representing a cached object in memory. 695 */ 696 struct cachefs_metadata { 697 struct vattr md_vattr; /* attributes */ 698 o_mode_t md_aclclass; /* CLASS_OBJ perm for ACL */ 699 ushort_t md_pad1; /* compiler padding */ 700 fid_t md_cookie; /* back fid */ 701 int md_flags; /* various flags */ 702 uint_t md_rlno; /* rl entry */ 703 enum cachefs_rl_type md_rltype; /* rl type */ 704 int md_consttype; /* type of consistency */ 705 fid_t md_fid; /* fid of front file */ 706 uint_t md_frontblks; /* # blks used in frontfs */ 707 uint_t md_gen; /* fid uniquifier */ 708 struct cfs_cid md_parent; /* id of parent */ 709 timestruc_t md_timestamp; /* front file timestamp */ 710 timestruc_t md_x_time; /* see consistency routines */ 711 timestruc_t md_localmtime; /* persistent local mtime */ 712 timestruc_t md_localctime; /* persistent local ctime */ 713 uint_t md_resettimes; /* when to reset local times */ 714 ino64_t md_localfileno; /* persistent local inum */ 715 uint_t md_resetfileno; /* when to reset local fileno */ 716 uint_t md_seq; /* seq number for putpage */ 717 int md_allocents; /* nbr of entries in allocmap */ 718 struct cachefs_allocmap md_allocinfo[C_MAX_ALLOCINFO_SLOTS]; 719 }; 720 typedef struct cachefs_metadata cachefs_metadata_t; 721 722 #if (defined(_SYSCALL32) && defined(_LP64)) 723 724 /* 725 * fid_t is long aligned, so user fid could be only 4 byte aligned. 726 * Since vnode/vfs calls require fid_t (which would be 8 byte aligned in 727 * _LP64), we would have to copy the user's value (and on-disk data) in/out. 728 */ 729 /* on-disk metadata structure - fid aligned to int, time is 32-bit */ 730 731 struct cfs_cachefs_metadata { 732 struct cfs_vattr md_vattr; /* attributes */ 733 o_mode_t md_aclclass; /* CLASS_OBJ perm for ACL */ 734 cfs_fid_t md_cookie; /* back fid */ 735 int md_flags; /* various flags */ 736 uint_t md_rlno; /* rl entry */ 737 enum cachefs_rl_type md_rltype; /* rl type */ 738 int md_consttype; /* type of consistency */ 739 cfs_fid_t md_fid; /* fid of front file */ 740 uint_t md_frontblks; /* # blks used in frontfs */ 741 uint_t md_gen; /* fid uniquifier */ 742 struct cfs_cid md_parent; /* id of parent */ 743 cfs_timestruc_t md_timestamp; /* front file timestamp */ 744 cfs_timestruc_t md_x_time; /* see consistency routines */ 745 cfs_timestruc_t md_localmtime; /* persistent local mtime */ 746 cfs_timestruc_t md_localctime; /* persistent local ctime */ 747 uint_t md_resettimes; /* when to reset local times */ 748 ino64_t md_localfileno; /* persistent local inum */ 749 uint_t md_resetfileno; /* when to reset local fileno */ 750 uint_t md_seq; /* seq number for putpage */ 751 int md_allocents; /* nbr of entries in allocmap */ 752 struct cachefs_allocmap md_allocinfo[C_MAX_ALLOCINFO_SLOTS]; 753 }; 754 typedef struct cfs_cachefs_metadata cfs_cachefs_metadata_t; 755 756 #else /* not _SYSCALL32 && _LP64 */ 757 758 typedef cachefs_metadata_t cfs_cachefs_metadata_t; 759 760 #define cfs_cachefs_metadata cachefs_metadata 761 762 #endif /* _SYSCALL32 && _LP64 */ 763 764 #if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4 765 #pragma pack() 766 #endif 767 768 /* 769 * Various flags to be stored in md_flags field of the metadata. 770 */ 771 #define MD_CREATEDONE 0x1 /* create was done to backfs */ 772 #define MD_POPULATED 0x2 /* front file or dir is populated */ 773 #define MD_FILE 0x4 /* front file or dir exists */ 774 #define MD_FASTSYMLNK 0x8 /* fast symbolic link */ 775 #define MD_PACKED 0x10 /* file is packed */ 776 #define MD_INVALREADDIR 0x40 /* repopulate on readdir */ 777 #define MD_PUTPAGE 0x200 /* we have already logged a putpage */ 778 #define MD_FREE 0x400 /* not used */ 779 #define MD_PUSHDONE 0x800 /* set if file pushed to back fs */ 780 #define MD_MAPPING 0x1000 /* set if cid mapping space written */ 781 #define MD_ACL 0x2000 /* file has a cached acl */ 782 #define MD_ACLDIR 0x4000 /* front `dir' exists for holding acl */ 783 #define MD_LOCALMTIME 0x8000 /* do not overwrite md_localmtime */ 784 #define MD_LOCALCTIME 0x10000 /* do not overwrite md_localctime */ 785 #define MD_LOCALFILENO 0x20000 /* do not overwrite md_localfileno */ 786 #define MD_NEEDATTRS 0x40000 /* new attrs needed at next check */ 787 788 #define C_MAX_MOUNT_FSCDIRNAME 128 789 /* 790 * cachefs mount structure and related data 791 */ 792 struct cachefs_mountargs { 793 struct cachefsoptions cfs_options; /* consistency modes, etc. */ 794 char *cfs_fsid; /* CFS ID fpr file system */ 795 char cfs_cacheid[C_MAX_MOUNT_FSCDIRNAME]; 796 /* CFS fscdir name */ 797 char *cfs_cachedir; /* path for this cache dir */ 798 char *cfs_backfs; /* back filesystem dir */ 799 uint_t cfs_acregmin; /* same as nfs values */ 800 uint_t cfs_acregmax; 801 uint_t cfs_acdirmin; 802 uint_t cfs_acdirmax; 803 char *cfs_hostname; /* server name */ 804 char *cfs_backfsname; /* back filesystem name */ 805 }; 806 807 #ifdef _SYSCALL32 808 struct cachefs_mountargs32 { 809 struct cachefsoptions cfs_options; /* consistency modes, etc. */ 810 caddr32_t cfs_fsid; /* CFS ID fpr file system */ 811 char cfs_cacheid[C_MAX_MOUNT_FSCDIRNAME]; 812 /* CFS fscdir name */ 813 caddr32_t cfs_cachedir; /* path for this cache dir */ 814 caddr32_t cfs_backfs; /* back filesystem dir */ 815 uint32_t cfs_acregmin; /* same as nfs values */ 816 uint32_t cfs_acregmax; 817 uint32_t cfs_acdirmin; 818 uint32_t cfs_acdirmax; 819 caddr32_t cfs_hostname; /* server name */ 820 caddr32_t cfs_backfsname; /* back filesystem name */ 821 }; 822 #endif /* _SYSCALL32 */ 823 824 /* 825 * struct cachefsops - consistency modules. 826 */ 827 struct cachefsops { 828 int (*co_init_cobject)(); 829 int (*co_check_cobject)(); 830 void (*co_modify_cobject)(); 831 void (*co_invalidate_cobject)(); 832 void (*co_convert_cobject)(); 833 }; 834 835 836 837 /* 838 * The attrcache file consists of a attrcache_header structure and an 839 * array of attrcache_slot structures (one per front file). 840 */ 841 842 /* 843 * Attrcache file format 844 * 845 * Header 846 * Offset array (# of entries = file group size) 847 * alloc list (1 bit per entry, 0 = free) Note that the 848 * file will be extended as needed 849 * attrcache entries 850 * 851 */ 852 struct attrcache_header { 853 uint_t ach_count; /* number of entries */ 854 int ach_nffs; /* number of front files */ 855 int ach_nblks; /* number of allocated blocks */ 856 uint_t ach_rlno; /* rl entry for this file */ 857 enum cachefs_rl_type ach_rl_current; /* which list we're on */ 858 }; 859 860 /* 861 * We assume that the seek offset to metadata will never be > 2GB. 862 * The filegrp size is 256 and the current calculations of the sizes 863 * of the data structures show that the ach_offset value here will not 864 * be > 2GB. 865 */ 866 867 struct attrcache_index { 868 uint_t ach_written:1; /* 1 if metadata written */ 869 uint_t ach_offset:31; /* seek offset to metadata */ 870 }; 871 872 /* 873 * cnode structure, one per file. 874 */ 875 #define c_attr c_metadata.md_vattr 876 #define c_cookie c_metadata.md_cookie 877 #define c_fileno c_id.cid_fileno 878 879 /* 880 * LOCKS: c_rwlock Read / Write serialization 881 * c_statelock Protects most other fields in the cnode 882 * c_popcv Condvar used to prevent routines from nuking 883 * a cnode which is currently being populated. 884 * Threads blocked on it will be woken when the 885 * populate completes. 886 * c_iocv broadcast, but never waited on - unused? 887 * c_iomutex c_nio and c_ioflags 888 * 889 * Fields protected by other locks: 890 * 891 * c_next fg_cnodelock in the filegrp struct 892 * c_idleback fs_idlelock in fscache struct 893 * c_idlefront fs_idlelock in fscache struct 894 * 895 * Large File support: c_size goes to u_offset_t and the apopoff type 896 * goes to offset_t. 897 */ 898 struct cnode { 899 int c_flags; /* see below */ 900 struct cnode *c_next; /* next cnode in fgp list */ 901 struct cnode *c_idleback; /* idle list back ptr */ 902 struct cnode *c_idlefront; /* idle list front ptr */ 903 struct vnode *c_frontvp; /* front vnode pointer */ 904 struct vnode *c_backvp; /* back vnode pointer */ 905 struct vnode *c_acldirvp; /* dir for storing dflt ACL */ 906 u_offset_t c_size; /* client view of the size */ 907 struct filegrp *c_filegrp; /* back pointer to filegrp */ 908 struct cfs_cid c_id; /* unique file number */ 909 int c_invals; /* # of recent dir invals */ 910 int c_usage; /* Usefulness of cache */ 911 struct vnode *c_vnode; /* pointer to vnode */ 912 struct cachefs_metadata c_metadata; /* cookie, ... */ 913 int c_error; 914 kmutex_t c_statelock; /* statelock */ 915 krwlock_t c_rwlock; /* serialize write/setattr requests */ 916 kcondvar_t c_popcv; /* cnode populate cond var. */ 917 kthread_id_t c_popthrp; /* threadp performing pop */ 918 vnode_t *c_unldvp; /* dir to unlink in */ 919 char *c_unlname; /* name to unlink */ 920 cred_t *c_unlcred; /* creds for unlink */ 921 int c_nio; /* Number of io's pending */ 922 uint_t c_ioflags; 923 kcondvar_t c_iocv; /* IO cond var. */ 924 kmutex_t c_iomutex; 925 cred_t *c_cred; 926 int c_ipending; /* 1 if inactive is pending */ 927 int c_mapcnt; /* number of mapped blocks */ 928 offset_t c_apopoffset; /* offset for async pop */ 929 uint_t c_apoplen; /* length for async pop */ 930 u_offset_t c_modaddr; /* writepage offset */ 931 int c_rdcnt; /* # of read opens for backvp */ 932 int c_wrcnt; /* # of write opens for backvp */ 933 }; 934 typedef struct cnode cnode_t; 935 936 extern struct kmem_cache *cachefs_cnode_cache; 937 938 /* 939 * Directory caching parameters - First cut... 940 */ 941 #define CFS_DIRCACHE_COST 3 942 #define CFS_DIRCACHE_INVAL 3 943 #define CFS_DIRCACHE_ENABLE (CFS_DIRCACHE_INVAL * CFS_DIRCACHE_COST) 944 945 /* 946 * Conversion macros 947 */ 948 #define VTOC(VP) ((struct cnode *)((void *)((VP)->v_data))) 949 #define CTOV(CP) ((CP)->c_vnode) 950 #define VFS_TO_FSCACHE(VFSP) ((struct fscache *)((void *)((VFSP)->vfs_data))) 951 #define C_TO_FSCACHE(CP) (VFS_TO_FSCACHE(CTOV(CP)->v_vfsp)) 952 953 /* 954 * Various flags stored in the flags field of the cnode structure. 955 */ 956 #define CN_NOCACHE 0x1 /* no-cache mode */ 957 #define CN_DESTROY 0x2 /* destroy when inactive */ 958 #define CN_ROOT 0x4 /* root of the file system */ 959 #define CN_IDLE 0x8 /* file is idle */ 960 #define CN_NEEDOPEN 0x10 /* need to open backvp */ 961 #define CN_UPDATED 0x40 /* Metadata was updated - needs sync */ 962 #define CDIRTY 0x80 963 #define CN_NEED_FRONT_SYNC 0x100 /* front file needs to be sync'd */ 964 #define CN_ALLOC_PENDING 0x200 /* Need to alloc attr cache entry */ 965 #define CN_STALE 0x400 /* cnode is stale */ 966 #define CN_MODIFIED 0x800 /* Object has been written to */ 967 #define CN_POPULATION_PENDING 0x1000 /* Population data needs to be sync'd */ 968 #define CN_ASYNC_POPULATE 0x2000 /* async population pending */ 969 #define CN_ASYNC_POP_WORKING 0x4000 /* async population in progress */ 970 #define CN_PENDRM 0x8000 /* hold off unlink until reconnected */ 971 #define CN_MAPWRITE 0x100000 /* mmapped file that is being written */ 972 #define CN_CMODINPROG 0x200000 /* writepage() in progress */ 973 974 /* 975 * io flags (in c_ioflag) 976 */ 977 #define CIO_PUTPAGES 0x1 /* putpage pending: off==0, len==0 */ 978 979 #define CFS_MAX_THREADS 5 980 #define CFS_ASYNC_TIMEOUT (60 * hz) 981 982 enum cachefs_cmd { 983 CFS_INVALID, 984 CFS_CACHE_SYNC, 985 CFS_PUTPAGE, 986 CFS_IDLE, 987 CFS_POPULATE, 988 CFS_NOOP 989 }; 990 991 struct cachefs_fs_sync_req { 992 struct cachefscache *cf_cachep; 993 }; 994 995 struct cachefs_idle_req { 996 vnode_t *ci_vp; 997 }; 998 999 /* 1000 * Large File support the offset in the vnode for putpage request 1001 * can now be greater than 2GB. 1002 */ 1003 1004 struct cachefs_putpage_req { 1005 vnode_t *cp_vp; 1006 offset_t cp_off; 1007 int cp_len; 1008 int cp_flags; 1009 }; 1010 1011 /* 1012 * Large File support the offset in the vnode for populate request 1013 * can now be greater than 2GB. 1014 */ 1015 1016 struct cachefs_populate_req { 1017 vnode_t *cpop_vp; 1018 offset_t cpop_off; 1019 size_t cpop_size; 1020 }; 1021 1022 struct cachefs_req { 1023 struct cachefs_req *cfs_next; 1024 enum cachefs_cmd cfs_cmd; /* Command to execute */ 1025 cred_t *cfs_cr; 1026 union { 1027 struct cachefs_fs_sync_req cu_fs_sync; 1028 struct cachefs_idle_req cu_idle; 1029 struct cachefs_putpage_req cu_putpage; 1030 struct cachefs_populate_req cu_populate; 1031 } cfs_req_u; 1032 kmutex_t cfs_req_lock; /* Protects contents */ 1033 }; 1034 1035 extern struct kmem_cache *cachefs_req_cache; 1036 1037 /* 1038 * Large file support: We allow cachefs to understand the 64 bit inode type. 1039 */ 1040 1041 struct cachefs_fid { 1042 ushort_t cf_len; 1043 ino64_t cf_fileno; 1044 uint_t cf_gen; 1045 }; 1046 #define CFS_FID_SIZE (sizeof (struct cachefs_fid) - sizeof (ushort_t)) 1047 1048 /* 1049 * 1050 * cachefs kstat stuff. each time you mount a cachefs filesystem, it 1051 * gets a unique number. it'll get that number again if you remount 1052 * the same thing. the number is unique until reboot, but it doesn't 1053 * survive reboots. 1054 * 1055 * each cachefs kstat uses this per-filesystem identifier. to get the 1056 * valid identifiers, the `cachefs.0.key' kstat has a mapping of all 1057 * the available filesystems. its structure, cachefs_kstat_key, is 1058 * below. 1059 * 1060 */ 1061 1062 typedef struct cachefs_kstat_key { 1063 int ks_id; 1064 int ks_mounted; 1065 uint64_t ks_vfsp; 1066 uint64_t ks_mountpoint; 1067 uint64_t ks_backfs; 1068 uint64_t ks_cachedir; 1069 uint64_t ks_cacheid; 1070 } cachefs_kstat_key_t; 1071 extern cachefs_kstat_key_t *cachefs_kstat_key; 1072 extern int cachefs_kstat_key_n; 1073 1074 /* 1075 * cachefs debugging aid. cachefs_debug_info_t is a cookie that we 1076 * can keep around to see what was happening at a certain time. 1077 * 1078 * for example, if we have a deadlock on the cnode's statelock 1079 * (i.e. someone is not letting go of it), we can add a 1080 * cachefs_debug_info_t * to the cnode structure, and call 1081 * cachefs_debug_save() whenever we grab the lock. then, when we're 1082 * deadlocked, we can see what was going on when we grabbed the lock 1083 * in the first place, and (hopefully) why we didn't release it. 1084 */ 1085 1086 #define CACHEFS_DEBUG_DEPTH (16) 1087 typedef struct cachefs_debug_info { 1088 char *cdb_message; /* arbitrary message */ 1089 uint_t cdb_flags; /* arbitrary flags */ 1090 int cdb_int; /* arbitrary int */ 1091 void *cdb_pointer; /* arbitrary pointer */ 1092 uint_t cdb_count; /* how many times called */ 1093 1094 cachefscache_t *cdb_cachep; /* relevant cachep (maybe undefined) */ 1095 struct fscache *cdb_fscp; /* relevant fscache */ 1096 struct cnode *cdb_cnode; /* relevant cnode */ 1097 vnode_t *cdb_frontvp; /* relevant front vnode */ 1098 vnode_t *cdb_backvp; /* relevant back vnode */ 1099 1100 kthread_id_t cdb_thread; /* thread who called */ 1101 hrtime_t cdb_timestamp; /* when */ 1102 int cdb_depth; /* depth of saved stack */ 1103 pc_t cdb_stack[CACHEFS_DEBUG_DEPTH]; /* stack trace */ 1104 struct cachefs_debug_info *cdb_next; /* pointer to next */ 1105 } cachefs_debug_info_t; 1106 1107 /* 1108 * cachefs function prototypes 1109 */ 1110 #if defined(_KERNEL) && defined(__STDC__) 1111 extern int cachefs_getcookie(vnode_t *, struct fid *, struct vattr *, 1112 cred_t *, uint32_t); 1113 cachefscache_t *cachefs_cache_create(void); 1114 void cachefs_cache_destroy(cachefscache_t *cachep); 1115 int cachefs_cache_activate_ro(cachefscache_t *cachep, vnode_t *cdvp); 1116 void cachefs_cache_activate_rw(cachefscache_t *cachep); 1117 void cachefs_cache_dirty(struct cachefscache *cachep, int lockit); 1118 int cachefs_cache_rssync(struct cachefscache *cachep); 1119 void cachefs_cache_sync(struct cachefscache *cachep); 1120 uint_t cachefs_cache_unique(cachefscache_t *cachep); 1121 void cachefs_do_req(struct cachefs_req *); 1122 1123 /* cachefs_cnode.c */ 1124 void cachefs_cnode_idle(struct vnode *vp, cred_t *cr); 1125 void cachefs_cnode_idleclean(fscache_t *fscp, int unmount); 1126 int cachefs_cnode_inactive(register struct vnode *vp, cred_t *cr); 1127 void cachefs_cnode_listadd(struct cnode *cp); 1128 void cachefs_cnode_listrem(struct cnode *cp); 1129 void cachefs_cnode_free(struct cnode *cp); 1130 void cachefs_cnode_cleanfreelist(); 1131 void cachefs_cnode_idleadd(struct cnode *cp); 1132 void cachefs_cnode_idlerem(struct cnode *cp); 1133 int cachefs_cnode_find(filegrp_t *fgp, cfs_cid_t *cidp, fid_t *cookiep, 1134 struct cnode **cpp, struct vnode *vp, vattr_t *vap); 1135 int cachefs_cnode_make(cfs_cid_t *cidp, fscache_t *fscp, fid_t *cookiep, 1136 vattr_t *vap, vnode_t *backvp, cred_t *cr, int flag, cnode_t **cpp); 1137 int cachefs_cid_inuse(filegrp_t *fgp, cfs_cid_t *cidp); 1138 int cachefs_fileno_inuse(fscache_t *fscp, ino64_t fileno); 1139 int cachefs_cnode_create(fscache_t *fscp, vattr_t *vap, int flag, 1140 cnode_t **cpp); 1141 void cachefs_cnode_move(cnode_t *cp); 1142 int cachefs_cnode_lostfound(cnode_t *cp, char *rname); 1143 void cachefs_cnode_sync(cnode_t *cp); 1144 void cachefs_cnode_traverse(fscache_t *fscp, void (*routinep)(cnode_t *)); 1145 void cachefs_cnode_stale(cnode_t *cp); 1146 void cachefs_cnode_setlocalstats(cnode_t *cp); 1147 void cachefs_cnode_disable_caching(cnode_t *cp); 1148 1149 void cachefs_enable_caching(struct fscache *); 1150 1151 /* cachefs_fscache.c */ 1152 void fscache_destroy(fscache_t *); 1153 1154 /* cachefs_ioctl.h */ 1155 int cachefs_pack_common(vnode_t *vp, cred_t *cr); 1156 void cachefs_inum_register(fscache_t *fscp, ino64_t real, ino64_t fake); 1157 ino64_t cachefs_inum_real2fake(fscache_t *fscp, ino64_t real); 1158 1159 1160 /* cachefs_subr.c */ 1161 int cachefs_sync_metadata(cnode_t *); 1162 int cachefs_cnode_cnt(int); 1163 int cachefs_getbackvp(struct fscache *, struct cnode *); 1164 int cachefs_getfrontfile(cnode_t *); 1165 void cachefs_removefrontfile(cachefs_metadata_t *mdp, cfs_cid_t *cidp, 1166 filegrp_t *fgp); 1167 void cachefs_nocache(cnode_t *); 1168 void cachefs_inval_object(cnode_t *); 1169 void make_ascii_name(cfs_cid_t *cidp, char *strp); 1170 int cachefs_async_halt(struct cachefs_workq *, int); 1171 int cachefs_async_okay(void); 1172 int cachefs_check_allocmap(cnode_t *cp, u_offset_t off); 1173 void cachefs_update_allocmap(cnode_t *, u_offset_t, size_t); 1174 int cachefs_cachesymlink(struct cnode *cp, cred_t *cr); 1175 int cachefs_stuffsymlink(cnode_t *cp, caddr_t buf, int buflen); 1176 int cachefs_readlink_back(cnode_t *cp, cred_t *cr, caddr_t *bufp, int *buflenp); 1177 /* 1178 * void cachefs_cluster_allocmap(struct cnode *, u_offset_t, u_offset_t *, 1179 * size_t *, size_t); 1180 */ 1181 void cachefs_cluster_allocmap(u_offset_t, u_offset_t *, size_t *, size_t, 1182 struct cnode *); 1183 int cachefs_populate(cnode_t *, u_offset_t, size_t, vnode_t *, vnode_t *, 1184 u_offset_t, cred_t *); 1185 int cachefs_stats_kstat_snapshot(kstat_t *, void *, int); 1186 cachefs_debug_info_t *cachefs_debug_save(cachefs_debug_info_t *, int, 1187 char *, uint_t, int, void *, cachefscache_t *, struct fscache *, 1188 struct cnode *); 1189 void cachefs_debug_show(cachefs_debug_info_t *); 1190 uint32_t cachefs_cred_checksum(cred_t *cr); 1191 int cachefs_frontfile_size(cnode_t *cp, u_offset_t length); 1192 int cachefs_req_create(void *, void *, int); 1193 void cachefs_req_destroy(void *, void *); 1194 int cachefs_stop_cache(cnode_t *); 1195 1196 1197 /* cachefs_resource.c */ 1198 void cachefs_rlent_moveto_nolock(cachefscache_t *cachep, 1199 enum cachefs_rl_type type, uint_t entno, size_t); 1200 void cachefs_rlent_moveto(cachefscache_t *, enum cachefs_rl_type, uint_t, 1201 size_t); 1202 void cachefs_rlent_verify(cachefscache_t *, enum cachefs_rl_type, uint_t); 1203 void cachefs_rl_changefileno(cachefscache_t *cachep, uint_t entno, 1204 ino64_t fileno); 1205 int cachefs_rlent_data(cachefscache_t *cachep, rl_entry_t *valp, 1206 uint_t *entnop); 1207 void cachefs_move_modified_to_mf(cachefscache_t *cachep, fscache_t *fscp); 1208 int cachefs_allocblocks(cachefscache_t *, size_t, enum cachefs_rl_type); 1209 void cachefs_freeblocks(cachefscache_t *, size_t, enum cachefs_rl_type); 1210 void cachefs_freefile(cachefscache_t *); 1211 int cachefs_allocfile(cachefscache_t *); 1212 int cachefs_rl_alloc(struct cachefscache *cachep, rl_entry_t *valp, 1213 uint_t *entnop); 1214 int cachefs_rl_attrc(struct cachefscache *, int, int); 1215 void cachefs_cachep_worker_thread(cachefscache_t *); 1216 void cachefs_rl_cleanup(cachefscache_t *); 1217 int cachefs_rl_entry_get(cachefscache_t *, uint_t, rl_entry_t **); 1218 #ifdef CFSRLDEBUG 1219 void cachefs_rl_debug_save(rl_entry_t *); 1220 void cachefs_rl_debug_show(rl_entry_t *); 1221 void cachefs_rl_debug_destroy(rl_entry_t *); 1222 #endif /* CFSRLDEBUG */ 1223 1224 /* cachefs_log.c */ 1225 int cachefs_log_kstat_snapshot(kstat_t *, void *, int); 1226 void cachefs_log_process_queue(cachefscache_t *, int); 1227 int cachefs_log_logfile_open(cachefscache_t *, char *); 1228 struct cachefs_log_cookie 1229 *cachefs_log_create_cookie(struct cachefs_log_control *); 1230 void cachefs_log_error(cachefscache_t *, int, int); 1231 void cachefs_log_destroy_cookie(struct cachefs_log_cookie *); 1232 1233 void cachefs_log_mount(cachefscache_t *, int, struct vfs *, 1234 fscache_t *, char *, enum uio_seg, char *); 1235 void cachefs_log_umount(cachefscache_t *, int, struct vfs *); 1236 void cachefs_log_getpage(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1237 uid_t, u_offset_t, size_t); 1238 void cachefs_log_readdir(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1239 uid_t, u_offset_t, int); 1240 void cachefs_log_readlink(cachefscache_t *, int, struct vfs *, 1241 fid_t *, ino64_t, uid_t, size_t); 1242 void cachefs_log_remove(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1243 uid_t); 1244 void cachefs_log_rmdir(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1245 uid_t); 1246 void cachefs_log_truncate(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1247 uid_t, u_offset_t); 1248 void cachefs_log_putpage(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1249 uid_t, u_offset_t, size_t); 1250 void cachefs_log_create(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1251 uid_t); 1252 void cachefs_log_mkdir(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1253 uid_t); 1254 void cachefs_log_rename(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1255 int, uid_t); 1256 void cachefs_log_symlink(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1257 uid_t, int); 1258 void cachefs_log_populate(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1259 u_offset_t, size_t); 1260 void cachefs_log_csymlink(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1261 int); 1262 void cachefs_log_filldir(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1263 u_offset_t); 1264 void cachefs_log_mdcreate(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1265 uint_t); 1266 void cachefs_log_gpfront(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1267 uid_t, u_offset_t, uint_t); 1268 void cachefs_log_rfdir(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1269 uid_t); 1270 void cachefs_log_ualloc(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1271 u_offset_t, size_t); 1272 void cachefs_log_calloc(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t, 1273 u_offset_t, size_t); 1274 void cachefs_log_nocache(cachefscache_t *, int, struct vfs *, fid_t *, ino64_t); 1275 1276 /* cachefs_vnops.c */ 1277 struct vnodeops *cachefs_getvnodeops(void); 1278 int cachefs_lookup_common(vnode_t *dvp, char *nm, vnode_t **vpp, 1279 struct pathname *pnp, int flags, vnode_t *rdir, cred_t *cr); 1280 int cachefs_putpage_common(struct vnode *vp, offset_t off, 1281 size_t len, int flags, cred_t *cr); 1282 ino64_t cachefs_fileno_conflict(fscache_t *fscp, ino64_t old); 1283 int cachefs_remove_connected(vnode_t *dvp, char *nm, cred_t *cr, 1284 vnode_t *vp); 1285 int cachefs_remove_disconnected(vnode_t *dvp, char *nm, cred_t *cr, 1286 vnode_t *vp); 1287 int cachefs_cacheacl(cnode_t *, vsecattr_t *); 1288 void cachefs_purgeacl(cnode_t *); 1289 int cachefs_vtype_aclok(vnode_t *); 1290 1291 /* cachefs_vfsops.c */ 1292 int cachefs_init_vfsops(int); 1293 int cachefs_init_vnops(char *); 1294 void cachefs_kstat_mount(struct fscache *, char *, char *, char *, char *); 1295 void cachefs_kstat_umount(int); 1296 int cachefs_kstat_key_update(kstat_t *, int); 1297 int cachefs_kstat_key_snapshot(kstat_t *, void *, int); 1298 1299 extern void cachefs_workq_init(struct cachefs_workq *); 1300 extern void cachefs_addqueue(struct cachefs_req *, struct cachefs_workq *); 1301 1302 1303 extern void *cachefs_kmem_alloc(size_t, int); 1304 extern void *cachefs_kmem_zalloc(size_t, int); 1305 extern void cachefs_kmem_free(void *, size_t); 1306 extern char *cachefs_strdup(char *); 1307 1308 #endif /* defined (_KERNEL) && defined (__STDC__) */ 1309 1310 1311 1312 #define C_RL_MAXENTS 0x4000 /* Whatever */ 1313 1314 /* 1315 * ioctls. 1316 */ 1317 #include <sys/ioccom.h> 1318 #define _FIOCOD _IO('f', 78) /* consistency on demand */ 1319 #define _FIOSTOPCACHE _IO('f', 86) /* stop using cache */ 1320 1321 #define CACHEFSIO_PACK _IO('f', 81) 1322 #define CACHEFSIO_UNPACK _IO('f', 82) 1323 #define CACHEFSIO_UNPACKALL _IO('f', 83) 1324 #define CACHEFSIO_PACKINFO _IO('f', 84) 1325 #define CACHEFSIO_DCMD _IO('f', 85) 1326 1327 #ifdef __cplusplus 1328 } 1329 #endif 1330 1331 #endif /* _SYS_FS_CACHEFS_FS_H */ 1332