vfs_trans.c revision 1.27 
1/*	$NetBSD: vfs_trans.c,v 1.27 2013/09/30 18:58:00 hannken Exp $	*/
2
3/*-
4 * Copyright (c) 2007 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Juergen Hannken-Illjes.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33__KERNEL_RCSID(0, "$NetBSD: vfs_trans.c,v 1.27 2013/09/30 18:58:00 hannken Exp $");
34
35/*
36 * File system transaction operations.
37 */
38
39#include "opt_ddb.h"
40
41#include <sys/param.h>
42#include <sys/systm.h>
43#include <sys/atomic.h>
44#include <sys/buf.h>
45#include <sys/kmem.h>
46#include <sys/mount.h>
47#include <sys/pserialize.h>
48#include <sys/vnode.h>
49#define _FSTRANS_API_PRIVATE
50#include <sys/fstrans.h>
51#include <sys/proc.h>
52
53#include <miscfs/specfs/specdev.h>
54#include <miscfs/syncfs/syncfs.h>
55
56struct fscow_handler {
57	LIST_ENTRY(fscow_handler) ch_list;
58	int (*ch_func)(void *, struct buf *, bool);
59	void *ch_arg;
60};
61struct fstrans_lwp_info {
62	struct fstrans_lwp_info *fli_succ;
63	struct lwp *fli_self;
64	struct mount *fli_mount;
65	int fli_trans_cnt;
66	int fli_cow_cnt;
67	enum fstrans_lock_type fli_lock_type;
68	LIST_ENTRY(fstrans_lwp_info) fli_list;
69};
70struct fstrans_mount_info {
71	enum fstrans_state fmi_state;
72	unsigned int fmi_ref_cnt;
73	bool fmi_cow_change;
74	LIST_HEAD(, fscow_handler) fmi_cow_handler;
75};
76
77static specificdata_key_t lwp_data_key;	/* Our specific data key. */
78static kmutex_t vfs_suspend_lock;	/* Serialize suspensions. */
79static kmutex_t fstrans_lock;		/* Fstrans big lock. */
80static kcondvar_t fstrans_state_cv;	/* Fstrans or cow state changed. */
81static kcondvar_t fstrans_count_cv;	/* Fstrans or cow count changed. */
82static pserialize_t fstrans_psz;	/* Pserialize state. */
83static LIST_HEAD(fstrans_lwp_head, fstrans_lwp_info) fstrans_fli_head;
84					/* List of all fstrans_lwp_info. */
85static pool_cache_t fstrans_cache;	/* Pool of struct fstrans_lwp_info. */
86
87static void fstrans_lwp_dtor(void *);
88static void fstrans_mount_dtor(struct mount *);
89static struct fstrans_lwp_info *fstrans_get_lwp_info(struct mount *, bool);
90static bool grant_lock(const enum fstrans_state, const enum fstrans_lock_type);
91static bool state_change_done(const struct mount *);
92static bool cow_state_change_done(const struct mount *);
93static void cow_change_enter(const struct mount *);
94static void cow_change_done(const struct mount *);
95
96/*
97 * Initialize.
98 */
99void
100fstrans_init(void)
101{
102	int error;
103
104	error = lwp_specific_key_create(&lwp_data_key, fstrans_lwp_dtor);
105	KASSERT(error == 0);
106
107	mutex_init(&vfs_suspend_lock, MUTEX_DEFAULT, IPL_NONE);
108	mutex_init(&fstrans_lock, MUTEX_DEFAULT, IPL_NONE);
109	cv_init(&fstrans_state_cv, "fstchg");
110	cv_init(&fstrans_count_cv, "fstcnt");
111	fstrans_psz = pserialize_create();
112	LIST_INIT(&fstrans_fli_head);
113	fstrans_cache = pool_cache_init(sizeof(struct fstrans_lwp_info), 0, 0,
114	    0, "fstrans", NULL, IPL_NONE, NULL, NULL, NULL);
115}
116
117/*
118 * Deallocate lwp state.
119 */
120static void
121fstrans_lwp_dtor(void *arg)
122{
123	struct fstrans_lwp_info *fli, *fli_next;
124
125	mutex_enter(&fstrans_lock);
126	for (fli = arg; fli; fli = fli_next) {
127		KASSERT(fli->fli_trans_cnt == 0);
128		KASSERT(fli->fli_cow_cnt == 0);
129		if (fli->fli_mount != NULL)
130			fstrans_mount_dtor(fli->fli_mount);
131		fli_next = fli->fli_succ;
132		LIST_REMOVE(fli, fli_list);
133		pool_cache_put(fstrans_cache, fli);
134	}
135	mutex_exit(&fstrans_lock);
136}
137
138/*
139 * Dereference mount state.
140 */
141static void
142fstrans_mount_dtor(struct mount *mp)
143{
144	struct fstrans_mount_info *fmi;
145
146	fmi = mp->mnt_transinfo;
147	if (atomic_dec_uint_nv(&fmi->fmi_ref_cnt) > 0)
148		return;
149
150	KASSERT(fmi->fmi_state == FSTRANS_NORMAL);
151	KASSERT(LIST_FIRST(&fmi->fmi_cow_handler) == NULL);
152
153	kmem_free(fmi, sizeof(*fmi));
154	mp->mnt_iflag &= ~IMNT_HAS_TRANS;
155	mp->mnt_transinfo = NULL;
156
157	vfs_destroy(mp);
158}
159
160/*
161 * Allocate mount state.
162 */
163int
164fstrans_mount(struct mount *mp)
165{
166	int error;
167	struct fstrans_mount_info *new;
168
169	error = vfs_busy(mp, NULL);
170	if (error)
171		return error;
172	if ((new = kmem_alloc(sizeof(*new), KM_SLEEP)) == NULL)
173		return ENOMEM;
174	new->fmi_state = FSTRANS_NORMAL;
175	new->fmi_ref_cnt = 1;
176	LIST_INIT(&new->fmi_cow_handler);
177	new->fmi_cow_change = false;
178
179	mp->mnt_transinfo = new;
180	mp->mnt_iflag |= IMNT_HAS_TRANS;
181
182	vfs_unbusy(mp, true, NULL);
183
184	return 0;
185}
186
187/*
188 * Deallocate mount state.
189 */
190void
191fstrans_unmount(struct mount *mp)
192{
193
194	KASSERT(mp->mnt_transinfo != NULL);
195
196	fstrans_mount_dtor(mp);
197}
198
199/*
200 * Retrieve the per lwp info for this mount allocating if necessary.
201 */
202static struct fstrans_lwp_info *
203fstrans_get_lwp_info(struct mount *mp, bool do_alloc)
204{
205	struct fstrans_lwp_info *fli, *res;
206	struct fstrans_mount_info *fmi;
207
208	/*
209	 * Scan our list for a match clearing entries whose mount is gone.
210	 */
211	res = NULL;
212	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ) {
213		if (fli->fli_mount == mp) {
214			KASSERT(res == NULL);
215			res = fli;
216		} else if (fli->fli_mount != NULL &&
217		    (fli->fli_mount->mnt_iflag & IMNT_GONE) != 0 &&
218		    fli->fli_trans_cnt == 0 && fli->fli_cow_cnt == 0) {
219			fstrans_mount_dtor(fli->fli_mount);
220			fli->fli_mount = NULL;
221		}
222	}
223	if (__predict_true(res != NULL))
224		return res;
225
226	if (! do_alloc)
227		return NULL;
228
229	/*
230	 * Try to reuse a cleared entry or allocate a new one.
231	 */
232	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ) {
233		if (fli->fli_mount == NULL) {
234			KASSERT(fli->fli_trans_cnt == 0);
235			KASSERT(fli->fli_cow_cnt == 0);
236			break;
237		}
238	}
239	if (fli == NULL) {
240		fli = pool_cache_get(fstrans_cache, PR_WAITOK);
241		mutex_enter(&fstrans_lock);
242		memset(fli, 0, sizeof(*fli));
243		fli->fli_self = curlwp;
244		LIST_INSERT_HEAD(&fstrans_fli_head, fli, fli_list);
245		mutex_exit(&fstrans_lock);
246		fli->fli_succ = lwp_getspecific(lwp_data_key);
247		lwp_setspecific(lwp_data_key, fli);
248	}
249
250	/*
251	 * Attach the entry to the mount.
252	 */
253	fmi = mp->mnt_transinfo;
254	fli->fli_mount = mp;
255	atomic_inc_uint(&fmi->fmi_ref_cnt);
256
257	return fli;
258}
259
260/*
261 * Check if this lock type is granted at this state.
262 */
263static bool
264grant_lock(const enum fstrans_state state, const enum fstrans_lock_type type)
265{
266
267	if (__predict_true(state == FSTRANS_NORMAL))
268		return true;
269	if (type == FSTRANS_EXCL)
270		return true;
271	if  (state == FSTRANS_SUSPENDING && type == FSTRANS_LAZY)
272		return true;
273
274	return false;
275}
276
277/*
278 * Start a transaction.  If this thread already has a transaction on this
279 * file system increment the reference counter.
280 */
281int
282_fstrans_start(struct mount *mp, enum fstrans_lock_type lock_type, int wait)
283{
284	int s;
285	struct fstrans_lwp_info *fli;
286	struct fstrans_mount_info *fmi;
287
288	ASSERT_SLEEPABLE();
289
290	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
291		return 0;
292
293	fli = fstrans_get_lwp_info(mp, true);
294
295	if (fli->fli_trans_cnt > 0) {
296		KASSERT(lock_type != FSTRANS_EXCL);
297		fli->fli_trans_cnt += 1;
298
299		return 0;
300	}
301
302	s = pserialize_read_enter();
303	fmi = mp->mnt_transinfo;
304	if (__predict_true(grant_lock(fmi->fmi_state, lock_type))) {
305		fli->fli_trans_cnt = 1;
306		fli->fli_lock_type = lock_type;
307		pserialize_read_exit(s);
308
309		return 0;
310	}
311	pserialize_read_exit(s);
312
313	if (! wait)
314		return EBUSY;
315
316	mutex_enter(&fstrans_lock);
317	while (! grant_lock(fmi->fmi_state, lock_type))
318		cv_wait(&fstrans_state_cv, &fstrans_lock);
319	fli->fli_trans_cnt = 1;
320	fli->fli_lock_type = lock_type;
321	mutex_exit(&fstrans_lock);
322
323	return 0;
324}
325
326/*
327 * Finish a transaction.
328 */
329void
330fstrans_done(struct mount *mp)
331{
332	int s;
333	struct fstrans_lwp_info *fli;
334	struct fstrans_mount_info *fmi;
335
336	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
337		return;
338
339	fli = fstrans_get_lwp_info(mp, false);
340	KASSERT(fli != NULL);
341	KASSERT(fli->fli_trans_cnt > 0);
342
343	if (fli->fli_trans_cnt > 1) {
344		fli->fli_trans_cnt -= 1;
345
346		return;
347	}
348
349	s = pserialize_read_enter();
350	fmi = mp->mnt_transinfo;
351	if (__predict_true(fmi->fmi_state == FSTRANS_NORMAL)) {
352		fli->fli_trans_cnt = 0;
353		pserialize_read_exit(s);
354
355		return;
356	}
357	pserialize_read_exit(s);
358
359	mutex_enter(&fstrans_lock);
360	fli->fli_trans_cnt = 0;
361	cv_signal(&fstrans_count_cv);
362	mutex_exit(&fstrans_lock);
363}
364
365/*
366 * Check if this thread has an exclusive lock.
367 */
368int
369fstrans_is_owner(struct mount *mp)
370{
371	struct fstrans_lwp_info *fli;
372
373	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
374		return 0;
375
376	fli = fstrans_get_lwp_info(mp, false);
377	if (fli == NULL || fli->fli_trans_cnt == 0)
378		return 0;
379
380	KASSERT(fli->fli_mount == mp);
381	KASSERT(fli->fli_trans_cnt > 0);
382
383	return (fli->fli_lock_type == FSTRANS_EXCL);
384}
385
386/*
387 * True, if no thread is in a transaction not granted at the current state.
388 */
389static bool
390state_change_done(const struct mount *mp)
391{
392	struct fstrans_lwp_info *fli;
393	struct fstrans_mount_info *fmi;
394
395	KASSERT(mutex_owned(&fstrans_lock));
396
397	fmi = mp->mnt_transinfo;
398	LIST_FOREACH(fli, &fstrans_fli_head, fli_list) {
399		if (fli->fli_mount != mp)
400			continue;
401		if (fli->fli_trans_cnt == 0)
402			continue;
403		if (grant_lock(fmi->fmi_state, fli->fli_lock_type))
404			continue;
405
406		return false;
407	}
408
409	return true;
410}
411
412/*
413 * Set new file system state.
414 */
415int
416fstrans_setstate(struct mount *mp, enum fstrans_state new_state)
417{
418	int error;
419	enum fstrans_state old_state;
420	struct fstrans_mount_info *fmi;
421
422	fmi = mp->mnt_transinfo;
423	old_state = fmi->fmi_state;
424	if (old_state == new_state)
425		return 0;
426
427	mutex_enter(&fstrans_lock);
428	fmi->fmi_state = new_state;
429	pserialize_perform(fstrans_psz);
430
431	/*
432	 * All threads see the new state now.
433	 * Wait for transactions invalid at this state to leave.
434	 */
435	error = 0;
436	while (! state_change_done(mp)) {
437		error = cv_wait_sig(&fstrans_count_cv, &fstrans_lock);
438		if (error) {
439			new_state = fmi->fmi_state = FSTRANS_NORMAL;
440			break;
441		}
442	}
443	cv_broadcast(&fstrans_state_cv);
444	mutex_exit(&fstrans_lock);
445
446	if (old_state != new_state) {
447		if (old_state == FSTRANS_NORMAL)
448			fstrans_start(mp, FSTRANS_EXCL);
449		if (new_state == FSTRANS_NORMAL)
450			fstrans_done(mp);
451	}
452
453	return error;
454}
455
456/*
457 * Get current file system state.
458 */
459enum fstrans_state
460fstrans_getstate(struct mount *mp)
461{
462	struct fstrans_mount_info *fmi;
463
464	fmi = mp->mnt_transinfo;
465	KASSERT(fmi != NULL);
466
467	return fmi->fmi_state;
468}
469
470/*
471 * Request a filesystem to suspend all operations.
472 */
473int
474vfs_suspend(struct mount *mp, int nowait)
475{
476	int error;
477
478	if (nowait) {
479		if (!mutex_tryenter(&vfs_suspend_lock))
480			return EWOULDBLOCK;
481	} else
482		mutex_enter(&vfs_suspend_lock);
483
484	mutex_enter(&syncer_mutex);
485	if ((error = VFS_SUSPENDCTL(mp, SUSPEND_SUSPEND)) != 0) {
486		mutex_exit(&syncer_mutex);
487		mutex_exit(&vfs_suspend_lock);
488	}
489
490	return error;
491}
492
493/*
494 * Request a filesystem to resume all operations.
495 */
496void
497vfs_resume(struct mount *mp)
498{
499
500	VFS_SUSPENDCTL(mp, SUSPEND_RESUME);
501	mutex_exit(&syncer_mutex);
502	mutex_exit(&vfs_suspend_lock);
503}
504
505
506/*
507 * True, if no thread is running a cow handler.
508 */
509static bool
510cow_state_change_done(const struct mount *mp)
511{
512	struct fstrans_lwp_info *fli;
513	struct fstrans_mount_info *fmi;
514
515	fmi = mp->mnt_transinfo;
516
517	KASSERT(mutex_owned(&fstrans_lock));
518	KASSERT(fmi->fmi_cow_change);
519
520	LIST_FOREACH(fli, &fstrans_fli_head, fli_list) {
521		if (fli->fli_mount != mp)
522			continue;
523		if (fli->fli_cow_cnt == 0)
524			continue;
525
526		return false;
527	}
528
529	return true;
530}
531
532/*
533 * Prepare for changing this mounts cow list.
534 * Returns with fstrans_lock locked.
535 */
536static void
537cow_change_enter(const struct mount *mp)
538{
539	struct fstrans_mount_info *fmi;
540
541	fmi = mp->mnt_transinfo;
542
543	mutex_enter(&fstrans_lock);
544
545	/*
546	 * Wait for other threads changing the list.
547	 */
548	while (fmi->fmi_cow_change)
549		cv_wait(&fstrans_state_cv, &fstrans_lock);
550
551	/*
552	 * Wait until all threads are aware of a state change.
553	 */
554	fmi->fmi_cow_change = true;
555	pserialize_perform(fstrans_psz);
556
557	while (! cow_state_change_done(mp))
558		cv_wait(&fstrans_count_cv, &fstrans_lock);
559}
560
561/*
562 * Done changing this mounts cow list.
563 */
564static void
565cow_change_done(const struct mount *mp)
566{
567	struct fstrans_mount_info *fmi;
568
569	KASSERT(mutex_owned(&fstrans_lock));
570
571	fmi = mp->mnt_transinfo;
572
573	fmi->fmi_cow_change = false;
574	pserialize_perform(fstrans_psz);
575
576	cv_broadcast(&fstrans_state_cv);
577
578	mutex_exit(&fstrans_lock);
579}
580
581/*
582 * Add a handler to this mount.
583 */
584int
585fscow_establish(struct mount *mp, int (*func)(void *, struct buf *, bool),
586    void *arg)
587{
588	struct fstrans_mount_info *fmi;
589	struct fscow_handler *new;
590
591	if ((mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
592		return EINVAL;
593
594	fmi = mp->mnt_transinfo;
595	KASSERT(fmi != NULL);
596
597	if ((new = kmem_alloc(sizeof(*new), KM_SLEEP)) == NULL)
598		return ENOMEM;
599	new->ch_func = func;
600	new->ch_arg = arg;
601
602	cow_change_enter(mp);
603	LIST_INSERT_HEAD(&fmi->fmi_cow_handler, new, ch_list);
604	cow_change_done(mp);
605
606	return 0;
607}
608
609/*
610 * Remove a handler from this mount.
611 */
612int
613fscow_disestablish(struct mount *mp, int (*func)(void *, struct buf *, bool),
614    void *arg)
615{
616	struct fstrans_mount_info *fmi;
617	struct fscow_handler *hp = NULL;
618
619	if ((mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
620		return EINVAL;
621
622	fmi = mp->mnt_transinfo;
623	KASSERT(fmi != NULL);
624
625	cow_change_enter(mp);
626	LIST_FOREACH(hp, &fmi->fmi_cow_handler, ch_list)
627		if (hp->ch_func == func && hp->ch_arg == arg)
628			break;
629	if (hp != NULL) {
630		LIST_REMOVE(hp, ch_list);
631		kmem_free(hp, sizeof(*hp));
632	}
633	cow_change_done(mp);
634
635	return hp ? 0 : EINVAL;
636}
637
638/*
639 * Check for need to copy block that is about to be written.
640 */
641int
642fscow_run(struct buf *bp, bool data_valid)
643{
644	int error, s;
645	struct mount *mp;
646	struct fstrans_lwp_info *fli;
647	struct fstrans_mount_info *fmi;
648	struct fscow_handler *hp;
649
650	/*
651	 * First check if we need run the copy-on-write handler.
652	 */
653	if ((bp->b_flags & B_COWDONE))
654		return 0;
655	if (bp->b_vp == NULL) {
656		bp->b_flags |= B_COWDONE;
657		return 0;
658	}
659	if (bp->b_vp->v_type == VBLK)
660		mp = spec_node_getmountedfs(bp->b_vp);
661	else
662		mp = bp->b_vp->v_mount;
663	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0) {
664		bp->b_flags |= B_COWDONE;
665		return 0;
666	}
667
668	fli = fstrans_get_lwp_info(mp, true);
669	fmi = mp->mnt_transinfo;
670
671	/*
672	 * On non-recursed run check if other threads
673	 * want to change the list.
674	 */
675	if (fli->fli_cow_cnt == 0) {
676		s = pserialize_read_enter();
677		if (__predict_false(fmi->fmi_cow_change)) {
678			pserialize_read_exit(s);
679			mutex_enter(&fstrans_lock);
680			while (fmi->fmi_cow_change)
681				cv_wait(&fstrans_state_cv, &fstrans_lock);
682			fli->fli_cow_cnt = 1;
683			mutex_exit(&fstrans_lock);
684		} else {
685			fli->fli_cow_cnt = 1;
686			pserialize_read_exit(s);
687		}
688	} else
689		fli->fli_cow_cnt += 1;
690
691	/*
692	 * Run all copy-on-write handlers, stop on error.
693	 */
694	error = 0;
695	LIST_FOREACH(hp, &fmi->fmi_cow_handler, ch_list)
696		if ((error = (*hp->ch_func)(hp->ch_arg, bp, data_valid)) != 0)
697			break;
698 	if (error == 0)
699 		bp->b_flags |= B_COWDONE;
700
701	/*
702	 * Check if other threads want to change the list.
703	 */
704	if (fli->fli_cow_cnt > 1) {
705		fli->fli_cow_cnt -= 1;
706	} else {
707		s = pserialize_read_enter();
708		if (__predict_false(fmi->fmi_cow_change)) {
709			pserialize_read_exit(s);
710			mutex_enter(&fstrans_lock);
711			fli->fli_cow_cnt = 0;
712			cv_signal(&fstrans_count_cv);
713			mutex_exit(&fstrans_lock);
714		} else {
715			fli->fli_cow_cnt = 0;
716			pserialize_read_exit(s);
717		}
718	}
719
720	return error;
721}
722
723#if defined(DDB)
724void fstrans_dump(int);
725
726static void
727fstrans_print_lwp(struct proc *p, struct lwp *l, int verbose)
728{
729	char prefix[9];
730	struct fstrans_lwp_info *fli;
731
732	snprintf(prefix, sizeof(prefix), "%d.%d", p->p_pid, l->l_lid);
733	LIST_FOREACH(fli, &fstrans_fli_head, fli_list) {
734		if (fli->fli_self != l)
735			continue;
736		if (fli->fli_trans_cnt == 0 && fli->fli_cow_cnt == 0) {
737			if (! verbose)
738				continue;
739		}
740		printf("%-8s", prefix);
741		if (verbose)
742			printf(" @%p", fli);
743		if (fli->fli_mount != NULL)
744			printf(" (%s)", fli->fli_mount->mnt_stat.f_mntonname);
745		else
746			printf(" NULL");
747		if (fli->fli_trans_cnt == 0) {
748			printf(" -");
749		} else {
750			switch (fli->fli_lock_type) {
751			case FSTRANS_LAZY:
752				printf(" lazy");
753				break;
754			case FSTRANS_SHARED:
755				printf(" shared");
756				break;
757			case FSTRANS_EXCL:
758				printf(" excl");
759				break;
760			default:
761				printf(" %#x", fli->fli_lock_type);
762				break;
763			}
764		}
765		printf(" %d cow %d\n", fli->fli_trans_cnt, fli->fli_cow_cnt);
766		prefix[0] = '\0';
767	}
768}
769
770static void
771fstrans_print_mount(struct mount *mp, int verbose)
772{
773	struct fstrans_mount_info *fmi;
774
775	fmi = mp->mnt_transinfo;
776	if (!verbose && (fmi == NULL || fmi->fmi_state == FSTRANS_NORMAL))
777		return;
778
779	printf("%-16s ", mp->mnt_stat.f_mntonname);
780	if (fmi == NULL) {
781		printf("(null)\n");
782		return;
783	}
784	switch (fmi->fmi_state) {
785	case FSTRANS_NORMAL:
786		printf("state normal\n");
787		break;
788	case FSTRANS_SUSPENDING:
789		printf("state suspending\n");
790		break;
791	case FSTRANS_SUSPENDED:
792		printf("state suspended\n");
793		break;
794	default:
795		printf("state %#x\n", fmi->fmi_state);
796		break;
797	}
798}
799
800void
801fstrans_dump(int full)
802{
803	const struct proclist_desc *pd;
804	struct proc *p;
805	struct lwp *l;
806	struct mount *mp;
807
808	printf("Fstrans locks by lwp:\n");
809	for (pd = proclists; pd->pd_list != NULL; pd++)
810		PROCLIST_FOREACH(p, pd->pd_list)
811			LIST_FOREACH(l, &p->p_lwps, l_sibling)
812				fstrans_print_lwp(p, l, full == 1);
813
814	printf("Fstrans state by mount:\n");
815	CIRCLEQ_FOREACH(mp, &mountlist, mnt_list)
816		fstrans_print_mount(mp, full == 1);
817}
818#endif /* defined(DDB) */
819