xref: /titanic_44/usr/src/uts/common/fs/cachefs/cachefs_subr.c (revision 3c112a2b34403220c06c3e2fcac403358cfba168)
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 #include <sys/param.h>
27 #include <sys/types.h>
28 #include <sys/systm.h>
29 #include <sys/cred.h>
30 #include <sys/proc.h>
31 #include <sys/user.h>
32 #include <sys/vfs.h>
33 #include <sys/vnode.h>
34 #include <sys/pathname.h>
35 #include <sys/uio.h>
36 #include <sys/tiuser.h>
37 #include <sys/sysmacros.h>
38 #include <sys/kmem.h>
39 #include <sys/mount.h>
40 #include <sys/ioctl.h>
41 #include <sys/statvfs.h>
42 #include <sys/errno.h>
43 #include <sys/debug.h>
44 #include <sys/cmn_err.h>
45 #include <sys/utsname.h>
46 #include <sys/modctl.h>
47 #include <sys/file.h>
48 #include <sys/stat.h>
49 #include <sys/fcntl.h>
50 #include <sys/fbuf.h>
51 #include <sys/dnlc.h>
52 #include <sys/callb.h>
53 #include <sys/kobj.h>
54 #include <sys/rwlock.h>
55 
56 #include <sys/vmsystm.h>
57 #include <vm/hat.h>
58 #include <vm/as.h>
59 #include <vm/page.h>
60 #include <vm/pvn.h>
61 #include <vm/seg.h>
62 #include <vm/seg_map.h>
63 #include <vm/seg_vn.h>
64 #include <vm/rm.h>
65 #include <sys/fs/cachefs_fs.h>
66 #include <sys/fs/cachefs_log.h>
67 #include <sys/fs/cachefs_dir.h>
68 
69 extern struct seg *segkmap;
70 caddr_t segmap_getmap();
71 int segmap_release();
72 
73 extern struct cnode *cachefs_freeback;
74 extern struct cnode *cachefs_freefront;
75 extern cachefscache_t *cachefs_cachelist;
76 
77 #ifdef CFSDEBUG
78 int cachefsdebug = 0;
79 #endif
80 
81 int cachefs_max_threads = CFS_MAX_THREADS;
82 ino64_t cachefs_check_fileno = 0;
83 struct kmem_cache *cachefs_cache_kmcache = NULL;
84 struct kmem_cache *cachefs_req_cache = NULL;
85 
86 static int
87 cachefs_async_populate_reg(struct cachefs_populate_req *, cred_t *,
88     vnode_t *, vnode_t *);
89 
90 /*
91  * Cache routines
92  */
93 
94 /*
95  * ------------------------------------------------------------------
96  *
97  *		cachefs_cache_create
98  *
99  * Description:
100  *	Creates a cachefscache_t object and initializes it to
101  *	be NOCACHE and NOFILL mode.
102  * Arguments:
103  * Returns:
104  *	Returns a pointer to the created object or NULL if
105  *	threads could not be created.
106  * Preconditions:
107  */
108 
109 cachefscache_t *
110 cachefs_cache_create(void)
111 {
112 	cachefscache_t *cachep;
113 	struct cachefs_req *rp;
114 
115 	/* allocate zeroed memory for the object */
116 	cachep = kmem_cache_alloc(cachefs_cache_kmcache, KM_SLEEP);
117 
118 	bzero(cachep, sizeof (*cachep));
119 
120 	cv_init(&cachep->c_cwcv, NULL, CV_DEFAULT, NULL);
121 	cv_init(&cachep->c_cwhaltcv, NULL, CV_DEFAULT, NULL);
122 	mutex_init(&cachep->c_contentslock, NULL, MUTEX_DEFAULT, NULL);
123 	mutex_init(&cachep->c_fslistlock, NULL, MUTEX_DEFAULT, NULL);
124 	mutex_init(&cachep->c_log_mutex, NULL, MUTEX_DEFAULT, NULL);
125 
126 	/* set up the work queue and get the sync thread created */
127 	cachefs_workq_init(&cachep->c_workq);
128 	cachep->c_workq.wq_keepone = 1;
129 	cachep->c_workq.wq_cachep = cachep;
130 	rp = kmem_cache_alloc(cachefs_req_cache, KM_SLEEP);
131 	rp->cfs_cmd = CFS_NOOP;
132 	rp->cfs_cr = kcred;
133 	rp->cfs_req_u.cu_fs_sync.cf_cachep = cachep;
134 	crhold(rp->cfs_cr);
135 	cachefs_addqueue(rp, &cachep->c_workq);
136 	cachep->c_flags |= CACHE_NOCACHE | CACHE_NOFILL | CACHE_ALLOC_PENDING;
137 
138 	return (cachep);
139 }
140 
141 /*
142  * ------------------------------------------------------------------
143  *
144  *		cachefs_cache_destroy
145  *
146  * Description:
147  *	Destroys the cachefscache_t object.
148  * Arguments:
149  *	cachep	the cachefscache_t object to destroy
150  * Returns:
151  * Preconditions:
152  *	precond(cachep)
153  */
154 
155 void
156 cachefs_cache_destroy(cachefscache_t *cachep)
157 {
158 	int error = 0;
159 #ifdef CFSRLDEBUG
160 	uint_t index;
161 #endif /* CFSRLDEBUG */
162 	clock_t wakeup = (60 * hz);
163 
164 	/* stop async threads */
165 	while (cachep->c_workq.wq_thread_count > 0)
166 		(void) cachefs_async_halt(&cachep->c_workq, 1);
167 
168 	/* kill off the cachep worker thread */
169 	mutex_enter(&cachep->c_contentslock);
170 	while (cachep->c_flags & CACHE_CACHEW_THREADRUN) {
171 		cachep->c_flags |= CACHE_CACHEW_THREADEXIT;
172 		cv_signal(&cachep->c_cwcv);
173 		(void) cv_reltimedwait(&cachep->c_cwhaltcv,
174 		    &cachep->c_contentslock, wakeup, TR_CLOCK_TICK);
175 	}
176 
177 	if ((cachep->c_flags & CACHE_ALLOC_PENDING) == 0) {
178 		cachep->c_usage.cu_flags &= ~CUSAGE_ACTIVE;
179 		(void) cachefs_cache_rssync(cachep);
180 	}
181 	mutex_exit(&cachep->c_contentslock);
182 
183 	/* if there is a cache */
184 	if ((cachep->c_flags & CACHE_NOCACHE) == 0) {
185 		if ((cachep->c_flags & CACHE_NOFILL) == 0) {
186 #ifdef CFSRLDEBUG
187 			/* blow away dangling rl debugging info */
188 			mutex_enter(&cachep->c_contentslock);
189 			for (index = 0;
190 			    index <= cachep->c_rlinfo.rl_entries;
191 			    index++) {
192 				rl_entry_t *rlent;
193 
194 				error = cachefs_rl_entry_get(cachep, index,
195 				    rlent);
196 				/*
197 				 * Since we are destroying the cache,
198 				 * better to ignore and proceed
199 				 */
200 				if (error)
201 					break;
202 				cachefs_rl_debug_destroy(rlent);
203 			}
204 			mutex_exit(&cachep->c_contentslock);
205 #endif /* CFSRLDEBUG */
206 
207 			/* sync the cache */
208 			if (!error)
209 				cachefs_cache_sync(cachep);
210 		} else {
211 			/* get rid of any unused fscache objects */
212 			mutex_enter(&cachep->c_fslistlock);
213 			fscache_list_gc(cachep);
214 			mutex_exit(&cachep->c_fslistlock);
215 		}
216 		ASSERT(cachep->c_fslist == NULL);
217 
218 		VN_RELE(cachep->c_resfilevp);
219 		VN_RELE(cachep->c_dirvp);
220 		VN_RELE(cachep->c_lockvp);
221 		VN_RELE(cachep->c_lostfoundvp);
222 	}
223 
224 	if (cachep->c_log_ctl != NULL)
225 		cachefs_kmem_free(cachep->c_log_ctl,
226 		    sizeof (cachefs_log_control_t));
227 	if (cachep->c_log != NULL)
228 		cachefs_log_destroy_cookie(cachep->c_log);
229 
230 	cv_destroy(&cachep->c_cwcv);
231 	cv_destroy(&cachep->c_cwhaltcv);
232 	mutex_destroy(&cachep->c_contentslock);
233 	mutex_destroy(&cachep->c_fslistlock);
234 	mutex_destroy(&cachep->c_log_mutex);
235 
236 	kmem_cache_free(cachefs_cache_kmcache, cachep);
237 }
238 
239 /*
240  * ------------------------------------------------------------------
241  *
242  *		cachefs_cache_active_ro
243  *
244  * Description:
245  *	Activates the cachefscache_t object for a read-only file system.
246  * Arguments:
247  *	cachep	the cachefscache_t object to activate
248  *	cdvp	the vnode of the cache directory
249  * Returns:
250  *	Returns 0 for success, !0 if there is a problem with the cache.
251  * Preconditions:
252  *	precond(cachep)
253  *	precond(cdvp)
254  *	precond(cachep->c_flags & CACHE_NOCACHE)
255  */
256 
257 int
258 cachefs_cache_activate_ro(cachefscache_t *cachep, vnode_t *cdvp)
259 {
260 	cachefs_log_control_t *lc;
261 	vnode_t *labelvp = NULL;
262 	vnode_t *rifvp = NULL;
263 	vnode_t *lockvp = NULL;
264 	vnode_t *statevp = NULL;
265 	vnode_t *lostfoundvp = NULL;
266 	struct vattr *attrp = NULL;
267 	int error;
268 
269 	ASSERT(cachep->c_flags & CACHE_NOCACHE);
270 	mutex_enter(&cachep->c_contentslock);
271 
272 	attrp = cachefs_kmem_alloc(sizeof (struct vattr), KM_SLEEP);
273 
274 	/* get the mode bits of the cache directory */
275 	attrp->va_mask = AT_ALL;
276 	error = VOP_GETATTR(cdvp, attrp, 0, kcred, NULL);
277 	if (error)
278 		goto out;
279 
280 	/* ensure the mode bits are 000 to keep out casual users */
281 	if (attrp->va_mode & S_IAMB) {
282 		cmn_err(CE_WARN, "cachefs: Cache Directory Mode must be 000\n");
283 		error = EPERM;
284 		goto out;
285 	}
286 
287 	/* Get the lock file */
288 	error = VOP_LOOKUP(cdvp, CACHEFS_LOCK_FILE, &lockvp, NULL, 0, NULL,
289 	    kcred, NULL, NULL, NULL);
290 	if (error) {
291 		cmn_err(CE_WARN, "cachefs: activate_a: cache corruption"
292 		    " run fsck.\n");
293 		goto out;
294 	}
295 
296 	/* Get the label file */
297 	error = VOP_LOOKUP(cdvp, CACHELABEL_NAME, &labelvp, NULL, 0, NULL,
298 	    kcred, NULL, NULL, NULL);
299 	if (error) {
300 		cmn_err(CE_WARN, "cachefs: activate_b: cache corruption"
301 		    " run fsck.\n");
302 		goto out;
303 	}
304 
305 	/* read in the label */
306 	error = vn_rdwr(UIO_READ, labelvp, (caddr_t)&cachep->c_label,
307 	    sizeof (struct cache_label), 0LL, UIO_SYSSPACE,
308 	    0, (rlim64_t)0, kcred, NULL);
309 	if (error) {
310 		cmn_err(CE_WARN, "cachefs: activate_c: cache corruption"
311 		    " run fsck.\n");
312 		goto out;
313 	}
314 
315 	/* Verify that we can handle the version this cache was created under */
316 	if (cachep->c_label.cl_cfsversion != CFSVERSION) {
317 		cmn_err(CE_WARN, "cachefs: Invalid Cache Version, run fsck\n");
318 		error = EINVAL;
319 		goto out;
320 	}
321 
322 	/* Open the resource file */
323 	error = VOP_LOOKUP(cdvp, RESOURCE_NAME, &rifvp, NULL, 0, NULL, kcred,
324 	    NULL, NULL, NULL);
325 	if (error) {
326 		cmn_err(CE_WARN, "cachefs: activate_d: cache corruption"
327 		    " run fsck.\n");
328 		goto out;
329 	}
330 
331 	/*  Read the usage struct for this cache */
332 	error = vn_rdwr(UIO_READ, rifvp, (caddr_t)&cachep->c_usage,
333 	    sizeof (struct cache_usage), 0LL, UIO_SYSSPACE, 0,
334 	    (rlim64_t)0, kcred, NULL);
335 	if (error) {
336 		cmn_err(CE_WARN, "cachefs: activate_e: cache corruption"
337 		    " run fsck.\n");
338 		goto out;
339 	}
340 
341 	if (cachep->c_usage.cu_flags & CUSAGE_ACTIVE) {
342 		cmn_err(CE_WARN, "cachefs: cache not clean.  Run fsck\n");
343 		/* ENOSPC is what UFS uses for clean flag check */
344 		error = ENOSPC;
345 		goto out;
346 	}
347 
348 	/*  Read the rlinfo for this cache */
349 	error = vn_rdwr(UIO_READ, rifvp, (caddr_t)&cachep->c_rlinfo,
350 	    sizeof (cachefs_rl_info_t), (offset_t)sizeof (struct cache_usage),
351 	    UIO_SYSSPACE, 0, 0, kcred, NULL);
352 	if (error) {
353 		cmn_err(CE_WARN, "cachefs: activate_f: cache corruption"
354 		    " run fsck.\n");
355 		goto out;
356 	}
357 
358 	/* Open the lost+found directory */
359 	error = VOP_LOOKUP(cdvp, CACHEFS_LOSTFOUND_NAME, &lostfoundvp,
360 	    NULL, 0, NULL, kcred, NULL, NULL, NULL);
361 	if (error) {
362 		cmn_err(CE_WARN, "cachefs: activate_g: cache corruption"
363 		    " run fsck.\n");
364 		goto out;
365 	}
366 
367 	VN_HOLD(rifvp);
368 	VN_HOLD(cdvp);
369 	VN_HOLD(lockvp);
370 	VN_HOLD(lostfoundvp);
371 	cachep->c_resfilevp = rifvp;
372 	cachep->c_dirvp = cdvp;
373 	cachep->c_lockvp = lockvp;
374 	cachep->c_lostfoundvp = lostfoundvp;
375 
376 	/* get the cachep worker thread created */
377 	cachep->c_flags |= CACHE_CACHEW_THREADRUN;
378 	(void) thread_create(NULL, 0, cachefs_cachep_worker_thread,
379 	    cachep, 0, &p0, TS_RUN, minclsyspri);
380 
381 	/* allocate the `logging control' field */
382 	mutex_enter(&cachep->c_log_mutex);
383 	cachep->c_log_ctl =
384 	    cachefs_kmem_zalloc(sizeof (cachefs_log_control_t), KM_SLEEP);
385 	lc = (cachefs_log_control_t *)cachep->c_log_ctl;
386 
387 	/* if the LOG_STATUS_NAME file exists, read it in and set up logging */
388 	error = VOP_LOOKUP(cachep->c_dirvp, LOG_STATUS_NAME, &statevp,
389 	    NULL, 0, NULL, kcred, NULL, NULL, NULL);
390 	if (error == 0) {
391 		int vnrw_error;
392 
393 		vnrw_error = vn_rdwr(UIO_READ, statevp, (caddr_t)lc,
394 		    sizeof (*lc), 0LL, UIO_SYSSPACE, 0, (rlim64_t)RLIM_INFINITY,
395 		    kcred, NULL);
396 		VN_RELE(statevp);
397 
398 		if (vnrw_error == 0) {
399 			if ((cachep->c_log = cachefs_log_create_cookie(lc))
400 			    == NULL)
401 				cachefs_log_error(cachep, ENOMEM, 0);
402 			else if ((lc->lc_magic != CACHEFS_LOG_MAGIC) ||
403 			    (lc->lc_path[0] != '/') ||
404 			    (cachefs_log_logfile_open(cachep,
405 			    lc->lc_path) != 0))
406 				cachefs_log_error(cachep, EINVAL, 0);
407 		}
408 	} else {
409 		error = 0;
410 	}
411 	lc->lc_magic = CACHEFS_LOG_MAGIC;
412 	lc->lc_cachep = (uint64_t)(uintptr_t)cachep;
413 	mutex_exit(&cachep->c_log_mutex);
414 
415 out:
416 	if (error == 0) {
417 		cachep->c_flags &= ~(CACHE_NOCACHE | CACHE_ALLOC_PENDING);
418 	}
419 	if (attrp)
420 		cachefs_kmem_free(attrp, sizeof (struct vattr));
421 	if (labelvp != NULL)
422 		VN_RELE(labelvp);
423 	if (rifvp != NULL)
424 		VN_RELE(rifvp);
425 	if (lockvp)
426 		VN_RELE(lockvp);
427 	if (lostfoundvp)
428 		VN_RELE(lostfoundvp);
429 
430 	mutex_exit(&cachep->c_contentslock);
431 	return (error);
432 }
433 
434 int
435 cachefs_stop_cache(cnode_t *cp)
436 {
437 	fscache_t *fscp = C_TO_FSCACHE(cp);
438 	cachefscache_t *cachep = fscp->fs_cache;
439 	filegrp_t *fgp;
440 	int i;
441 	int error = 0;
442 	clock_t wakeup = (60 * hz);
443 
444 	/* XXX verify lock-ordering for this function */
445 
446 	mutex_enter(&cachep->c_contentslock);
447 
448 	/*
449 	 * no work if we're already in nocache mode.  hopefully this
450 	 * will be the usual case.
451 	 */
452 
453 	if (cachep->c_flags & CACHE_NOCACHE) {
454 		mutex_exit(&cachep->c_contentslock);
455 		return (0);
456 	}
457 
458 	if ((cachep->c_flags & CACHE_NOFILL) == 0) {
459 		mutex_exit(&cachep->c_contentslock);
460 		return (EINVAL);
461 	}
462 
463 	mutex_exit(&cachep->c_contentslock);
464 
465 	/* We are already not caching if nfsv4 */
466 	if (CFS_ISFS_BACKFS_NFSV4(fscp)) {
467 		return (0);
468 	}
469 
470 #ifdef CFSDEBUG
471 	mutex_enter(&cachep->c_fslistlock);
472 	ASSERT(fscp == cachep->c_fslist);
473 	ASSERT(fscp->fs_next == NULL);
474 	mutex_exit(&cachep->c_fslistlock);
475 
476 	printf("cachefs_stop_cache: resetting CACHE_NOCACHE\n");
477 #endif
478 
479 	/* XXX should i worry about disconnected during boot? */
480 	error = cachefs_cd_access(fscp, 1, 1);
481 	if (error)
482 		goto out;
483 
484 	error = cachefs_async_halt(&fscp->fs_workq, 1);
485 	ASSERT(error == 0);
486 	error = cachefs_async_halt(&cachep->c_workq, 1);
487 	ASSERT(error == 0);
488 	/* sigh -- best to keep going if async_halt failed. */
489 	error = 0;
490 
491 	/* XXX current order: cnode, fgp, fscp, cache. okay? */
492 
493 	cachefs_cnode_traverse(fscp, cachefs_cnode_disable_caching);
494 
495 	for (i = 0; i < CFS_FS_FGP_BUCKET_SIZE; i++) {
496 		for (fgp = fscp->fs_filegrp[i]; fgp != NULL;
497 		    fgp = fgp->fg_next) {
498 			mutex_enter(&fgp->fg_mutex);
499 
500 			ASSERT((fgp->fg_flags &
501 			    (CFS_FG_WRITE | CFS_FG_UPDATED)) == 0);
502 			fgp->fg_flags |=
503 			    CFS_FG_ALLOC_FILE |
504 			    CFS_FG_ALLOC_ATTR;
505 			fgp->fg_flags &= ~CFS_FG_READ;
506 
507 			if (fgp->fg_dirvp) {
508 				fgp->fg_flags |= CFS_FG_ALLOC_FILE;
509 				VN_RELE(fgp->fg_dirvp);
510 				fgp->fg_dirvp = NULL;
511 			}
512 			if (fgp->fg_attrvp) {
513 				fgp->fg_flags |= CFS_FG_ALLOC_ATTR;
514 				VN_RELE(fgp->fg_attrvp);
515 				fgp->fg_attrvp = NULL;
516 			}
517 
518 			mutex_exit(&fgp->fg_mutex);
519 		}
520 	}
521 
522 	mutex_enter(&fscp->fs_fslock);
523 	ASSERT((fscp->fs_flags & (CFS_FS_WRITE)) == 0);
524 	fscp->fs_flags &= ~(CFS_FS_READ | CFS_FS_DIRTYINFO);
525 
526 	if (fscp->fs_fscdirvp) {
527 		VN_RELE(fscp->fs_fscdirvp);
528 		fscp->fs_fscdirvp = NULL;
529 	}
530 	if (fscp->fs_fsattrdir) {
531 		VN_RELE(fscp->fs_fsattrdir);
532 		fscp->fs_fsattrdir = NULL;
533 	}
534 	if (fscp->fs_infovp) {
535 		VN_RELE(fscp->fs_infovp);
536 		fscp->fs_infovp = NULL;
537 	}
538 	/* XXX dlog stuff? */
539 
540 	mutex_exit(&fscp->fs_fslock);
541 
542 	/*
543 	 * release resources grabbed in cachefs_cache_activate_ro
544 	 */
545 
546 	mutex_enter(&cachep->c_contentslock);
547 
548 	/* kill off the cachep worker thread */
549 	while (cachep->c_flags & CACHE_CACHEW_THREADRUN) {
550 		cachep->c_flags |= CACHE_CACHEW_THREADEXIT;
551 		cv_signal(&cachep->c_cwcv);
552 		(void) cv_reltimedwait(&cachep->c_cwhaltcv,
553 		    &cachep->c_contentslock, wakeup, TR_CLOCK_TICK);
554 	}
555 
556 	if (cachep->c_resfilevp) {
557 		VN_RELE(cachep->c_resfilevp);
558 		cachep->c_resfilevp = NULL;
559 	}
560 	if (cachep->c_dirvp) {
561 		VN_RELE(cachep->c_dirvp);
562 		cachep->c_dirvp = NULL;
563 	}
564 	if (cachep->c_lockvp) {
565 		VN_RELE(cachep->c_lockvp);
566 		cachep->c_lockvp = NULL;
567 	}
568 	if (cachep->c_lostfoundvp) {
569 		VN_RELE(cachep->c_lostfoundvp);
570 		cachep->c_lostfoundvp = NULL;
571 	}
572 
573 	mutex_enter(&cachep->c_log_mutex);
574 	if (cachep->c_log_ctl) {
575 		cachefs_kmem_free(cachep->c_log_ctl,
576 		    sizeof (cachefs_log_control_t));
577 		cachep->c_log_ctl = NULL;
578 	}
579 	if (cachep->c_log) {
580 		cachefs_log_destroy_cookie(cachep->c_log);
581 		cachep->c_log = NULL;
582 	}
583 	mutex_exit(&cachep->c_log_mutex);
584 
585 	/* XXX do what mountroot_init does when ! foundcache */
586 
587 	cachep->c_flags |= CACHE_NOCACHE;
588 	mutex_exit(&cachep->c_contentslock);
589 
590 	/* XXX should i release this here? */
591 	cachefs_cd_release(fscp);
592 
593 out:
594 
595 	return (error);
596 }
597 
598 /*
599  * ------------------------------------------------------------------
600  *
601  *		cachefs_cache_active_rw
602  *
603  * Description:
604  *	Activates the cachefscache_t object for a read-write file system.
605  * Arguments:
606  *	cachep	the cachefscache_t object to activate
607  * Returns:
608  * Preconditions:
609  *	precond(cachep)
610  *	precond((cachep->c_flags & CACHE_NOCACHE) == 0)
611  *	precond(cachep->c_flags & CACHE_NOFILL)
612  */
613 
614 void
615 cachefs_cache_activate_rw(cachefscache_t *cachep)
616 {
617 	cachefs_rl_listhead_t *lhp;
618 
619 	ASSERT((cachep->c_flags & CACHE_NOCACHE) == 0);
620 	ASSERT(cachep->c_flags & CACHE_NOFILL);
621 
622 	mutex_enter(&cachep->c_contentslock);
623 	cachep->c_flags &= ~CACHE_NOFILL;
624 
625 	/* move the active list to the rl list */
626 	cachefs_rl_cleanup(cachep);
627 
628 	lhp = &cachep->c_rlinfo.rl_items[
629 	    CACHEFS_RL_INDEX(CACHEFS_RL_PACKED_PENDING)];
630 	if (lhp->rli_itemcnt != 0)
631 		cachep->c_flags |= CACHE_PACKED_PENDING;
632 	cachefs_cache_dirty(cachep, 0);
633 	mutex_exit(&cachep->c_contentslock);
634 }
635 
636 /*
637  * ------------------------------------------------------------------
638  *
639  *		cachefs_cache_dirty
640  *
641  * Description:
642  *	Marks the cache as dirty (active).
643  * Arguments:
644  *	cachep	the cachefscache_t to mark as dirty
645  *	lockit	1 means grab contents lock, 0 means caller grabbed it
646  * Returns:
647  * Preconditions:
648  *	precond(cachep)
649  *	precond(cache is in rw mode)
650  */
651 
652 void
653 cachefs_cache_dirty(struct cachefscache *cachep, int lockit)
654 {
655 	int error;
656 
657 	ASSERT((cachep->c_flags & (CACHE_NOCACHE | CACHE_NOFILL)) == 0);
658 
659 	if (lockit) {
660 		mutex_enter(&cachep->c_contentslock);
661 	} else {
662 		ASSERT(MUTEX_HELD(&cachep->c_contentslock));
663 	}
664 	if (cachep->c_flags & CACHE_DIRTY) {
665 		ASSERT(cachep->c_usage.cu_flags & CUSAGE_ACTIVE);
666 	} else {
667 		/*
668 		 * turn on the "cache active" (dirty) flag and write it
669 		 * synchronously to disk
670 		 */
671 		cachep->c_flags |= CACHE_DIRTY;
672 		cachep->c_usage.cu_flags |= CUSAGE_ACTIVE;
673 		if (error = vn_rdwr(UIO_WRITE, cachep->c_resfilevp,
674 		    (caddr_t)&cachep->c_usage, sizeof (struct cache_usage),
675 		    0LL, UIO_SYSSPACE, FSYNC, (rlim64_t)RLIM_INFINITY,
676 		    kcred, NULL)) {
677 			cmn_err(CE_WARN,
678 			    "cachefs: clean flag write error: %d\n", error);
679 		}
680 	}
681 
682 	if (lockit)
683 		mutex_exit(&cachep->c_contentslock);
684 }
685 
686 /*
687  * ------------------------------------------------------------------
688  *
689  *		cachefs_cache_rssync
690  *
691  * Description:
692  *	Syncs out the resource file for the cachefscache_t object.
693  * Arguments:
694  *	cachep	the cachefscache_t object to operate on
695  * Returns:
696  *	Returns 0 for success, !0 on an error writing data.
697  * Preconditions:
698  *	precond(cachep)
699  *	precond(cache is in rw mode)
700  */
701 
702 int
703 cachefs_cache_rssync(struct cachefscache *cachep)
704 {
705 	int error;
706 
707 	ASSERT((cachep->c_flags & (CACHE_NOCACHE | CACHE_NOFILL |
708 	    CACHE_ALLOC_PENDING)) == 0);
709 
710 	if (cachep->c_rl_entries != NULL) {
711 		error = vn_rdwr(UIO_WRITE, cachep->c_resfilevp,
712 		    (caddr_t)cachep->c_rl_entries, MAXBSIZE,
713 		    (offset_t)((cachep->c_rl_window + 1) * MAXBSIZE),
714 		    UIO_SYSSPACE, FSYNC, RLIM_INFINITY, kcred, NULL);
715 		if (error)
716 			cmn_err(CE_WARN,
717 			    "cachefs: Can't Write rl entries Info\n");
718 		cachefs_kmem_free(cachep->c_rl_entries, MAXBSIZE);
719 		cachep->c_rl_entries = NULL;
720 	}
721 
722 	/* write the usage struct for this cache */
723 	error = vn_rdwr(UIO_WRITE, cachep->c_resfilevp,
724 	    (caddr_t)&cachep->c_usage, sizeof (struct cache_usage),
725 	    0LL, UIO_SYSSPACE, 0, (rlim64_t)RLIM_INFINITY, kcred, NULL);
726 	if (error) {
727 		cmn_err(CE_WARN, "cachefs: Can't Write Cache Usage Info\n");
728 	}
729 
730 	/* write the rlinfo for this cache */
731 	error = vn_rdwr(UIO_WRITE, cachep->c_resfilevp,
732 	    (caddr_t)&cachep->c_rlinfo, sizeof (cachefs_rl_info_t),
733 	    (offset_t)sizeof (struct cache_usage), UIO_SYSSPACE,
734 	    0, (rlim64_t)RLIM_INFINITY, kcred, NULL);
735 	if (error) {
736 		cmn_err(CE_WARN, "cachefs: Can't Write Cache RL Info\n");
737 	}
738 	error = VOP_FSYNC(cachep->c_resfilevp, FSYNC, kcred, NULL);
739 	return (error);
740 }
741 
742 /*
743  * ------------------------------------------------------------------
744  *
745  *		cachefs_cache_sync
746  *
747  * Description:
748  *	Sync a cache which includes all of its fscaches.
749  * Arguments:
750  *	cachep	the cachefscache_t object to sync
751  * Returns:
752  * Preconditions:
753  *	precond(cachep)
754  *	precond(cache is in rw mode)
755  */
756 
757 void
758 cachefs_cache_sync(struct cachefscache *cachep)
759 {
760 	struct fscache *fscp;
761 	struct fscache **syncfsc;
762 	int nfscs, fscidx;
763 	int try;
764 	int done;
765 
766 	if (cachep->c_flags & (CACHE_NOCACHE | CACHE_NOFILL))
767 		return;
768 
769 	done = 0;
770 	for (try = 0; (try < 2) && !done; try++) {
771 
772 		nfscs = 0;
773 
774 		/*
775 		 * here we turn off the cache-wide DIRTY flag.  If it's still
776 		 * off when the sync completes we can write the clean flag to
777 		 * disk telling fsck it has no work to do.
778 		 */
779 #ifdef CFSCLEANFLAG
780 		mutex_enter(&cachep->c_contentslock);
781 		cachep->c_flags &= ~CACHE_DIRTY;
782 		mutex_exit(&cachep->c_contentslock);
783 #endif /* CFSCLEANFLAG */
784 
785 		cachefs_log_process_queue(cachep, 1);
786 
787 		mutex_enter(&cachep->c_fslistlock);
788 		syncfsc = cachefs_kmem_alloc(
789 		    cachep->c_refcnt * sizeof (struct fscache *), KM_SLEEP);
790 		for (fscp = cachep->c_fslist; fscp; fscp = fscp->fs_next) {
791 			fscache_hold(fscp);
792 			ASSERT(nfscs < cachep->c_refcnt);
793 			syncfsc[nfscs++] = fscp;
794 		}
795 		ASSERT(nfscs == cachep->c_refcnt);
796 		mutex_exit(&cachep->c_fslistlock);
797 		for (fscidx = 0; fscidx < nfscs; fscidx++) {
798 			fscp = syncfsc[fscidx];
799 			fscache_sync(fscp);
800 			fscache_rele(fscp);
801 		}
802 
803 		/* get rid of any unused fscache objects */
804 		mutex_enter(&cachep->c_fslistlock);
805 		fscache_list_gc(cachep);
806 		mutex_exit(&cachep->c_fslistlock);
807 
808 		/*
809 		 * here we check the cache-wide DIRTY flag.
810 		 * If it's off,
811 		 * we can write the clean flag to disk.
812 		 */
813 #ifdef CFSCLEANFLAG
814 		mutex_enter(&cachep->c_contentslock);
815 		if ((cachep->c_flags & CACHE_DIRTY) == 0) {
816 			if (cachep->c_usage.cu_flags & CUSAGE_ACTIVE) {
817 				cachep->c_usage.cu_flags &= ~CUSAGE_ACTIVE;
818 				if (cachefs_cache_rssync(cachep) == 0) {
819 					done = 1;
820 				} else {
821 					cachep->c_usage.cu_flags |=
822 					    CUSAGE_ACTIVE;
823 				}
824 			} else {
825 				done = 1;
826 			}
827 		}
828 		mutex_exit(&cachep->c_contentslock);
829 #else /* CFSCLEANFLAG */
830 		mutex_enter(&cachep->c_contentslock);
831 		(void) cachefs_cache_rssync(cachep);
832 		mutex_exit(&cachep->c_contentslock);
833 		done = 1;
834 #endif /* CFSCLEANFLAG */
835 		cachefs_kmem_free(syncfsc, nfscs * sizeof (struct fscache *));
836 	}
837 }
838 
839 /*
840  * ------------------------------------------------------------------
841  *
842  *		cachefs_cache_unique
843  *
844  * Description:
845  * Arguments:
846  * Returns:
847  *	Returns a unique number.
848  * Preconditions:
849  *	precond(cachep)
850  */
851 
852 uint_t
853 cachefs_cache_unique(cachefscache_t *cachep)
854 {
855 	uint_t unique = 0;
856 	int error = 0;
857 
858 	mutex_enter(&cachep->c_contentslock);
859 	if (cachep->c_usage.cu_flags & CUSAGE_NEED_ADJUST ||
860 	    ++(cachep->c_unique) == 0) {
861 		cachep->c_usage.cu_unique++;
862 
863 		if (cachep->c_unique == 0)
864 			cachep->c_unique = 1;
865 		cachep->c_flags &= ~CUSAGE_NEED_ADJUST;
866 		error = cachefs_cache_rssync(cachep);
867 	}
868 	if (error == 0)
869 		unique = (cachep->c_usage.cu_unique << 16) + cachep->c_unique;
870 	mutex_exit(&cachep->c_contentslock);
871 	return (unique);
872 }
873 
874 /*
875  * Called from c_getfrontfile. Shouldn't be called from anywhere else !
876  */
877 static int
878 cachefs_createfrontfile(cnode_t *cp, struct filegrp *fgp)
879 {
880 	char name[CFS_FRONTFILE_NAME_SIZE];
881 	struct vattr *attrp = NULL;
882 	int error = 0;
883 	int mode;
884 	int alloc = 0;
885 	int freefile = 0;
886 	int ffrele = 0;
887 	int rlfree = 0;
888 	rl_entry_t rl_ent;
889 
890 #ifdef CFSDEBUG
891 	CFS_DEBUG(CFSDEBUG_FRONT)
892 		printf("c_createfrontfile: ENTER cp %p fgp %p\n",
893 		    (void *)cp, (void *)fgp);
894 #endif
895 
896 	ASSERT(cp->c_frontvp == NULL);
897 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fgp->fg_fscp) == 0);
898 
899 	/* quit if we cannot write to the filegrp */
900 	if ((fgp->fg_flags & CFS_FG_WRITE) == 0) {
901 		error = ENOENT;
902 		goto out;
903 	}
904 
905 	/* find or create the filegrp attrcache file if necessary */
906 	if (fgp->fg_flags & CFS_FG_ALLOC_ATTR) {
907 		error = filegrp_allocattr(fgp);
908 		if (error)
909 			goto out;
910 	}
911 
912 	make_ascii_name(&cp->c_id, name);
913 
914 	/* set up attributes for the front file we want to create */
915 	attrp = cachefs_kmem_zalloc(sizeof (struct vattr), KM_SLEEP);
916 	alloc++;
917 	attrp->va_mode = S_IFREG | 0666;
918 	mode = 0666;
919 	attrp->va_uid = 0;
920 	attrp->va_gid = 0;
921 	attrp->va_type = VREG;
922 	attrp->va_size = 0;
923 	attrp->va_mask = AT_SIZE | AT_TYPE | AT_MODE | AT_UID | AT_GID;
924 
925 	/* get a file from the resource counts */
926 	error = cachefs_allocfile(fgp->fg_fscp->fs_cache);
927 	if (error) {
928 		error = EINVAL;
929 		goto out;
930 	}
931 	freefile++;
932 
933 	/* create the metadata slot if necessary */
934 	if (cp->c_flags & CN_ALLOC_PENDING) {
935 		error = filegrp_create_metadata(fgp, &cp->c_metadata,
936 		    &cp->c_id);
937 		if (error) {
938 			error = EINVAL;
939 			goto out;
940 		}
941 		cp->c_flags &= ~CN_ALLOC_PENDING;
942 		cp->c_flags |= CN_UPDATED;
943 	}
944 
945 	/* get an rl entry if necessary */
946 	if (cp->c_metadata.md_rlno == 0) {
947 		rl_ent.rl_fileno = cp->c_id.cid_fileno;
948 		rl_ent.rl_local = (cp->c_id.cid_flags & CFS_CID_LOCAL) ? 1 : 0;
949 		rl_ent.rl_fsid = fgp->fg_fscp->fs_cfsid;
950 		rl_ent.rl_attrc = 0;
951 		error = cachefs_rl_alloc(fgp->fg_fscp->fs_cache, &rl_ent,
952 		    &cp->c_metadata.md_rlno);
953 		if (error)
954 			goto out;
955 		cachefs_rlent_moveto(fgp->fg_fscp->fs_cache,
956 		    CACHEFS_RL_ACTIVE, cp->c_metadata.md_rlno,
957 		    cp->c_metadata.md_frontblks);
958 		cp->c_metadata.md_rltype = CACHEFS_RL_ACTIVE;
959 		rlfree++;
960 		cp->c_flags |= CN_UPDATED; /* XXX sam: do we need this? */
961 
962 		/* increment number of front files */
963 		error = filegrp_ffhold(fgp);
964 		if (error) {
965 			error = EINVAL;
966 			goto out;
967 		}
968 		ffrele++;
969 	}
970 
971 	if (cp->c_flags & CN_ASYNC_POP_WORKING) {
972 		/* lookup the already created front file */
973 		error = VOP_LOOKUP(fgp->fg_dirvp, name, &cp->c_frontvp,
974 		    NULL, 0, NULL, kcred, NULL, NULL, NULL);
975 	} else {
976 		/* create the front file */
977 		error = VOP_CREATE(fgp->fg_dirvp, name, attrp, EXCL, mode,
978 		    &cp->c_frontvp, kcred, 0, NULL, NULL);
979 	}
980 	if (error) {
981 #ifdef CFSDEBUG
982 		CFS_DEBUG(CFSDEBUG_FRONT)
983 			printf("c_createfrontfile: Can't create cached object"
984 			    " error %u, fileno %llx\n", error,
985 			    (u_longlong_t)cp->c_id.cid_fileno);
986 #endif
987 		goto out;
988 	}
989 
990 	/* get a copy of the fid of the front file */
991 	cp->c_metadata.md_fid.fid_len = MAXFIDSZ;
992 	error = VOP_FID(cp->c_frontvp, &cp->c_metadata.md_fid, NULL);
993 	if (error) {
994 		/*
995 		 * If we get back ENOSPC then the fid we passed in was too
996 		 * small.  For now we don't do anything and map to EINVAL.
997 		 */
998 		if (error == ENOSPC) {
999 			error = EINVAL;
1000 		}
1001 		goto out;
1002 	}
1003 
1004 	dnlc_purge_vp(cp->c_frontvp);
1005 
1006 	cp->c_metadata.md_flags |= MD_FILE;
1007 	cp->c_flags |= CN_UPDATED | CN_NEED_FRONT_SYNC;
1008 
1009 out:
1010 	if (error) {
1011 		if (cp->c_frontvp) {
1012 			VN_RELE(cp->c_frontvp);
1013 			(void) VOP_REMOVE(fgp->fg_dirvp, name, kcred, NULL, 0);
1014 			cp->c_frontvp = NULL;
1015 		}
1016 		if (ffrele)
1017 			filegrp_ffrele(fgp);
1018 		if (freefile)
1019 			cachefs_freefile(fgp->fg_fscp->fs_cache);
1020 		if (rlfree) {
1021 #ifdef CFSDEBUG
1022 			cachefs_rlent_verify(fgp->fg_fscp->fs_cache,
1023 			    CACHEFS_RL_ACTIVE, cp->c_metadata.md_rlno);
1024 #endif /* CFSDEBUG */
1025 			cachefs_rlent_moveto(fgp->fg_fscp->fs_cache,
1026 			    CACHEFS_RL_FREE, cp->c_metadata.md_rlno, 0);
1027 			cp->c_metadata.md_rlno = 0;
1028 			cp->c_metadata.md_rltype = CACHEFS_RL_NONE;
1029 		}
1030 		cachefs_nocache(cp);
1031 	}
1032 	if (alloc)
1033 		cachefs_kmem_free(attrp, sizeof (struct vattr));
1034 #ifdef CFSDEBUG
1035 	CFS_DEBUG(CFSDEBUG_FRONT)
1036 		printf("c_createfrontfile: EXIT error = %d name %s\n", error,
1037 		    name);
1038 #endif
1039 	return (error);
1040 }
1041 
1042 /*
1043  * Releases resources associated with the front file.
1044  * Only call this routine if a ffhold has been done.
1045  * Its okay to call this routine if the front file does not exist.
1046  * Note: this routine is used even if there is no front file.
1047  */
1048 void
1049 cachefs_removefrontfile(cachefs_metadata_t *mdp, cfs_cid_t *cidp,
1050     filegrp_t *fgp)
1051 {
1052 	int error, enoent;
1053 	char name[CFS_FRONTFILE_NAME_SIZE + 2];
1054 
1055 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fgp->fg_fscp) == 0);
1056 
1057 	enoent = 0;
1058 	if (mdp->md_flags & MD_FILE) {
1059 		if (fgp->fg_dirvp == NULL) {
1060 			cmn_err(CE_WARN, "cachefs: remove error, run fsck\n");
1061 			return;
1062 		}
1063 		make_ascii_name(cidp, name);
1064 		error = VOP_REMOVE(fgp->fg_dirvp, name, kcred, NULL, 0);
1065 		if (error == ENOENT)
1066 			enoent = 1;
1067 		if ((error) && (error != ENOENT)) {
1068 			cmn_err(CE_WARN, "UFS remove error %s %d, run fsck\n",
1069 			    name, error);
1070 		}
1071 		if (mdp->md_flags & MD_ACLDIR) {
1072 			(void) strcat(name, ".d");
1073 			error = VOP_RMDIR(fgp->fg_dirvp, name, fgp->fg_dirvp,
1074 			    kcred, NULL, 0);
1075 			if ((error) && (error != ENOENT)) {
1076 				cmn_err(CE_WARN, "frontfs rmdir error %s %d"
1077 				    "; run fsck\n", name, error);
1078 			}
1079 		}
1080 		mdp->md_flags &= ~(MD_FILE | MD_POPULATED | MD_ACL | MD_ACLDIR);
1081 		bzero(&mdp->md_allocinfo, mdp->md_allocents *
1082 		    sizeof (struct cachefs_allocmap));
1083 		cachefs_freefile(fgp->fg_fscp->fs_cache);
1084 	}
1085 
1086 	/*
1087 	 * Clear packed bit, fastsymlinks and special files
1088 	 * do not have a front file.
1089 	 */
1090 	mdp->md_flags &= ~MD_PACKED;
1091 
1092 	/* XXX either rename routine or move this to caller */
1093 	if (enoent == 0)
1094 		filegrp_ffrele(fgp);
1095 
1096 	if (mdp->md_frontblks) {
1097 		cachefs_freeblocks(fgp->fg_fscp->fs_cache, mdp->md_frontblks,
1098 		    mdp->md_rltype);
1099 		mdp->md_frontblks = 0;
1100 	}
1101 }
1102 
1103 /*
1104  * This is the interface to the rest of CFS. This takes a cnode, and returns
1105  * the frontvp (stuffs it in the cnode). This creates an attrcache slot and
1106  * and frontfile if necessary.
1107  */
1108 
1109 int
1110 cachefs_getfrontfile(cnode_t *cp)
1111 {
1112 	struct filegrp *fgp = cp->c_filegrp;
1113 	int error;
1114 	struct vattr va;
1115 
1116 #ifdef CFSDEBUG
1117 	CFS_DEBUG(CFSDEBUG_SUBR)
1118 		printf("c_getfrontfile: ENTER cp %p\n", (void *)cp);
1119 #endif
1120 
1121 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fgp->fg_fscp) == 0);
1122 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1123 
1124 	/*
1125 	 * Now we check to see if there is a front file for this entry.
1126 	 * If there is, we get the vnode for it and stick it in the cnode.
1127 	 * Otherwise, we create a front file, get the vnode for it and stick
1128 	 * it in the cnode.
1129 	 */
1130 	if (cp->c_flags & CN_STALE) {
1131 		cp->c_flags |= CN_NOCACHE;
1132 		error = ESTALE;
1133 		goto out;
1134 	}
1135 
1136 	/*
1137 	 * If the cnode is being populated, and we're not the populating
1138 	 * thread, then block until the pop thread completes.  If we are the
1139 	 * pop thread, then we may come in here, but not to nuke the directory
1140 	 * cnode at a critical juncture.  If we return from a cv_wait and the
1141 	 * cnode is now stale, don't bother trying to get the front file.
1142 	 */
1143 	while ((cp->c_flags & CN_ASYNC_POP_WORKING) &&
1144 	    (cp->c_popthrp != curthread)) {
1145 		cv_wait(&cp->c_popcv, &cp->c_statelock);
1146 		if (cp->c_flags & CN_STALE) {
1147 			cp->c_flags |= CN_NOCACHE;
1148 			error = ESTALE;
1149 			goto out;
1150 		}
1151 	}
1152 
1153 	if ((cp->c_metadata.md_flags & MD_FILE) == 0) {
1154 #ifdef CFSDEBUG
1155 		if (cp->c_frontvp != NULL)
1156 			CFS_DEBUG(CFSDEBUG_FRONT)
1157 				printf("c_getfrontfile: !MD_FILE and frontvp "
1158 				    "not null cp %p\n", (void *)cp);
1159 #endif
1160 		if (CTOV(cp)->v_type == VDIR)
1161 			ASSERT((cp->c_metadata.md_flags & MD_POPULATED) == 0);
1162 		error = cachefs_createfrontfile(cp, fgp);
1163 		if (error)
1164 			goto out;
1165 	} else {
1166 		/*
1167 		 * A front file exists, all we need to do is to grab the fid,
1168 		 * do a VFS_VGET() on the fid, stuff the vnode in the cnode,
1169 		 * and return.
1170 		 */
1171 		if (fgp->fg_dirvp == NULL) {
1172 			cmn_err(CE_WARN, "cachefs: gff0: corrupted file system"
1173 			    " run fsck\n");
1174 			cachefs_inval_object(cp);
1175 			cp->c_flags |= CN_NOCACHE;
1176 			error = ESTALE;
1177 			goto out;
1178 		}
1179 		error = VFS_VGET(fgp->fg_dirvp->v_vfsp, &cp->c_frontvp,
1180 		    &cp->c_metadata.md_fid);
1181 		if (error || (cp->c_frontvp == NULL)) {
1182 #ifdef CFSDEBUG
1183 			CFS_DEBUG(CFSDEBUG_FRONT)
1184 				printf("cachefs: "
1185 				    "gff1: front file system error %d\n",
1186 				    error);
1187 #endif /* CFSDEBUG */
1188 			cachefs_inval_object(cp);
1189 			cp->c_flags |= CN_NOCACHE;
1190 			error = ESTALE;
1191 			goto out;
1192 		}
1193 
1194 		/* don't need to check timestamps if need_front_sync is set */
1195 		if (cp->c_flags & CN_NEED_FRONT_SYNC) {
1196 			error = 0;
1197 			goto out;
1198 		}
1199 
1200 		/* don't need to check empty directories */
1201 		if (CTOV(cp)->v_type == VDIR &&
1202 		    ((cp->c_metadata.md_flags & MD_POPULATED) == 0)) {
1203 			error = 0;
1204 			goto out;
1205 		}
1206 
1207 		/* get modify time of the front file */
1208 		va.va_mask = AT_MTIME;
1209 		error = VOP_GETATTR(cp->c_frontvp, &va, 0, kcred, NULL);
1210 		if (error) {
1211 			cmn_err(CE_WARN, "cachefs: gff2: front file"
1212 			    " system error %d", error);
1213 			cachefs_inval_object(cp);
1214 			error = (cp->c_flags & CN_NOCACHE) ? ESTALE : 0;
1215 			goto out;
1216 		}
1217 
1218 		/* compare with modify time stored in metadata */
1219 		if (bcmp(&va.va_mtime, &cp->c_metadata.md_timestamp,
1220 		    sizeof (timestruc_t)) != 0) {
1221 #ifdef CFSDEBUG
1222 			CFS_DEBUG(CFSDEBUG_GENERAL | CFSDEBUG_INVALIDATE) {
1223 				long sec, nsec;
1224 				sec = cp->c_metadata.md_timestamp.tv_sec;
1225 				nsec = cp->c_metadata.md_timestamp.tv_nsec;
1226 				printf("c_getfrontfile: timestamps don't"
1227 				    " match fileno %lld va %lx %lx"
1228 				    " meta %lx %lx\n",
1229 				    (u_longlong_t)cp->c_id.cid_fileno,
1230 				    va.va_mtime.tv_sec,
1231 				    va.va_mtime.tv_nsec, sec, nsec);
1232 			}
1233 #endif
1234 			cachefs_inval_object(cp);
1235 			error = (cp->c_flags & CN_NOCACHE) ? ESTALE : 0;
1236 		}
1237 	}
1238 out:
1239 #ifdef CFSDEBUG
1240 	CFS_DEBUG(CFSDEBUG_FRONT)
1241 		printf("c_getfrontfile: EXIT error = %d\n", error);
1242 #endif
1243 	return (error);
1244 }
1245 
1246 void
1247 cachefs_inval_object(cnode_t *cp)
1248 {
1249 	cachefscache_t *cachep = C_TO_FSCACHE(cp)->fs_cache;
1250 	struct filegrp *fgp = cp->c_filegrp;
1251 	int error;
1252 
1253 	ASSERT(CFS_ISFS_BACKFS_NFSV4(C_TO_FSCACHE(cp)) == 0);
1254 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1255 	ASSERT((cp->c_flags & CN_ASYNC_POP_WORKING) == 0 ||
1256 	    cp->c_popthrp == curthread);
1257 #if 0
1258 	CFS_DEBUG(CFSDEBUG_SUBR)
1259 		printf("c_inval_object: ENTER cp %p\n", (void *)cp);
1260 	if (cp->c_flags & (CN_ASYNC_POPULATE | CN_ASYNC_POP_WORKING))
1261 		debug_enter("inval object during async pop");
1262 #endif
1263 	cp->c_flags |= CN_NOCACHE;
1264 
1265 	/* if we cannot modify the cache */
1266 	if (C_TO_FSCACHE(cp)->fs_cache->c_flags &
1267 	    (CACHE_NOFILL | CACHE_NOCACHE)) {
1268 		goto out;
1269 	}
1270 
1271 	/* if there is a front file */
1272 	if (cp->c_metadata.md_flags & MD_FILE) {
1273 		if (fgp->fg_dirvp == NULL)
1274 			goto out;
1275 
1276 		/* get the front file vp if necessary */
1277 		if (cp->c_frontvp == NULL) {
1278 
1279 			error = VFS_VGET(fgp->fg_dirvp->v_vfsp, &cp->c_frontvp,
1280 			    &cp->c_metadata.md_fid);
1281 			if (error || (cp->c_frontvp == NULL)) {
1282 #ifdef CFSDEBUG
1283 				CFS_DEBUG(CFSDEBUG_FRONT)
1284 					printf("cachefs: "
1285 					    "io: front file error %d\n", error);
1286 #endif /* CFSDEBUG */
1287 				goto out;
1288 			}
1289 		}
1290 
1291 		/* truncate the file to zero size */
1292 		error = cachefs_frontfile_size(cp, 0);
1293 		if (error)
1294 			goto out;
1295 		cp->c_flags &= ~CN_NOCACHE;
1296 
1297 		/* if a directory, v_type is zero if called from initcnode */
1298 		if (cp->c_attr.va_type == VDIR) {
1299 			if (cp->c_usage < CFS_DIRCACHE_COST) {
1300 				cp->c_invals++;
1301 				if (cp->c_invals > CFS_DIRCACHE_INVAL) {
1302 					cp->c_invals = 0;
1303 				}
1304 			} else
1305 				cp->c_invals = 0;
1306 			cp->c_usage = 0;
1307 		}
1308 	} else {
1309 		cp->c_flags &= ~CN_NOCACHE;
1310 	}
1311 
1312 out:
1313 	if ((cp->c_metadata.md_flags & MD_PACKED) &&
1314 	    (cp->c_metadata.md_rltype != CACHEFS_RL_MODIFIED) &&
1315 	    ((cachep->c_flags & CACHE_NOFILL) == 0)) {
1316 		ASSERT(cp->c_metadata.md_rlno != 0);
1317 		if (cp->c_metadata.md_rltype != CACHEFS_RL_PACKED_PENDING) {
1318 			cachefs_rlent_moveto(cachep,
1319 			    CACHEFS_RL_PACKED_PENDING,
1320 			    cp->c_metadata.md_rlno,
1321 			    cp->c_metadata.md_frontblks);
1322 			cp->c_metadata.md_rltype = CACHEFS_RL_PACKED_PENDING;
1323 			/* unconditionally set CN_UPDATED below */
1324 		}
1325 	}
1326 
1327 	cachefs_purgeacl(cp);
1328 
1329 	if (cp->c_flags & CN_ASYNC_POP_WORKING)
1330 		cp->c_flags |= CN_NOCACHE;
1331 	cp->c_metadata.md_flags &= ~(MD_POPULATED | MD_INVALREADDIR |
1332 	    MD_FASTSYMLNK);
1333 	cp->c_flags &= ~CN_NEED_FRONT_SYNC;
1334 	cp->c_flags |= CN_UPDATED;
1335 
1336 	/*
1337 	 * If the object invalidated is a directory, the dnlc should be purged
1338 	 * to elide all references to this (directory) vnode.
1339 	 */
1340 	if (CTOV(cp)->v_type == VDIR)
1341 		dnlc_purge_vp(CTOV(cp));
1342 
1343 #ifdef CFSDEBUG
1344 	CFS_DEBUG(CFSDEBUG_SUBR)
1345 		printf("c_inval_object: EXIT\n");
1346 #endif
1347 }
1348 
1349 void
1350 make_ascii_name(cfs_cid_t *cidp, char *strp)
1351 {
1352 	int i = sizeof (uint_t) * 4;
1353 	u_longlong_t index;
1354 	ino64_t name;
1355 
1356 	if (cidp->cid_flags & CFS_CID_LOCAL)
1357 		*strp++ = 'L';
1358 	name = (ino64_t)cidp->cid_fileno;
1359 	do {
1360 		index = (((u_longlong_t)name) & 0xf000000000000000) >> 60;
1361 		index &= (u_longlong_t)0xf;
1362 		ASSERT(index < (u_longlong_t)16);
1363 		*strp++ = "0123456789abcdef"[index];
1364 		name <<= 4;
1365 	} while (--i);
1366 	*strp = '\0';
1367 }
1368 
1369 void
1370 cachefs_nocache(cnode_t *cp)
1371 {
1372 	fscache_t *fscp = C_TO_FSCACHE(cp);
1373 	cachefscache_t *cachep = fscp->fs_cache;
1374 
1375 #ifdef CFSDEBUG
1376 	CFS_DEBUG(CFSDEBUG_SUBR)
1377 		printf("c_nocache: ENTER cp %p\n", (void *)cp);
1378 #endif
1379 
1380 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0);
1381 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1382 	if ((cp->c_flags & CN_NOCACHE) == 0) {
1383 #ifdef CFSDEBUG
1384 		CFS_DEBUG(CFSDEBUG_INVALIDATE)
1385 			printf("cachefs_nocache: invalidating %llu\n",
1386 			    (u_longlong_t)cp->c_id.cid_fileno);
1387 #endif
1388 		/*
1389 		 * Here we are waiting until inactive time to do
1390 		 * the inval_object.  In case we don't get to inactive
1391 		 * (because of a crash, say) we set up a timestamp mismatch
1392 		 * such that getfrontfile will blow the front file away
1393 		 * next time we try to use it.
1394 		 */
1395 		cp->c_metadata.md_timestamp.tv_sec = 0;
1396 		cp->c_metadata.md_timestamp.tv_nsec = 0;
1397 		cp->c_metadata.md_flags &= ~(MD_POPULATED | MD_INVALREADDIR |
1398 		    MD_FASTSYMLNK);
1399 		cp->c_flags &= ~CN_NEED_FRONT_SYNC;
1400 
1401 		cachefs_purgeacl(cp);
1402 
1403 		/*
1404 		 * It is possible we can nocache while disconnected.
1405 		 * A directory could be nocached by running out of space.
1406 		 * A regular file should only be nocached if an I/O error
1407 		 * occurs to the front fs.
1408 		 * We count on the item staying on the modified list
1409 		 * so we do not loose the cid to fid mapping for directories.
1410 		 */
1411 
1412 		if ((cp->c_metadata.md_flags & MD_PACKED) &&
1413 		    (cp->c_metadata.md_rltype != CACHEFS_RL_MODIFIED) &&
1414 		    ((cachep->c_flags & CACHE_NOFILL) == 0)) {
1415 			ASSERT(cp->c_metadata.md_rlno != 0);
1416 			if (cp->c_metadata.md_rltype !=
1417 			    CACHEFS_RL_PACKED_PENDING) {
1418 				cachefs_rlent_moveto(cachep,
1419 				    CACHEFS_RL_PACKED_PENDING,
1420 				    cp->c_metadata.md_rlno,
1421 				    cp->c_metadata.md_frontblks);
1422 				cp->c_metadata.md_rltype =
1423 				    CACHEFS_RL_PACKED_PENDING;
1424 				/* unconditionally set CN_UPDATED below */
1425 			}
1426 		}
1427 
1428 		if (CTOV(cp)->v_type == VDIR)
1429 			dnlc_purge_vp(CTOV(cp));
1430 		cp->c_flags |= (CN_NOCACHE | CN_UPDATED);
1431 	}
1432 
1433 	if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_NOCACHE))
1434 		cachefs_log_nocache(cachep, 0, fscp->fs_cfsvfsp,
1435 		    &cp->c_metadata.md_cookie, cp->c_id.cid_fileno);
1436 
1437 #ifdef CFSDEBUG
1438 	CFS_DEBUG(CFSDEBUG_SUBR)
1439 		printf("c_nocache: EXIT cp %p\n", (void *)cp);
1440 #endif
1441 }
1442 
1443 /*
1444  * Checks to see if the page is in the disk cache, by checking the allocmap.
1445  */
1446 int
1447 cachefs_check_allocmap(cnode_t *cp, u_offset_t off)
1448 {
1449 	int i;
1450 	size_t dbl_size_to_look = cp->c_attr.va_size - off;
1451 	uint_t	size_to_look;
1452 
1453 	if (dbl_size_to_look > (u_offset_t)PAGESIZE)
1454 		size_to_look = (uint_t)PAGESIZE;
1455 	else
1456 		/*LINTED alignment okay*/
1457 		size_to_look = (uint_t)dbl_size_to_look;
1458 
1459 	for (i = 0; i < cp->c_metadata.md_allocents; i++) {
1460 		struct cachefs_allocmap *allocp =
1461 		    cp->c_metadata.md_allocinfo + i;
1462 
1463 		if (off >= allocp->am_start_off) {
1464 			if ((off + size_to_look) <=
1465 			    (allocp->am_start_off + allocp->am_size)) {
1466 				struct fscache *fscp = C_TO_FSCACHE(cp);
1467 				cachefscache_t *cachep = fscp->fs_cache;
1468 
1469 				if (CACHEFS_LOG_LOGGING(cachep,
1470 				    CACHEFS_LOG_CALLOC))
1471 					cachefs_log_calloc(cachep, 0,
1472 					    fscp->fs_cfsvfsp,
1473 					    &cp->c_metadata.md_cookie,
1474 					    cp->c_id.cid_fileno,
1475 					    off, size_to_look);
1476 			/*
1477 			 * Found the page in the CFS disk cache.
1478 			 */
1479 				return (1);
1480 			}
1481 		} else {
1482 			return (0);
1483 		}
1484 	}
1485 	return (0);
1486 }
1487 
1488 /*
1489  * Merges adjacent allocmap entries together where possible, e.g.
1490  *   offset=0x0,     size=0x40000
1491  *   offset=0x40000, size=0x20000	becomes just offset=0x0, size-0x90000
1492  *   offset=0x60000, size=0x30000
1493  */
1494 
1495 
1496 void
1497 cachefs_coalesce_allocmap(struct cachefs_metadata *cmd)
1498 {
1499 	int i, reduced = 0;
1500 	struct cachefs_allocmap *allocp, *nallocp;
1501 
1502 	nallocp = allocp = cmd->md_allocinfo;
1503 	allocp++;
1504 	for (i = 1; i < cmd->md_allocents; i++, allocp++) {
1505 		if (nallocp->am_start_off + nallocp->am_size ==
1506 		    allocp->am_start_off) {
1507 			nallocp->am_size += allocp->am_size;
1508 			reduced++;
1509 		} else {
1510 			nallocp++;
1511 			nallocp->am_start_off = allocp->am_start_off;
1512 			nallocp->am_size = allocp->am_size;
1513 		}
1514 	}
1515 	cmd->md_allocents -= reduced;
1516 }
1517 
1518 /*
1519  * Updates the allocmap to reflect a new chunk of data that has been
1520  * populated.
1521  */
1522 void
1523 cachefs_update_allocmap(cnode_t *cp, u_offset_t off, size_t size)
1524 {
1525 	int i;
1526 	struct cachefs_allocmap *allocp;
1527 	struct fscache *fscp =  C_TO_FSCACHE(cp);
1528 	cachefscache_t *cachep = fscp->fs_cache;
1529 	u_offset_t saveoff;
1530 	u_offset_t savesize;
1531 	u_offset_t logoff = off;
1532 	size_t logsize = size;
1533 	u_offset_t endoff;
1534 	u_offset_t tmpendoff;
1535 
1536 	/*
1537 	 * We try to see if we can coalesce the current block into an existing
1538 	 * allocation and mark it as such.
1539 	 * If we can't do that then we make a new entry in the allocmap.
1540 	 * when we run out of allocmaps, put the cnode in NOCACHE mode.
1541 	 */
1542 again:
1543 	allocp = cp->c_metadata.md_allocinfo;
1544 	for (i = 0; i < cp->c_metadata.md_allocents; i++, allocp++) {
1545 
1546 		if (off <= (allocp->am_start_off)) {
1547 			endoff = off + size;
1548 			if (endoff >= allocp->am_start_off) {
1549 				tmpendoff = allocp->am_start_off +
1550 				    allocp->am_size;
1551 				if (endoff < tmpendoff)
1552 					endoff = tmpendoff;
1553 				allocp->am_size = endoff - off;
1554 				allocp->am_start_off = off;
1555 				cachefs_coalesce_allocmap(&cp->c_metadata);
1556 				allocp = cp->c_metadata.md_allocinfo;
1557 				if (allocp->am_size >= cp->c_size)
1558 					cp->c_metadata.md_flags |= MD_POPULATED;
1559 				return;
1560 			} else {
1561 				saveoff = off;
1562 				savesize = size;
1563 				off = allocp->am_start_off;
1564 				size = allocp->am_size;
1565 				allocp->am_size = savesize;
1566 				allocp->am_start_off = saveoff;
1567 				goto again;
1568 			}
1569 		} else {
1570 			endoff = allocp->am_start_off + allocp->am_size;
1571 			if (off < endoff) {
1572 				tmpendoff = off + size;
1573 				if (endoff < tmpendoff)
1574 					endoff = tmpendoff;
1575 				allocp->am_size = endoff - allocp->am_start_off;
1576 				cachefs_coalesce_allocmap(&cp->c_metadata);
1577 				allocp = cp->c_metadata.md_allocinfo;
1578 				if (allocp->am_size >= cp->c_size)
1579 					cp->c_metadata.md_flags |= MD_POPULATED;
1580 				return;
1581 			}
1582 			if (off == (allocp->am_start_off + allocp->am_size)) {
1583 				allocp->am_size += size;
1584 				cachefs_coalesce_allocmap(&cp->c_metadata);
1585 				allocp = cp->c_metadata.md_allocinfo;
1586 				if (allocp->am_size >= cp->c_size)
1587 					cp->c_metadata.md_flags |= MD_POPULATED;
1588 				return;
1589 			}
1590 		}
1591 	}
1592 	if (i == C_MAX_ALLOCINFO_SLOTS) {
1593 #ifdef CFSDEBUG
1594 		CFS_DEBUG(CFSDEBUG_ALLOCMAP)
1595 			printf("c_update_alloc_map: "
1596 			    "Too many allinfo entries cp %p fileno %llu %p\n",
1597 			    (void *)cp, (u_longlong_t)cp->c_id.cid_fileno,
1598 			    (void *)cp->c_metadata.md_allocinfo);
1599 #endif
1600 		cachefs_nocache(cp);
1601 		return;
1602 	}
1603 	allocp->am_start_off = off;
1604 	allocp->am_size = (u_offset_t)size;
1605 	if (allocp->am_size >= cp->c_size)
1606 		cp->c_metadata.md_flags |= MD_POPULATED;
1607 	cp->c_metadata.md_allocents++;
1608 
1609 	if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_UALLOC))
1610 		cachefs_log_ualloc(cachep, 0, fscp->fs_cfsvfsp,
1611 		    &cp->c_metadata.md_cookie, cp->c_id.cid_fileno,
1612 		    logoff, logsize);
1613 }
1614 
1615 /*
1616  * CFS population function
1617  *
1618  * before async population, this function used to turn on the cnode
1619  * flags CN_UPDATED, CN_NEED_FRONT_SYNC, and CN_POPULATION_PENDING.
1620  * now, however, it's the responsibility of the caller to do this if
1621  * this function returns 0 (no error).
1622  */
1623 
1624 int
1625 cachefs_populate(cnode_t *cp, u_offset_t off, size_t popsize, vnode_t *frontvp,
1626     vnode_t *backvp, u_offset_t cpsize, cred_t *cr)
1627 {
1628 	int error = 0;
1629 	caddr_t addr;
1630 	u_offset_t upto;
1631 	uint_t size;
1632 	u_offset_t from = off;
1633 	cachefscache_t *cachep = C_TO_FSCACHE(cp)->fs_cache;
1634 	ssize_t resid;
1635 	struct fbuf *fbp;
1636 	caddr_t buf = kmem_alloc(MAXBSIZE, KM_SLEEP);
1637 
1638 #ifdef CFSDEBUG
1639 	CFS_DEBUG(CFSDEBUG_VOPS)
1640 		printf("cachefs_populate: ENTER cp %p off %lld\n",
1641 		    (void *)cp, off);
1642 #endif
1643 
1644 	upto = MIN((off + popsize), cpsize);
1645 
1646 	while (from < upto) {
1647 		u_offset_t blkoff = (from & (offset_t)MAXBMASK);
1648 		uint_t n = from - blkoff;
1649 
1650 		size = upto - from;
1651 		if (upto > (blkoff + MAXBSIZE))
1652 			size = MAXBSIZE - n;
1653 
1654 		error = fbread(backvp, (offset_t)blkoff, n + size,
1655 		    S_OTHER, &fbp);
1656 		if (CFS_TIMEOUT(C_TO_FSCACHE(cp), error))
1657 			goto out;
1658 		else if (error) {
1659 #ifdef CFSDEBUG
1660 			CFS_DEBUG(CFSDEBUG_BACK)
1661 				printf("cachefs_populate: fbread error %d\n",
1662 				    error);
1663 #endif
1664 			goto out;
1665 		}
1666 
1667 		addr = fbp->fb_addr;
1668 		ASSERT(addr != NULL);
1669 		ASSERT(n + size <= MAXBSIZE);
1670 		bcopy(addr, buf, n + size);
1671 		fbrelse(fbp, S_OTHER);
1672 
1673 		if (n == 0 || cachefs_check_allocmap(cp, blkoff) == 0) {
1674 			if (error = cachefs_allocblocks(cachep, 1,
1675 			    cp->c_metadata.md_rltype))
1676 				goto out;
1677 			cp->c_metadata.md_frontblks++;
1678 		}
1679 		resid = 0;
1680 		error = vn_rdwr(UIO_WRITE, frontvp, buf + n, size,
1681 		    (offset_t)from, UIO_SYSSPACE, 0,
1682 		    (rlim64_t)RLIM64_INFINITY, cr, &resid);
1683 		if (error) {
1684 #ifdef CFSDEBUG
1685 			CFS_DEBUG(CFSDEBUG_FRONT)
1686 				printf("cachefs_populate: "
1687 				    "Got error = %d from vn_rdwr\n", error);
1688 #endif
1689 			goto out;
1690 		}
1691 #ifdef CFSDEBUG
1692 		if (resid)
1693 			CFS_DEBUG(CFSDEBUG_FRONT)
1694 				printf("cachefs_populate: non-zero resid %ld\n",
1695 				    resid);
1696 #endif
1697 		from += size;
1698 	}
1699 	(void) cachefs_update_allocmap(cp, off, upto - off);
1700 out:
1701 	if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_POPULATE))
1702 		cachefs_log_populate(cachep, error,
1703 		    C_TO_FSCACHE(cp)->fs_cfsvfsp,
1704 		    &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, off,
1705 		    popsize);
1706 
1707 #ifdef CFSDEBUG
1708 	CFS_DEBUG(CFSDEBUG_VOPS)
1709 		printf("cachefs_populate: EXIT cp %p error %d\n",
1710 		    (void *)cp, error);
1711 #endif
1712 	kmem_free(buf, MAXBSIZE);
1713 
1714 	return (error);
1715 }
1716 
1717 /*
1718  * due to compiler error we shifted cnode to the last argument slot.
1719  * occurred during large files project - XXX.
1720  */
1721 void
1722 cachefs_cluster_allocmap(u_offset_t off, u_offset_t *popoffp, size_t *popsizep,
1723     size_t size, struct cnode *cp)
1724 {
1725 	int i;
1726 	u_offset_t lastoff = 0;
1727 	u_offset_t forward_diff = 0;
1728 	u_offset_t backward_diff = 0;
1729 
1730 	ASSERT(size <= C_TO_FSCACHE(cp)->fs_info.fi_popsize);
1731 
1732 #ifdef CFSDEBUG
1733 	CFS_DEBUG(CFSDEBUG_SUBR)
1734 		printf("cachefs_cluster_allocmap: off %llx, size %llx, "
1735 		    "c_size %llx\n", off, size, (longlong_t)cp->c_size);
1736 #endif /* CFSDEBUG */
1737 	for (i = 0; i < cp->c_metadata.md_allocents; i++) {
1738 		struct cachefs_allocmap *allocp =
1739 		    cp->c_metadata.md_allocinfo + i;
1740 
1741 		if (allocp->am_start_off > off) {
1742 			if ((off + size) > allocp->am_start_off) {
1743 				forward_diff = allocp->am_start_off - off;
1744 				backward_diff = size - forward_diff;
1745 				if (backward_diff > off)
1746 					backward_diff = off;
1747 				if (lastoff > (off - backward_diff))
1748 					backward_diff = off - lastoff;
1749 			} else {
1750 				forward_diff = size;
1751 			}
1752 			*popoffp = (off - backward_diff) & (offset_t)PAGEMASK;
1753 			*popsizep = ((off + forward_diff) - *popoffp) &
1754 			    (offset_t)PAGEMASK;
1755 			return;
1756 		} else {
1757 			lastoff = allocp->am_start_off + allocp->am_size;
1758 		}
1759 	}
1760 	if ((lastoff + size) > off) {
1761 		*popoffp = (lastoff & (offset_t)PAGEMASK);
1762 	} else {
1763 		*popoffp = off & (offset_t)PAGEMASK;
1764 	}
1765 
1766 	/*
1767 	 * 64bit project: popsize is the chunk size used to populate the
1768 	 * cache (default 64K). As such, 32 bit should suffice.
1769 	 */
1770 	if ((*popoffp + size) > cp->c_size)
1771 		*popsizep = (cp->c_size - *popoffp + PAGEOFFSET) &
1772 		    (offset_t)PAGEMASK;
1773 	else if (size < PAGESIZE)
1774 		*popsizep = (size + PAGEOFFSET) & (offset_t)PAGEMASK;
1775 	else
1776 		*popsizep = size & (offset_t)PAGEMASK;
1777 
1778 #ifdef CFSDEBUG
1779 	CFS_DEBUG(CFSDEBUG_SUBR)
1780 		printf("cachefs_cluster_allocmap: popoff %llx, popsize %llx\n",
1781 		    (u_longlong_t)(*popoffp), (u_longlong_t)(*popsizep));
1782 #endif /* CFSDEBUG */
1783 }
1784 
1785 /*
1786  * "populate" a symlink in the cache
1787  */
1788 int
1789 cachefs_stuffsymlink(cnode_t *cp, caddr_t buf, int buflen)
1790 {
1791 	int error = 0;
1792 	struct fscache *fscp = C_TO_FSCACHE(cp);
1793 	cachefscache_t *cachep = fscp->fs_cache;
1794 	struct cachefs_metadata *mdp = &cp->c_metadata;
1795 
1796 	ASSERT(RW_WRITE_HELD(&cp->c_rwlock));
1797 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1798 
1799 	if (CFS_ISFS_BACKFS_NFSV4(fscp))
1800 		goto out;
1801 
1802 	if (cp->c_flags & CN_NOCACHE)
1803 		return (ENOENT);
1804 
1805 	cp->c_size = (u_offset_t)buflen;
1806 
1807 	/* if can create a fast sym link */
1808 	if (buflen <= C_FSL_SIZE) {
1809 		/* give up the front file resources */
1810 		if (mdp->md_rlno) {
1811 			cachefs_removefrontfile(mdp, &cp->c_id, cp->c_filegrp);
1812 			cachefs_rlent_moveto(cachep, CACHEFS_RL_FREE,
1813 			    mdp->md_rlno, 0);
1814 			mdp->md_rlno = 0;
1815 			mdp->md_rltype = CACHEFS_RL_NONE;
1816 		}
1817 		/* put sym link contents in allocinfo in metadata */
1818 		bzero(mdp->md_allocinfo, C_FSL_SIZE);
1819 		bcopy(buf, mdp->md_allocinfo, buflen);
1820 
1821 		mdp->md_flags |= MD_FASTSYMLNK;
1822 		cp->c_flags &= ~CN_NEED_FRONT_SYNC;
1823 		cp->c_flags |= CN_UPDATED;
1824 		goto out;
1825 	}
1826 
1827 	/* else create a sym link in a front file */
1828 	if (cp->c_frontvp == NULL)
1829 		error = cachefs_getfrontfile(cp);
1830 	if (error)
1831 		goto out;
1832 
1833 	/* truncate front file */
1834 	error = cachefs_frontfile_size(cp, 0);
1835 	mdp->md_flags &= ~(MD_FASTSYMLNK | MD_POPULATED);
1836 	if (error)
1837 		goto out;
1838 
1839 	/* get space for the sym link */
1840 	error = cachefs_allocblocks(cachep, 1, cp->c_metadata.md_rltype);
1841 	if (error)
1842 		goto out;
1843 
1844 	/* write the sym link to the front file */
1845 	error = vn_rdwr(UIO_WRITE, cp->c_frontvp, buf, buflen, 0,
1846 	    UIO_SYSSPACE, 0, RLIM_INFINITY, kcred, NULL);
1847 	if (error) {
1848 		cachefs_freeblocks(cachep, 1, cp->c_metadata.md_rltype);
1849 		goto out;
1850 	}
1851 
1852 	cp->c_metadata.md_flags |= MD_POPULATED;
1853 	cp->c_flags |= CN_NEED_FRONT_SYNC;
1854 	cp->c_flags |= CN_UPDATED;
1855 
1856 out:
1857 	if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_CSYMLINK))
1858 		cachefs_log_csymlink(cachep, error, fscp->fs_cfsvfsp,
1859 		    &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, buflen);
1860 
1861 	return (error);
1862 }
1863 
1864 /*
1865  * Reads the full contents of the symbolic link from the back file system.
1866  * *bufp is set to a MAXPATHLEN buffer that must be freed when done
1867  * *buflenp is the length of the link
1868  */
1869 int
1870 cachefs_readlink_back(cnode_t *cp, cred_t *cr, caddr_t *bufp, int *buflenp)
1871 {
1872 	int error;
1873 	struct uio uio;
1874 	struct iovec iov;
1875 	caddr_t buf;
1876 	fscache_t *fscp = C_TO_FSCACHE(cp);
1877 
1878 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1879 
1880 	*bufp = NULL;
1881 
1882 	/* get back vnode */
1883 	if (cp->c_backvp == NULL) {
1884 		error = cachefs_getbackvp(fscp, cp);
1885 		if (error)
1886 			return (error);
1887 	}
1888 
1889 	/* set up for the readlink */
1890 	bzero(&uio, sizeof (struct uio));
1891 	bzero(&iov, sizeof (struct iovec));
1892 	buf = cachefs_kmem_alloc(MAXPATHLEN, KM_SLEEP);
1893 	iov.iov_base = buf;
1894 	iov.iov_len = MAXPATHLEN;
1895 	uio.uio_iov = &iov;
1896 	uio.uio_iovcnt = 1;
1897 	uio.uio_resid = MAXPATHLEN;
1898 	uio.uio_segflg = UIO_SYSSPACE;
1899 	uio.uio_loffset = 0;
1900 	uio.uio_fmode = 0;
1901 	uio.uio_extflg = UIO_COPY_CACHED;
1902 	uio.uio_llimit = MAXOFFSET_T;
1903 
1904 	/* get the link data */
1905 	CFS_DPRINT_BACKFS_NFSV4(fscp,
1906 	    ("cachefs_readlink (nfsv4): cnode %p, backvp %p\n",
1907 	    cp, cp->c_backvp));
1908 	error = VOP_READLINK(cp->c_backvp, &uio, cr, NULL);
1909 	if (error) {
1910 		cachefs_kmem_free(buf, MAXPATHLEN);
1911 	} else {
1912 		*bufp = buf;
1913 		/*LINTED alignment okay*/
1914 		*buflenp = MAXPATHLEN - (int)uio.uio_resid;
1915 	}
1916 
1917 	return (error);
1918 }
1919 
1920 int
1921 cachefs_getbackvp(struct fscache *fscp, struct cnode *cp)
1922 {
1923 	int error = 0;
1924 	int flag;
1925 
1926 #ifdef CFSDEBUG
1927 	CFS_DEBUG(CFSDEBUG_CHEAT | CFSDEBUG_BACK)
1928 		printf("cachefs_getbackvp: ENTER fscp %p cp %p\n",
1929 		    (void *)fscp, (void *)cp);
1930 #endif
1931 	ASSERT(cp != NULL);
1932 	ASSERT(MUTEX_HELD(&cp->c_statelock));
1933 	ASSERT(cp->c_backvp == NULL);
1934 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0);
1935 
1936 	/*
1937 	 * If destroy is set then the last link to a file has been
1938 	 * removed.  Oddly enough NFS will still return a vnode
1939 	 * for the file if the timeout has not expired.
1940 	 * This causes headaches for cachefs_push because the
1941 	 * vnode is really stale.
1942 	 * So we just short circuit the problem here.
1943 	 */
1944 	if (cp->c_flags & CN_DESTROY)
1945 		return (ESTALE);
1946 
1947 	ASSERT(fscp->fs_backvfsp);
1948 	if (fscp->fs_backvfsp == NULL)
1949 		return (ETIMEDOUT);
1950 	error = VFS_VGET(fscp->fs_backvfsp, &cp->c_backvp,
1951 	    (struct fid *)&cp->c_cookie);
1952 	if (cp->c_backvp && cp->c_cred &&
1953 	    ((cp->c_flags & CN_NEEDOPEN) || (cp->c_attr.va_type == VREG))) {
1954 		/*
1955 		 * XXX bob: really should pass in the correct flag,
1956 		 * fortunately nobody pays attention to it
1957 		 */
1958 		flag = 0;
1959 		/*
1960 		 * If NEEDOOPEN is set, then this file was opened VOP_OPEN'd
1961 		 * but the backvp was not.  So, for the sake of the vnode
1962 		 * open counts used by delegation, we need to OPEN the backvp
1963 		 * with the same flags that were used for this cnode.  That way
1964 		 * when the file is VOP_CLOSE'd the counts won't go negative.
1965 		 */
1966 		if (cp->c_flags & CN_NEEDOPEN) {
1967 			cp->c_flags &= ~CN_NEEDOPEN;
1968 			if (cp->c_rdcnt > 0) {
1969 				cp->c_rdcnt--;
1970 				flag |= FREAD;
1971 			}
1972 			if (cp->c_wrcnt > 0) {
1973 				cp->c_wrcnt--;
1974 				flag |= FWRITE;
1975 			}
1976 		}
1977 		error = VOP_OPEN(&cp->c_backvp, flag, cp->c_cred, NULL);
1978 		if (error) {
1979 			VN_RELE(cp->c_backvp);
1980 			cp->c_backvp = NULL;
1981 		}
1982 	}
1983 
1984 #ifdef CFSDEBUG
1985 	CFS_DEBUG(CFSDEBUG_GENERAL | CFSDEBUG_BACK) {
1986 		if (error || cp->c_backvp == NULL) {
1987 			printf("Stale cookie cp %p fileno %llu type %d \n",
1988 			    (void *)cp, (u_longlong_t)cp->c_id.cid_fileno,
1989 			    CTOV(cp)->v_type);
1990 		}
1991 	}
1992 #endif
1993 
1994 #ifdef CFSDEBUG
1995 	CFS_DEBUG(CFSDEBUG_CHEAT | CFSDEBUG_BACK)
1996 		printf("cachefs_getbackvp: EXIT error = %d\n", error);
1997 #endif
1998 	return (error);
1999 }
2000 
2001 int
2002 cachefs_getcookie(
2003 	vnode_t *vp,
2004 	struct fid *cookiep,
2005 	struct vattr *attrp,
2006 	cred_t *cr,
2007 	uint32_t valid_fid)
2008 {
2009 	int error = 0;
2010 
2011 #ifdef CFSDEBUG
2012 	CFS_DEBUG(CFSDEBUG_CHEAT)
2013 		printf("cachefs_getcookie: ENTER vp %p\n", (void *)vp);
2014 #endif
2015 	/*
2016 	 * Get the FID only if the caller has indicated it is valid,
2017 	 * otherwise, zero the cookie.
2018 	 */
2019 	if (valid_fid) {
2020 		/*
2021 		 * This assumes that the cookie is a full size fid, if we go to
2022 		 * variable length fids we will need to change this.
2023 		 */
2024 		cookiep->fid_len = MAXFIDSZ;
2025 		error = VOP_FID(vp, cookiep, NULL);
2026 	} else {
2027 		bzero(cookiep, sizeof (*cookiep));
2028 	}
2029 
2030 	if (!error) {
2031 		if (attrp) {
2032 			ASSERT(attrp != NULL);
2033 			attrp->va_mask = AT_ALL;
2034 			error = VOP_GETATTR(vp, attrp, 0, cr, NULL);
2035 		}
2036 	} else {
2037 		if (error == ENOSPC) {
2038 			/*
2039 			 * This is an indication that the underlying filesystem
2040 			 * needs a bigger fid.  For now just map to EINVAL.
2041 			 */
2042 			error = EINVAL;
2043 		}
2044 	}
2045 #ifdef CFSDEBUG
2046 	CFS_DEBUG(CFSDEBUG_CHEAT)
2047 		printf("cachefs_getcookie: EXIT error = %d\n", error);
2048 #endif
2049 	return (error);
2050 }
2051 
2052 void
2053 cachefs_workq_init(struct cachefs_workq *qp)
2054 {
2055 	qp->wq_head = qp->wq_tail = NULL;
2056 	qp->wq_length =
2057 	    qp->wq_thread_count =
2058 	    qp->wq_max_len =
2059 	    qp->wq_halt_request = 0;
2060 	qp->wq_keepone = 0;
2061 	cv_init(&qp->wq_req_cv, NULL, CV_DEFAULT, NULL);
2062 	cv_init(&qp->wq_halt_cv, NULL, CV_DEFAULT, NULL);
2063 	mutex_init(&qp->wq_queue_lock, NULL, MUTEX_DEFAULT, NULL);
2064 }
2065 
2066 /*
2067  * return non-zero if it's `okay' to queue more requests (policy)
2068  */
2069 
2070 static int cachefs_async_max = 512;
2071 static int cachefs_async_count = 0;
2072 kmutex_t cachefs_async_lock;
2073 
2074 int
2075 cachefs_async_okay(void)
2076 {
2077 	/*
2078 	 * a value of -1 for max means to ignore freemem
2079 	 */
2080 
2081 	if (cachefs_async_max == -1)
2082 		return (1);
2083 
2084 	if (freemem < minfree)
2085 		return (0);
2086 
2087 	/*
2088 	 * a value of 0 for max means no arbitrary limit (only `freemen')
2089 	 */
2090 
2091 	if (cachefs_async_max == 0)
2092 		return (1);
2093 
2094 	ASSERT(cachefs_async_max > 0);
2095 
2096 	/*
2097 	 * check the global count against the max.
2098 	 *
2099 	 * we don't need to grab cachefs_async_lock -- we're just
2100 	 * looking, and a little bit of `fuzz' is okay.
2101 	 */
2102 
2103 	if (cachefs_async_count >= cachefs_async_max)
2104 		return (0);
2105 
2106 	return (1);
2107 }
2108 
2109 void
2110 cachefs_async_start(struct cachefs_workq *qp)
2111 {
2112 	struct cachefs_req *rp;
2113 	int left;
2114 	callb_cpr_t cprinfo;
2115 
2116 	CALLB_CPR_INIT(&cprinfo, &qp->wq_queue_lock, callb_generic_cpr, "cas");
2117 	mutex_enter(&qp->wq_queue_lock);
2118 	left = 1;
2119 	for (;;) {
2120 		/* if there are no pending requests */
2121 		if ((qp->wq_head == NULL) && (qp->wq_logwork == 0)) {
2122 			/* see if thread should exit */
2123 			if (qp->wq_halt_request || (left == -1)) {
2124 				if ((qp->wq_thread_count > 1) ||
2125 				    (qp->wq_keepone == 0))
2126 					break;
2127 			}
2128 
2129 			/* wake up thread in async_halt if necessary */
2130 			if (qp->wq_halt_request)
2131 				cv_broadcast(&qp->wq_halt_cv);
2132 
2133 			CALLB_CPR_SAFE_BEGIN(&cprinfo);
2134 			/* sleep until there is something to do */
2135 			left = cv_reltimedwait(&qp->wq_req_cv,
2136 			    &qp->wq_queue_lock, CFS_ASYNC_TIMEOUT,
2137 			    TR_CLOCK_TICK);
2138 			CALLB_CPR_SAFE_END(&cprinfo, &qp->wq_queue_lock);
2139 			if ((qp->wq_head == NULL) && (qp->wq_logwork == 0))
2140 				continue;
2141 		}
2142 		left = 1;
2143 
2144 		if (qp->wq_logwork) {
2145 			qp->wq_logwork = 0;
2146 			mutex_exit(&qp->wq_queue_lock);
2147 			cachefs_log_process_queue(qp->wq_cachep, 1);
2148 			mutex_enter(&qp->wq_queue_lock);
2149 			continue;
2150 		}
2151 
2152 		/* remove request from the list */
2153 		rp = qp->wq_head;
2154 		qp->wq_head = rp->cfs_next;
2155 		if (rp->cfs_next == NULL)
2156 			qp->wq_tail = NULL;
2157 
2158 		/* do the request */
2159 		mutex_exit(&qp->wq_queue_lock);
2160 		cachefs_do_req(rp);
2161 		mutex_enter(&qp->wq_queue_lock);
2162 
2163 		/* decrement count of requests */
2164 		qp->wq_length--;
2165 		mutex_enter(&cachefs_async_lock);
2166 		--cachefs_async_count;
2167 		mutex_exit(&cachefs_async_lock);
2168 	}
2169 	ASSERT(qp->wq_head == NULL);
2170 	qp->wq_thread_count--;
2171 	if (qp->wq_halt_request && qp->wq_thread_count == 0)
2172 		cv_broadcast(&qp->wq_halt_cv);
2173 	CALLB_CPR_EXIT(&cprinfo);
2174 	thread_exit();
2175 	/*NOTREACHED*/
2176 }
2177 
2178 /*
2179  * attempt to halt all the async threads associated with a given workq
2180  */
2181 int
2182 cachefs_async_halt(struct cachefs_workq *qp, int force)
2183 {
2184 	int error = 0;
2185 
2186 	mutex_enter(&qp->wq_queue_lock);
2187 	if (force)
2188 		qp->wq_keepone = 0;
2189 
2190 	if (qp->wq_thread_count > 0) {
2191 		qp->wq_halt_request++;
2192 		cv_broadcast(&qp->wq_req_cv);
2193 		(void) cv_reltimedwait(&qp->wq_halt_cv,
2194 		    &qp->wq_queue_lock, (60 * hz), TR_CLOCK_TICK);
2195 		qp->wq_halt_request--;
2196 		if (qp->wq_thread_count > 0) {
2197 			if ((qp->wq_thread_count == 1) &&
2198 			    (qp->wq_length == 0) && qp->wq_keepone)
2199 				error = EAGAIN;
2200 			else
2201 				error = EBUSY;
2202 		} else {
2203 			ASSERT(qp->wq_length == 0 && qp->wq_head == NULL);
2204 		}
2205 	}
2206 	mutex_exit(&qp->wq_queue_lock);
2207 	return (error);
2208 }
2209 
2210 void
2211 cachefs_addqueue(struct cachefs_req *rp, struct cachefs_workq *qp)
2212 {
2213 	mutex_enter(&qp->wq_queue_lock);
2214 	if (qp->wq_thread_count < cachefs_max_threads) {
2215 		if (qp->wq_thread_count == 0 ||
2216 		    (qp->wq_length >= (qp->wq_thread_count * 2))) {
2217 			(void) thread_create(NULL, 0, cachefs_async_start,
2218 			    qp, 0, &p0, TS_RUN, minclsyspri);
2219 			qp->wq_thread_count++;
2220 		}
2221 	}
2222 	mutex_enter(&rp->cfs_req_lock);
2223 	if (qp->wq_tail)
2224 		qp->wq_tail->cfs_next = rp;
2225 	else
2226 		qp->wq_head = rp;
2227 	qp->wq_tail = rp;
2228 	rp->cfs_next = NULL;
2229 	qp->wq_length++;
2230 	if (qp->wq_length > qp->wq_max_len)
2231 		qp->wq_max_len = qp->wq_length;
2232 	mutex_enter(&cachefs_async_lock);
2233 	++cachefs_async_count;
2234 	mutex_exit(&cachefs_async_lock);
2235 
2236 	cv_signal(&qp->wq_req_cv);
2237 	mutex_exit(&rp->cfs_req_lock);
2238 	mutex_exit(&qp->wq_queue_lock);
2239 }
2240 
2241 void
2242 cachefs_async_putpage(struct cachefs_putpage_req *prp, cred_t *cr)
2243 {
2244 	struct cnode *cp = VTOC(prp->cp_vp);
2245 
2246 	ASSERT(CFS_ISFS_BACKFS_NFSV4(C_TO_FSCACHE(cp)) == 0);
2247 
2248 	(void) VOP_PUTPAGE(prp->cp_vp, prp->cp_off, prp->cp_len,
2249 	    prp->cp_flags, cr, NULL);
2250 
2251 	mutex_enter(&cp->c_iomutex);
2252 	if (--cp->c_nio == 0)
2253 		cv_broadcast(&cp->c_iocv);
2254 	if (prp->cp_off == 0 && prp->cp_len == 0 &&
2255 	    (cp->c_ioflags & CIO_PUTPAGES)) {
2256 		cp->c_ioflags &= ~CIO_PUTPAGES;
2257 	}
2258 	mutex_exit(&cp->c_iomutex);
2259 }
2260 
2261 void
2262 cachefs_async_populate(struct cachefs_populate_req *pop, cred_t *cr)
2263 {
2264 	struct cnode *cp = VTOC(pop->cpop_vp);
2265 	struct fscache *fscp = C_TO_FSCACHE(cp);
2266 	struct filegrp *fgp = cp->c_filegrp;
2267 	int error = 0; /* not returned -- used as a place-holder */
2268 	vnode_t *frontvp = NULL, *backvp = NULL;
2269 	int havelock = 0;
2270 	vattr_t va;
2271 
2272 	ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0);
2273 
2274 	if (((cp->c_filegrp->fg_flags & CFS_FG_WRITE) == 0) ||
2275 	    (fscp->fs_cdconnected != CFS_CD_CONNECTED)) {
2276 		mutex_enter(&cp->c_statelock);
2277 		cp->c_flags &= ~CN_ASYNC_POPULATE;
2278 		mutex_exit(&cp->c_statelock);
2279 		return; /* goto out */
2280 	}
2281 
2282 	error = cachefs_cd_access(fscp, 0, 0);
2283 	if (error) {
2284 #ifdef CFSDEBUG
2285 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2286 			printf("async_pop: cd_access: err %d con %d\n",
2287 			    error, fscp->fs_cdconnected);
2288 #endif /* CFSDEBUG */
2289 		mutex_enter(&cp->c_statelock);
2290 		cp->c_flags &= ~CN_ASYNC_POPULATE;
2291 		mutex_exit(&cp->c_statelock);
2292 		return; /* goto out */
2293 	}
2294 
2295 	/*
2296 	 * grab the statelock for some minimal things
2297 	 */
2298 
2299 	rw_enter(&cp->c_rwlock, RW_WRITER);
2300 	mutex_enter(&cp->c_statelock);
2301 	havelock = 1;
2302 
2303 	if ((cp->c_flags & CN_ASYNC_POPULATE) == 0)
2304 		goto out;
2305 
2306 	/* there can be only one */
2307 	ASSERT((cp->c_flags & CN_ASYNC_POP_WORKING) == 0);
2308 	cp->c_flags |= CN_ASYNC_POP_WORKING;
2309 	cp->c_popthrp = curthread;
2310 
2311 	if (cp->c_metadata.md_flags & MD_POPULATED)
2312 		goto out;
2313 
2314 	if (cp->c_flags & CN_NOCACHE) {
2315 #ifdef CFSDEBUG
2316 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2317 			printf("cachefs_async_populate: nocache bit on\n");
2318 #endif /* CFSDEBUG */
2319 		error = EINVAL;
2320 		goto out;
2321 	}
2322 
2323 	if (cp->c_frontvp == NULL) {
2324 		if ((cp->c_metadata.md_flags & MD_FILE) == 0) {
2325 			struct cfs_cid cid = cp->c_id;
2326 
2327 			mutex_exit(&cp->c_statelock);
2328 			havelock = 0;
2329 
2330 			/*
2331 			 * if frontfile doesn't exist, drop the lock
2332 			 * to do some of the file creation stuff.
2333 			 */
2334 
2335 			if (fgp->fg_flags & CFS_FG_ALLOC_ATTR) {
2336 				error = filegrp_allocattr(fgp);
2337 				if (error != 0)
2338 					goto out;
2339 			}
2340 			if (fgp->fg_flags & CFS_FG_ALLOC_FILE) {
2341 				mutex_enter(&fgp->fg_mutex);
2342 				if (fgp->fg_flags & CFS_FG_ALLOC_FILE) {
2343 					if (fgp->fg_header->ach_nffs == 0)
2344 						error = filegrpdir_create(fgp);
2345 					else
2346 						error = filegrpdir_find(fgp);
2347 					if (error != 0) {
2348 						mutex_exit(&fgp->fg_mutex);
2349 						goto out;
2350 					}
2351 				}
2352 				mutex_exit(&fgp->fg_mutex);
2353 			}
2354 
2355 			if (fgp->fg_dirvp != NULL) {
2356 				char name[CFS_FRONTFILE_NAME_SIZE];
2357 				struct vattr *attrp;
2358 
2359 				attrp = cachefs_kmem_zalloc(
2360 				    sizeof (struct vattr), KM_SLEEP);
2361 				attrp->va_mode = S_IFREG | 0666;
2362 				attrp->va_uid = 0;
2363 				attrp->va_gid = 0;
2364 				attrp->va_type = VREG;
2365 				attrp->va_size = 0;
2366 				attrp->va_mask =
2367 				    AT_SIZE | AT_TYPE | AT_MODE |
2368 				    AT_UID | AT_GID;
2369 
2370 				make_ascii_name(&cid, name);
2371 
2372 				(void) VOP_CREATE(fgp->fg_dirvp, name, attrp,
2373 				    EXCL, 0666, &frontvp, kcred, 0, NULL, NULL);
2374 
2375 				cachefs_kmem_free(attrp,
2376 				    sizeof (struct vattr));
2377 			}
2378 
2379 			mutex_enter(&cp->c_statelock);
2380 			havelock = 1;
2381 		}
2382 		error = cachefs_getfrontfile(cp);
2383 		ASSERT((error != 0) ||
2384 		    (frontvp == NULL) ||
2385 		    (frontvp == cp->c_frontvp));
2386 	}
2387 	if ((error != 0) || (cp->c_frontvp == NULL))
2388 		goto out;
2389 
2390 	if (frontvp != NULL)
2391 		VN_RELE(frontvp);
2392 
2393 	frontvp = cp->c_frontvp;
2394 	VN_HOLD(frontvp);
2395 
2396 	if (cp->c_backvp == NULL) {
2397 		error = cachefs_getbackvp(fscp, cp);
2398 		if ((error != 0) || (cp->c_backvp == NULL))
2399 			goto out;
2400 	}
2401 	backvp = cp->c_backvp;
2402 	VN_HOLD(backvp);
2403 
2404 	switch (pop->cpop_vp->v_type) {
2405 	case VREG:
2406 		mutex_exit(&cp->c_statelock);
2407 		havelock = 0;
2408 		error = cachefs_async_populate_reg(pop, cr, backvp, frontvp);
2409 		break;
2410 	case VDIR:
2411 		error = cachefs_async_populate_dir(pop, cr, backvp, frontvp);
2412 		mutex_exit(&cp->c_statelock);
2413 		havelock = 0;
2414 		break;
2415 	default:
2416 #ifdef CFSDEBUG
2417 		printf("cachefs_async_populate: warning: vnode type = %d\n",
2418 		    pop->cpop_vp->v_type);
2419 		ASSERT(0);
2420 #endif /* CFSDEBUG */
2421 		error = EINVAL;
2422 		break;
2423 	}
2424 
2425 	if (error != 0)
2426 		goto out;
2427 
2428 	error = VOP_FSYNC(frontvp, FSYNC, cr, NULL);
2429 	if (error != 0) {
2430 #ifdef CFSDEBUG
2431 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2432 			printf("cachefs_async_populate: fsync\n");
2433 #endif /* CFSDEBUG */
2434 		goto out;
2435 	}
2436 
2437 	/* grab the lock and finish up */
2438 	mutex_enter(&cp->c_statelock);
2439 	havelock = 1;
2440 
2441 	/* if went nocache while lock was dropped, get out */
2442 	if ((cp->c_flags & CN_NOCACHE) || (cp->c_frontvp == NULL)) {
2443 		error = EINVAL;
2444 		goto out;
2445 	}
2446 
2447 	va.va_mask = AT_MTIME;
2448 	error = VOP_GETATTR(cp->c_frontvp, &va, 0, cr, NULL);
2449 	if (error) {
2450 #ifdef CFSDEBUG
2451 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2452 			printf("cachefs_async_populate: getattr\n");
2453 #endif /* CFSDEBUG */
2454 		goto out;
2455 	}
2456 	cp->c_metadata.md_timestamp = va.va_mtime;
2457 	cp->c_metadata.md_flags |= MD_POPULATED;
2458 	cp->c_metadata.md_flags &= ~MD_INVALREADDIR;
2459 	cp->c_flags |= CN_UPDATED;
2460 
2461 out:
2462 	if (! havelock)
2463 		mutex_enter(&cp->c_statelock);
2464 
2465 	/* see if an error happened behind our backs */
2466 	if ((error == 0) && (cp->c_flags & CN_NOCACHE)) {
2467 #ifdef CFSDEBUG
2468 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2469 			printf("cachefs_async_populate: "
2470 			    "nocache behind our backs\n");
2471 #endif /* CFSDEBUG */
2472 		error = EINVAL;
2473 	}
2474 
2475 	cp->c_flags &= ~(CN_NEED_FRONT_SYNC | CN_POPULATION_PENDING |
2476 	    CN_ASYNC_POPULATE | CN_ASYNC_POP_WORKING);
2477 	cp->c_popthrp = NULL;
2478 
2479 	if (error != 0)
2480 		cachefs_nocache(cp);
2481 
2482 	/* unblock any threads waiting for populate to finish */
2483 	cv_broadcast(&cp->c_popcv);
2484 	mutex_exit(&cp->c_statelock);
2485 	rw_exit(&cp->c_rwlock);
2486 	cachefs_cd_release(fscp);
2487 
2488 	if (backvp != NULL) {
2489 		VN_RELE(backvp);
2490 	}
2491 	if (frontvp != NULL) {
2492 		VN_RELE(frontvp);
2493 	}
2494 }
2495 
2496 /*
2497  * only to be called from cachefs_async_populate
2498  */
2499 
2500 static int
2501 cachefs_async_populate_reg(struct cachefs_populate_req *pop, cred_t *cr,
2502     vnode_t *backvp, vnode_t *frontvp)
2503 {
2504 	struct cnode *cp = VTOC(pop->cpop_vp);
2505 	int error = 0;
2506 	u_offset_t popoff;
2507 	size_t popsize;
2508 
2509 	cachefs_cluster_allocmap(pop->cpop_off, &popoff,
2510 	    &popsize, pop->cpop_size, cp);
2511 	if (popsize == 0) {
2512 #ifdef CFSDEBUG
2513 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2514 			printf("cachefs_async_populate: popsize == 0\n");
2515 #endif /* CFSDEBUG */
2516 		goto out;
2517 	}
2518 
2519 	error = cachefs_populate(cp, popoff, popsize, frontvp, backvp,
2520 	    cp->c_size, cr);
2521 	if (error != 0) {
2522 #ifdef CFSDEBUG
2523 		CFS_DEBUG(CFSDEBUG_ASYNCPOP)
2524 			printf("cachefs_async_populate: cachefs_populate\n");
2525 #endif /* CFSDEBUG */
2526 		goto out;
2527 	}
2528 
2529 out:
2530 	return (error);
2531 }
2532 
2533 void
2534 cachefs_do_req(struct cachefs_req *rp)
2535 {
2536 	struct cachefscache *cachep;
2537 
2538 	mutex_enter(&rp->cfs_req_lock);
2539 	switch (rp->cfs_cmd) {
2540 	case CFS_INVALID:
2541 		panic("cachefs_do_req: CFS_INVALID operation on queue");
2542 		/*NOTREACHED*/
2543 	case CFS_CACHE_SYNC:
2544 		cachep = rp->cfs_req_u.cu_fs_sync.cf_cachep;
2545 		cachefs_cache_sync(cachep);
2546 		break;
2547 	case CFS_IDLE:
2548 		cachefs_cnode_idle(rp->cfs_req_u.cu_idle.ci_vp, rp->cfs_cr);
2549 		break;
2550 	case CFS_PUTPAGE:
2551 		cachefs_async_putpage(&rp->cfs_req_u.cu_putpage, rp->cfs_cr);
2552 		VN_RELE(rp->cfs_req_u.cu_putpage.cp_vp);
2553 		break;
2554 	case CFS_POPULATE:
2555 		cachefs_async_populate(&rp->cfs_req_u.cu_populate, rp->cfs_cr);
2556 		VN_RELE(rp->cfs_req_u.cu_populate.cpop_vp);
2557 		break;
2558 	case CFS_NOOP:
2559 		break;
2560 	default:
2561 		panic("c_do_req: Invalid CFS async operation");
2562 	}
2563 	crfree(rp->cfs_cr);
2564 	rp->cfs_cmd = CFS_INVALID;
2565 	mutex_exit(&rp->cfs_req_lock);
2566 	kmem_cache_free(cachefs_req_cache, rp);
2567 }
2568 
2569 
2570 
2571 
2572 ssize_t cachefs_mem_usage = 0;
2573 
2574 struct km_wrap {
2575 	size_t kw_size;
2576 	struct km_wrap *kw_other;
2577 };
2578 
2579 kmutex_t cachefs_kmem_lock;
2580 
2581 void *
2582 cachefs_kmem_alloc(size_t size, int flag)
2583 {
2584 #ifdef DEBUG
2585 	caddr_t mp = NULL;
2586 	struct km_wrap *kwp;
2587 	size_t n = (size + (2 * sizeof (struct km_wrap)) + 7) & ~7;
2588 
2589 	ASSERT(n >= (size + 8));
2590 	mp = kmem_alloc(n, flag);
2591 	if (mp == NULL) {
2592 		return (NULL);
2593 	}
2594 	/*LINTED alignment okay*/
2595 	kwp = (struct km_wrap *)mp;
2596 	kwp->kw_size = n;
2597 	/*LINTED alignment okay*/
2598 	kwp->kw_other = (struct km_wrap *)(mp + n - sizeof (struct km_wrap));
2599 	kwp = (struct km_wrap *)kwp->kw_other;
2600 	kwp->kw_size = n;
2601 	/*LINTED alignment okay*/
2602 	kwp->kw_other = (struct km_wrap *)mp;
2603 
2604 	mutex_enter(&cachefs_kmem_lock);
2605 	ASSERT(cachefs_mem_usage >= 0);
2606 	cachefs_mem_usage += n;
2607 	mutex_exit(&cachefs_kmem_lock);
2608 
2609 	return (mp + sizeof (struct km_wrap));
2610 #else /* DEBUG */
2611 	return (kmem_alloc(size, flag));
2612 #endif /* DEBUG */
2613 }
2614 
2615 void *
2616 cachefs_kmem_zalloc(size_t size, int flag)
2617 {
2618 #ifdef DEBUG
2619 	caddr_t mp = NULL;
2620 	struct km_wrap *kwp;
2621 	size_t n = (size + (2 * sizeof (struct km_wrap)) + 7) & ~7;
2622 
2623 	ASSERT(n >= (size + 8));
2624 	mp = kmem_zalloc(n, flag);
2625 	if (mp == NULL) {
2626 		return (NULL);
2627 	}
2628 	/*LINTED alignment okay*/
2629 	kwp = (struct km_wrap *)mp;
2630 	kwp->kw_size = n;
2631 	/*LINTED alignment okay*/
2632 	kwp->kw_other = (struct km_wrap *)(mp + n - sizeof (struct km_wrap));
2633 	kwp = (struct km_wrap *)kwp->kw_other;
2634 	kwp->kw_size = n;
2635 	/*LINTED alignment okay*/
2636 	kwp->kw_other = (struct km_wrap *)mp;
2637 
2638 	mutex_enter(&cachefs_kmem_lock);
2639 	ASSERT(cachefs_mem_usage >= 0);
2640 	cachefs_mem_usage += n;
2641 	mutex_exit(&cachefs_kmem_lock);
2642 
2643 	return (mp + sizeof (struct km_wrap));
2644 #else /* DEBUG */
2645 	return (kmem_zalloc(size, flag));
2646 #endif /* DEBUG */
2647 }
2648 
2649 void
2650 cachefs_kmem_free(void *mp, size_t size)
2651 {
2652 #ifdef DEBUG
2653 	struct km_wrap *front_kwp;
2654 	struct km_wrap *back_kwp;
2655 	size_t n = (size + (2 * sizeof (struct km_wrap)) + 7) & ~7;
2656 	void *p;
2657 
2658 	ASSERT(n >= (size + 8));
2659 	front_kwp = (struct km_wrap *)((uintptr_t)mp - sizeof (struct km_wrap));
2660 	back_kwp = (struct km_wrap *)
2661 	    ((uintptr_t)front_kwp + n - sizeof (struct km_wrap));
2662 
2663 	ASSERT(front_kwp->kw_other == back_kwp);
2664 	ASSERT(front_kwp->kw_size == n);
2665 	ASSERT(back_kwp->kw_other == front_kwp);
2666 	ASSERT(back_kwp->kw_size == n);
2667 
2668 	mutex_enter(&cachefs_kmem_lock);
2669 	cachefs_mem_usage -= n;
2670 	ASSERT(cachefs_mem_usage >= 0);
2671 	mutex_exit(&cachefs_kmem_lock);
2672 
2673 	p = front_kwp;
2674 	front_kwp->kw_size = back_kwp->kw_size = 0;
2675 	front_kwp->kw_other = back_kwp->kw_other = NULL;
2676 	kmem_free(p, n);
2677 #else /* DEBUG */
2678 	kmem_free(mp, size);
2679 #endif /* DEBUG */
2680 }
2681 
2682 char *
2683 cachefs_strdup(char *s)
2684 {
2685 	char *rc;
2686 
2687 	ASSERT(s != NULL);
2688 
2689 	rc = cachefs_kmem_alloc(strlen(s) + 1, KM_SLEEP);
2690 	(void) strcpy(rc, s);
2691 
2692 	return (rc);
2693 }
2694 
2695 int
2696 cachefs_stats_kstat_snapshot(kstat_t *ksp, void *buf, int rw)
2697 {
2698 	struct fscache *fscp = (struct fscache *)ksp->ks_data;
2699 	cachefscache_t *cachep = fscp->fs_cache;
2700 	int	error = 0;
2701 
2702 	if (rw == KSTAT_WRITE) {
2703 		bcopy(buf, &fscp->fs_stats, sizeof (fscp->fs_stats));
2704 		cachep->c_gc_count = fscp->fs_stats.st_gc_count;
2705 		CACHEFS_CFS_TIME_TO_TIME_COPY(fscp->fs_stats.st_gc_time,
2706 		    cachep->c_gc_time);
2707 		CACHEFS_CFS_TIME_TO_TIME_COPY(fscp->fs_stats.st_gc_before_atime,
2708 		    cachep->c_gc_before);
2709 		CACHEFS_CFS_TIME_TO_TIME_COPY(fscp->fs_stats.st_gc_after_atime,
2710 		    cachep->c_gc_after);
2711 		return (error);
2712 	}
2713 
2714 	fscp->fs_stats.st_gc_count = cachep->c_gc_count;
2715 	CACHEFS_TIME_TO_CFS_TIME_COPY(cachep->c_gc_time,
2716 	    fscp->fs_stats.st_gc_time, error);
2717 	CACHEFS_TIME_TO_CFS_TIME_COPY(cachep->c_gc_before,
2718 	    fscp->fs_stats.st_gc_before_atime, error);
2719 	CACHEFS_TIME_TO_CFS_TIME_COPY(cachep->c_gc_after,
2720 	    fscp->fs_stats.st_gc_after_atime, error);
2721 	bcopy(&fscp->fs_stats, buf, sizeof (fscp->fs_stats));
2722 
2723 	return (error);
2724 }
2725 
2726 #ifdef DEBUG
2727 cachefs_debug_info_t *
2728 cachefs_debug_save(cachefs_debug_info_t *oldcdb, int chain,
2729     char *message, uint_t flags, int number, void *pointer,
2730     cachefscache_t *cachep, struct fscache *fscp, struct cnode *cp)
2731 {
2732 	cachefs_debug_info_t *cdb;
2733 
2734 	if ((chain) || (oldcdb == NULL))
2735 		cdb = cachefs_kmem_zalloc(sizeof (*cdb), KM_SLEEP);
2736 	else
2737 		cdb = oldcdb;
2738 	if (chain)
2739 		cdb->cdb_next = oldcdb;
2740 
2741 	if (message != NULL) {
2742 		if (cdb->cdb_message != NULL)
2743 			cachefs_kmem_free(cdb->cdb_message,
2744 			    strlen(cdb->cdb_message) + 1);
2745 		cdb->cdb_message = cachefs_kmem_alloc(strlen(message) + 1,
2746 		    KM_SLEEP);
2747 		(void) strcpy(cdb->cdb_message, message);
2748 	}
2749 	cdb->cdb_flags = flags;
2750 	cdb->cdb_int = number;
2751 	cdb->cdb_pointer = pointer;
2752 
2753 	cdb->cdb_count++;
2754 
2755 	cdb->cdb_cnode = cp;
2756 	if (cp != NULL) {
2757 		cdb->cdb_frontvp = cp->c_frontvp;
2758 		cdb->cdb_backvp = cp->c_backvp;
2759 	}
2760 	if (fscp != NULL)
2761 		cdb->cdb_fscp = fscp;
2762 	else if (cp != NULL)
2763 		cdb->cdb_fscp = C_TO_FSCACHE(cp);
2764 	if (cachep != NULL)
2765 		cdb->cdb_cachep = cachep;
2766 	else if (cdb->cdb_fscp != NULL)
2767 		cdb->cdb_cachep = cdb->cdb_fscp->fs_cache;
2768 
2769 	cdb->cdb_thread = curthread;
2770 	cdb->cdb_timestamp = gethrtime();
2771 	cdb->cdb_depth = getpcstack(cdb->cdb_stack, CACHEFS_DEBUG_DEPTH);
2772 
2773 	return (cdb);
2774 }
2775 
2776 void
2777 cachefs_debug_show(cachefs_debug_info_t *cdb)
2778 {
2779 	hrtime_t now = gethrtime();
2780 	timestruc_t ts;
2781 	int i;
2782 
2783 	while (cdb != NULL) {
2784 		hrt2ts(now - cdb->cdb_timestamp, &ts);
2785 		printf("cdb: %p count: %d timelapse: %ld.%9ld\n",
2786 		    (void *)cdb, cdb->cdb_count, ts.tv_sec, ts.tv_nsec);
2787 		if (cdb->cdb_message != NULL)
2788 			printf("message: %s", cdb->cdb_message);
2789 		printf("flags: %x int: %d pointer: %p\n",
2790 		    cdb->cdb_flags, cdb->cdb_int, (void *)cdb->cdb_pointer);
2791 
2792 		printf("cnode: %p fscp: %p cachep: %p\n",
2793 		    (void *)cdb->cdb_cnode,
2794 		    (void *)cdb->cdb_fscp, (void *)cdb->cdb_cachep);
2795 		printf("frontvp: %p backvp: %p\n",
2796 		    (void *)cdb->cdb_frontvp, (void *)cdb->cdb_backvp);
2797 
2798 		printf("thread: %p stack...\n", (void *)cdb->cdb_thread);
2799 		for (i = 0; i < cdb->cdb_depth; i++) {
2800 			ulong_t off;
2801 			char *sym;
2802 
2803 			sym = kobj_getsymname(cdb->cdb_stack[i], &off);
2804 			printf("%s+%lx\n", sym ? sym : "?", off);
2805 		}
2806 		delay(2*hz);
2807 		cdb = cdb->cdb_next;
2808 	}
2809 	debug_enter(NULL);
2810 }
2811 #endif /* DEBUG */
2812 
2813 /*
2814  * Changes the size of the front file.
2815  * Returns 0 for success or error if cannot set file size.
2816  * NOCACHE bit is ignored.
2817  * c_size is ignored.
2818  * statelock must be held, frontvp must be set.
2819  * File must be populated if setting to a size other than zero.
2820  */
2821 int
2822 cachefs_frontfile_size(cnode_t *cp, u_offset_t length)
2823 {
2824 	cachefscache_t *cachep = C_TO_FSCACHE(cp)->fs_cache;
2825 	vattr_t va;
2826 	size_t nblks, blkdelta;
2827 	int error = 0;
2828 	int alloc = 0;
2829 	struct cachefs_allocmap *allocp;
2830 
2831 	ASSERT(MUTEX_HELD(&cp->c_statelock));
2832 	ASSERT(cp->c_frontvp);
2833 
2834 	/* if growing the file, allocate space first, we charge for holes */
2835 	if (length) {
2836 		ASSERT(cp->c_metadata.md_flags & MD_POPULATED);
2837 
2838 		nblks = (length + MAXBSIZE - 1) / MAXBSIZE;
2839 		if (nblks > cp->c_metadata.md_frontblks) {
2840 			blkdelta = nblks - cp->c_metadata.md_frontblks;
2841 			error = cachefs_allocblocks(cachep, blkdelta,
2842 			    cp->c_metadata.md_rltype);
2843 			if (error)
2844 				goto out;
2845 			alloc = 1;
2846 		}
2847 	}
2848 
2849 	/* change the size of the front file */
2850 	va.va_mask = AT_SIZE;
2851 	va.va_size = length;
2852 	error = VOP_SETATTR(cp->c_frontvp, &va, 0, kcred, NULL);
2853 	if (error)
2854 		goto out;
2855 
2856 	/* zero out the alloc map */
2857 	bzero(&cp->c_metadata.md_allocinfo,
2858 	    cp->c_metadata.md_allocents * sizeof (struct cachefs_allocmap));
2859 	cp->c_metadata.md_allocents = 0;
2860 
2861 	if (length == 0) {
2862 		/* free up blocks */
2863 		if (cp->c_metadata.md_frontblks) {
2864 			cachefs_freeblocks(cachep, cp->c_metadata.md_frontblks,
2865 			    cp->c_metadata.md_rltype);
2866 			cp->c_metadata.md_frontblks = 0;
2867 		}
2868 	} else {
2869 		/* update number of blocks if shrinking file */
2870 		nblks = (length + MAXBSIZE - 1) / MAXBSIZE;
2871 		if (nblks < cp->c_metadata.md_frontblks) {
2872 			blkdelta = cp->c_metadata.md_frontblks - nblks;
2873 			cachefs_freeblocks(cachep, blkdelta,
2874 			    cp->c_metadata.md_rltype);
2875 			cp->c_metadata.md_frontblks = (uint_t)nblks;
2876 		}
2877 
2878 		/* fix up alloc map to reflect new size */
2879 		allocp = cp->c_metadata.md_allocinfo;
2880 		allocp->am_start_off = 0;
2881 		allocp->am_size = length;
2882 		cp->c_metadata.md_allocents = 1;
2883 	}
2884 	cp->c_flags |= CN_UPDATED | CN_NEED_FRONT_SYNC;
2885 
2886 out:
2887 	if (error && alloc)
2888 		cachefs_freeblocks(cachep, blkdelta, cp->c_metadata.md_rltype);
2889 	return (error);
2890 }
2891 
2892 /*ARGSUSED*/
2893 int
2894 cachefs_req_create(void *voidp, void *cdrarg, int kmflags)
2895 {
2896 	struct cachefs_req *rp = (struct cachefs_req *)voidp;
2897 
2898 	/*
2899 	 * XXX don't do this!  if you need this, you can't use this
2900 	 * constructor.
2901 	 */
2902 
2903 	bzero(rp, sizeof (struct cachefs_req));
2904 
2905 	mutex_init(&rp->cfs_req_lock, NULL, MUTEX_DEFAULT, NULL);
2906 	return (0);
2907 }
2908 
2909 /*ARGSUSED*/
2910 void
2911 cachefs_req_destroy(void *voidp, void *cdrarg)
2912 {
2913 	struct cachefs_req *rp = (struct cachefs_req *)voidp;
2914 
2915 	mutex_destroy(&rp->cfs_req_lock);
2916 }
2917