Home | History | Annotate | Line # | Download | only in kern
vfs_trans.c revision 1.18
      1  1.18     yamt /*	$NetBSD: vfs_trans.c,v 1.18 2008/03/17 08:27:50 yamt Exp $	*/
      2   1.1  hannken 
      3   1.1  hannken /*-
      4   1.1  hannken  * Copyright (c) 2007 The NetBSD Foundation, Inc.
      5   1.1  hannken  * All rights reserved.
      6   1.1  hannken  *
      7   1.1  hannken  * This code is derived from software contributed to The NetBSD Foundation
      8   1.1  hannken  * by Juergen Hannken-Illjes.
      9   1.1  hannken  *
     10   1.1  hannken  * Redistribution and use in source and binary forms, with or without
     11   1.1  hannken  * modification, are permitted provided that the following conditions
     12   1.1  hannken  * are met:
     13   1.1  hannken  * 1. Redistributions of source code must retain the above copyright
     14   1.1  hannken  *    notice, this list of conditions and the following disclaimer.
     15   1.1  hannken  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1  hannken  *    notice, this list of conditions and the following disclaimer in the
     17   1.1  hannken  *    documentation and/or other materials provided with the distribution.
     18   1.1  hannken  * 3. All advertising materials mentioning features or use of this software
     19   1.1  hannken  *    must display the following acknowledgement:
     20   1.1  hannken  *	This product includes software developed by the NetBSD
     21   1.1  hannken  *	Foundation, Inc. and its contributors.
     22   1.1  hannken  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23   1.1  hannken  *    contributors may be used to endorse or promote products derived
     24   1.1  hannken  *    from this software without specific prior written permission.
     25   1.1  hannken  *
     26   1.1  hannken  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27   1.1  hannken  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28   1.1  hannken  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29   1.1  hannken  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30   1.1  hannken  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31   1.1  hannken  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32   1.1  hannken  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33   1.1  hannken  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34   1.1  hannken  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35   1.1  hannken  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36   1.1  hannken  * POSSIBILITY OF SUCH DAMAGE.
     37   1.1  hannken  */
     38   1.1  hannken 
     39   1.1  hannken #include <sys/cdefs.h>
     40  1.18     yamt __KERNEL_RCSID(0, "$NetBSD: vfs_trans.c,v 1.18 2008/03/17 08:27:50 yamt Exp $");
     41   1.1  hannken 
     42   1.1  hannken /*
     43   1.1  hannken  * File system transaction operations.
     44   1.1  hannken  */
     45   1.1  hannken 
     46   1.1  hannken #include "opt_ddb.h"
     47   1.1  hannken 
     48   1.1  hannken #if defined(DDB)
     49   1.1  hannken #define _LWP_API_PRIVATE	/* Need _lwp_getspecific_by_lwp() */
     50   1.1  hannken #endif
     51   1.1  hannken 
     52   1.1  hannken #include <sys/param.h>
     53   1.1  hannken #include <sys/systm.h>
     54  1.12  hannken #include <sys/kmem.h>
     55   1.1  hannken #include <sys/mount.h>
     56   1.8  hannken #include <sys/rwlock.h>
     57   1.1  hannken #include <sys/vnode.h>
     58   1.1  hannken #define _FSTRANS_API_PRIVATE
     59   1.1  hannken #include <sys/fstrans.h>
     60  1.10       ad #include <sys/proc.h>
     61   1.1  hannken 
     62  1.12  hannken #include <miscfs/specfs/specdev.h>
     63   1.1  hannken #include <miscfs/syncfs/syncfs.h>
     64   1.1  hannken 
     65  1.16       ad struct fscow_handler {
     66  1.16       ad 	SLIST_ENTRY(fscow_handler) ch_list;
     67  1.16       ad 	int (*ch_func)(void *, struct buf *, bool);
     68  1.16       ad 	void *ch_arg;
     69  1.16       ad };
     70   1.1  hannken struct fstrans_lwp_info {
     71   1.1  hannken 	struct fstrans_lwp_info *fli_succ;
     72   1.1  hannken 	struct mount *fli_mount;
     73   1.1  hannken 	int fli_count;
     74   1.1  hannken 	enum fstrans_lock_type fli_lock_type;
     75   1.1  hannken };
     76   1.1  hannken struct fstrans_mount_info {
     77   1.1  hannken 	enum fstrans_state fmi_state;
     78   1.8  hannken 	krwlock_t fmi_shared_lock;
     79   1.8  hannken 	krwlock_t fmi_lazy_lock;
     80  1.16       ad 	krwlock_t fmi_cow_lock;
     81  1.16       ad 	SLIST_HEAD(, fscow_handler) fmi_cow_handler;
     82   1.1  hannken };
     83   1.1  hannken 
     84   1.1  hannken static specificdata_key_t lwp_data_key;
     85   1.4       ad static kmutex_t vfs_suspend_lock;	/* Serialize suspensions. */
     86   1.1  hannken 
     87   1.1  hannken POOL_INIT(fstrans_pl, sizeof(struct fstrans_lwp_info), 0, 0, 0,
     88   1.6       ad     "fstrans", NULL, IPL_NONE);
     89   1.1  hannken 
     90   1.1  hannken static void fstrans_lwp_dtor(void *);
     91   1.1  hannken 
     92   1.1  hannken /*
     93   1.1  hannken  * Initialize
     94   1.1  hannken  */
     95   1.1  hannken void
     96   1.1  hannken fstrans_init(void)
     97   1.1  hannken {
     98   1.1  hannken 	int error;
     99   1.1  hannken 
    100   1.1  hannken 	error = lwp_specific_key_create(&lwp_data_key, fstrans_lwp_dtor);
    101   1.1  hannken 	KASSERT(error == 0);
    102   1.7       ad 
    103   1.4       ad 	mutex_init(&vfs_suspend_lock, MUTEX_DEFAULT, IPL_NONE);
    104   1.1  hannken }
    105   1.1  hannken 
    106   1.1  hannken /*
    107   1.1  hannken  * Deallocate lwp state
    108   1.1  hannken  */
    109   1.1  hannken static void
    110   1.1  hannken fstrans_lwp_dtor(void *arg)
    111   1.1  hannken {
    112   1.1  hannken 	struct fstrans_lwp_info *fli, *fli_next;
    113   1.1  hannken 
    114   1.1  hannken 	for (fli = arg; fli; fli = fli_next) {
    115   1.1  hannken 		KASSERT(fli->fli_mount == NULL);
    116   1.1  hannken 		KASSERT(fli->fli_count == 0);
    117   1.1  hannken 		fli_next = fli->fli_succ;
    118   1.1  hannken 		pool_put(&fstrans_pl, fli);
    119   1.1  hannken 	}
    120   1.1  hannken }
    121   1.1  hannken 
    122   1.1  hannken /*
    123  1.16       ad  * Allocate mount state
    124   1.1  hannken  */
    125  1.16       ad int
    126  1.16       ad fstrans_mount(struct mount *mp)
    127   1.1  hannken {
    128  1.16       ad 	struct fstrans_mount_info *new;
    129  1.16       ad 
    130  1.16       ad 	if ((new = kmem_alloc(sizeof(*new), KM_SLEEP)) == NULL)
    131  1.16       ad 		return ENOMEM;
    132  1.16       ad 	new->fmi_state = FSTRANS_NORMAL;
    133  1.16       ad 	rw_init(&new->fmi_lazy_lock);
    134  1.16       ad 	rw_init(&new->fmi_shared_lock);
    135  1.16       ad 	SLIST_INIT(&new->fmi_cow_handler);
    136  1.16       ad 	rw_init(&new->fmi_cow_lock);
    137  1.16       ad 
    138  1.16       ad 	mp->mnt_transinfo = new;
    139  1.16       ad 	mp->mnt_iflag |= IMNT_HAS_TRANS;
    140   1.1  hannken 
    141  1.16       ad 	return 0;
    142   1.1  hannken }
    143   1.1  hannken 
    144   1.1  hannken /*
    145  1.16       ad  * Deallocate mount state
    146   1.1  hannken  */
    147  1.16       ad void
    148  1.16       ad fstrans_unmount(struct mount *mp)
    149   1.1  hannken {
    150  1.16       ad 	struct fstrans_mount_info *fmi;
    151   1.1  hannken 
    152  1.16       ad 	if ((fmi = mp->mnt_transinfo) == NULL)
    153  1.16       ad 		return;
    154   1.1  hannken 
    155  1.16       ad 	KASSERT(fmi->fmi_state == FSTRANS_NORMAL);
    156  1.16       ad 	rw_destroy(&fmi->fmi_lazy_lock);
    157  1.16       ad 	rw_destroy(&fmi->fmi_shared_lock);
    158  1.16       ad 	KASSERT(SLIST_EMPTY(&fmi->fmi_cow_handler));
    159  1.16       ad 	rw_destroy(&fmi->fmi_cow_lock);
    160  1.16       ad 	kmem_free(fmi, sizeof(*fmi));
    161  1.16       ad 	mp->mnt_iflag &= ~IMNT_HAS_TRANS;
    162  1.16       ad 	mp->mnt_transinfo = NULL;
    163   1.1  hannken }
    164   1.1  hannken 
    165   1.1  hannken /*
    166   1.1  hannken  * Start a transaction.  If this thread already has a transaction on this
    167   1.1  hannken  * file system increment the reference counter.
    168   1.1  hannken  * A thread with an exclusive transaction lock may get a shared or lazy one.
    169   1.1  hannken  * A thread with a shared or lazy transaction lock cannot upgrade to an
    170   1.1  hannken  * exclusive one yet.
    171   1.1  hannken  */
    172   1.1  hannken int
    173   1.1  hannken _fstrans_start(struct mount *mp, enum fstrans_lock_type lock_type, int wait)
    174   1.1  hannken {
    175   1.8  hannken 	krwlock_t *lock_p;
    176   1.8  hannken 	krw_t lock_op;
    177   1.1  hannken 	struct fstrans_lwp_info *fli, *new_fli;
    178   1.1  hannken 	struct fstrans_mount_info *fmi;
    179   1.1  hannken 
    180  1.18     yamt 	ASSERT_SLEEPABLE();
    181   1.1  hannken 
    182   1.1  hannken 	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    183   1.1  hannken 		return 0;
    184   1.1  hannken 
    185   1.1  hannken 	new_fli = NULL;
    186   1.1  hannken 	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ) {
    187   1.1  hannken 		if (fli->fli_mount == NULL && new_fli == NULL)
    188   1.1  hannken 			new_fli = fli;
    189   1.1  hannken 		if (fli->fli_mount == mp) {
    190   1.1  hannken 			KASSERT(fli->fli_count > 0);
    191   1.2  hannken 			if (fli->fli_lock_type != FSTRANS_EXCL &&
    192   1.2  hannken 			    lock_type == FSTRANS_EXCL)
    193   1.1  hannken 				panic("fstrans_start: cannot upgrade lock");
    194   1.1  hannken 			fli->fli_count += 1;
    195   1.1  hannken 			return 0;
    196   1.1  hannken 		}
    197   1.1  hannken 	}
    198   1.1  hannken 
    199   1.1  hannken 	if (new_fli == NULL) {
    200   1.1  hannken 		new_fli = pool_get(&fstrans_pl, PR_WAITOK);
    201   1.1  hannken 		new_fli->fli_mount = NULL;
    202   1.1  hannken 		new_fli->fli_count = 0;
    203   1.1  hannken 		new_fli->fli_succ = lwp_getspecific(lwp_data_key);
    204   1.1  hannken 		lwp_setspecific(lwp_data_key, new_fli);
    205   1.1  hannken 	}
    206   1.1  hannken 
    207   1.1  hannken 	KASSERT(new_fli->fli_mount == NULL);
    208   1.1  hannken 	KASSERT(new_fli->fli_count == 0);
    209   1.1  hannken 
    210  1.16       ad 	fmi = mp->mnt_transinfo;
    211   1.1  hannken 
    212   1.2  hannken 	if (lock_type == FSTRANS_LAZY)
    213   1.8  hannken 		lock_p = &fmi->fmi_lazy_lock;
    214   1.1  hannken 	else
    215   1.8  hannken 		lock_p = &fmi->fmi_shared_lock;
    216   1.8  hannken 	lock_op = (lock_type == FSTRANS_EXCL ? RW_WRITER : RW_READER);
    217   1.8  hannken 
    218   1.8  hannken 	if (wait)
    219   1.8  hannken 		rw_enter(lock_p, lock_op);
    220   1.8  hannken 	else if (rw_tryenter(lock_p, lock_op) == 0)
    221   1.8  hannken 		return EBUSY;
    222   1.1  hannken 
    223   1.1  hannken 	new_fli->fli_mount = mp;
    224   1.1  hannken 	new_fli->fli_count = 1;
    225   1.1  hannken 	new_fli->fli_lock_type = lock_type;
    226   1.1  hannken 
    227   1.1  hannken 	return 0;
    228   1.1  hannken }
    229   1.1  hannken 
    230   1.1  hannken /*
    231   1.1  hannken  * Finish a transaction.
    232   1.1  hannken  */
    233   1.1  hannken void
    234   1.1  hannken fstrans_done(struct mount *mp)
    235   1.1  hannken {
    236   1.1  hannken 	struct fstrans_lwp_info *fli;
    237   1.1  hannken 	struct fstrans_mount_info *fmi;
    238   1.1  hannken 
    239   1.1  hannken 	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    240   1.1  hannken 		return;
    241   1.1  hannken 
    242   1.1  hannken 	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ) {
    243   1.1  hannken 		if (fli->fli_mount == mp) {
    244   1.1  hannken 			fli->fli_count -= 1;
    245   1.1  hannken 			if (fli->fli_count > 0)
    246   1.1  hannken 				return;
    247   1.1  hannken 			break;
    248   1.1  hannken 		}
    249   1.1  hannken 	}
    250   1.1  hannken 
    251   1.1  hannken 	KASSERT(fli != NULL);
    252   1.1  hannken 	KASSERT(fli->fli_mount == mp);
    253   1.1  hannken 	KASSERT(fli->fli_count == 0);
    254   1.1  hannken 	fli->fli_mount = NULL;
    255  1.16       ad 	fmi = mp->mnt_transinfo;
    256   1.1  hannken 	KASSERT(fmi != NULL);
    257   1.2  hannken 	if (fli->fli_lock_type == FSTRANS_LAZY)
    258   1.8  hannken 		rw_exit(&fmi->fmi_lazy_lock);
    259   1.1  hannken 	else
    260   1.8  hannken 		rw_exit(&fmi->fmi_shared_lock);
    261   1.1  hannken }
    262   1.1  hannken 
    263   1.1  hannken /*
    264   1.1  hannken  * Check if this thread has an exclusive lock.
    265   1.1  hannken  */
    266   1.1  hannken int
    267   1.1  hannken fstrans_is_owner(struct mount *mp)
    268   1.1  hannken {
    269   1.1  hannken 	struct fstrans_lwp_info *fli;
    270   1.1  hannken 
    271   1.1  hannken 	if (mp == NULL)
    272   1.1  hannken 		return 0;
    273   1.1  hannken 	if ((mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    274   1.1  hannken 		return 0;
    275   1.1  hannken 
    276   1.1  hannken 	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ)
    277   1.1  hannken 		if (fli->fli_mount == mp)
    278   1.1  hannken 			break;
    279   1.1  hannken 
    280   1.1  hannken 	if (fli == NULL)
    281   1.1  hannken 		return 0;
    282   1.1  hannken 
    283   1.1  hannken 	KASSERT(fli->fli_mount == mp);
    284   1.1  hannken 	KASSERT(fli->fli_count > 0);
    285   1.2  hannken 	return (fli->fli_lock_type == FSTRANS_EXCL);
    286   1.1  hannken }
    287   1.1  hannken 
    288   1.1  hannken /*
    289   1.1  hannken  * Set new file system state.
    290   1.1  hannken  */
    291   1.1  hannken int
    292   1.1  hannken fstrans_setstate(struct mount *mp, enum fstrans_state new_state)
    293   1.1  hannken {
    294   1.1  hannken 	struct fstrans_mount_info *fmi;
    295   1.1  hannken 
    296  1.16       ad 	fmi = mp->mnt_transinfo;
    297   1.1  hannken 
    298   1.1  hannken 	switch (new_state) {
    299   1.2  hannken 	case FSTRANS_SUSPENDING:
    300   1.2  hannken 		KASSERT(fmi->fmi_state == FSTRANS_NORMAL);
    301   1.9  hannken 		fstrans_start(mp, FSTRANS_EXCL);
    302   1.2  hannken 		fmi->fmi_state = FSTRANS_SUSPENDING;
    303   1.1  hannken 		break;
    304   1.1  hannken 
    305   1.2  hannken 	case FSTRANS_SUSPENDED:
    306   1.2  hannken 		KASSERT(fmi->fmi_state == FSTRANS_NORMAL ||
    307   1.2  hannken 			fmi->fmi_state == FSTRANS_SUSPENDING);
    308   1.2  hannken 		KASSERT(fmi->fmi_state == FSTRANS_NORMAL ||
    309   1.1  hannken 			fstrans_is_owner(mp));
    310   1.9  hannken 		if (fmi->fmi_state == FSTRANS_NORMAL)
    311   1.9  hannken 			fstrans_start(mp, FSTRANS_EXCL);
    312   1.8  hannken 		rw_enter(&fmi->fmi_lazy_lock, RW_WRITER);
    313   1.2  hannken 		fmi->fmi_state = FSTRANS_SUSPENDED;
    314   1.1  hannken 		break;
    315   1.1  hannken 
    316   1.2  hannken 	case FSTRANS_NORMAL:
    317   1.2  hannken 		KASSERT(fmi->fmi_state == FSTRANS_NORMAL ||
    318   1.1  hannken 			fstrans_is_owner(mp));
    319   1.2  hannken 		if (fmi->fmi_state == FSTRANS_SUSPENDED)
    320   1.8  hannken 			rw_exit(&fmi->fmi_lazy_lock);
    321   1.2  hannken 		if (fmi->fmi_state == FSTRANS_SUSPENDING ||
    322   1.2  hannken 		    fmi->fmi_state == FSTRANS_SUSPENDED) {
    323   1.2  hannken 			fmi->fmi_state = FSTRANS_NORMAL;
    324   1.1  hannken 			fstrans_done(mp);
    325   1.1  hannken 		}
    326   1.1  hannken 		break;
    327   1.1  hannken 
    328   1.1  hannken 	default:
    329   1.1  hannken 		panic("%s: illegal state %d", __func__, new_state);
    330   1.1  hannken 	}
    331   1.1  hannken 
    332   1.1  hannken 	return 0;
    333   1.1  hannken }
    334   1.1  hannken 
    335   1.1  hannken /*
    336   1.1  hannken  * Get current file system state
    337   1.1  hannken  */
    338   1.1  hannken enum fstrans_state
    339   1.1  hannken fstrans_getstate(struct mount *mp)
    340   1.1  hannken {
    341   1.1  hannken 	struct fstrans_mount_info *fmi;
    342   1.1  hannken 
    343  1.16       ad 	fmi = mp->mnt_transinfo;
    344   1.1  hannken 
    345   1.1  hannken 	return fmi->fmi_state;
    346   1.1  hannken }
    347   1.1  hannken 
    348   1.1  hannken /*
    349   1.1  hannken  * Request a filesystem to suspend all operations.
    350   1.1  hannken  */
    351   1.1  hannken int
    352   1.1  hannken vfs_suspend(struct mount *mp, int nowait)
    353   1.1  hannken {
    354   1.4       ad 	int error;
    355   1.1  hannken 
    356   1.4       ad 	if (nowait) {
    357   1.4       ad 		if (!mutex_tryenter(&vfs_suspend_lock))
    358   1.4       ad 			return EWOULDBLOCK;
    359   1.4       ad 	} else
    360   1.4       ad 		mutex_enter(&vfs_suspend_lock);
    361   1.1  hannken 
    362   1.3  hannken 	mutex_enter(&syncer_mutex);
    363   1.1  hannken 
    364   1.1  hannken 	if ((error = VFS_SUSPENDCTL(mp, SUSPEND_SUSPEND)) != 0) {
    365   1.3  hannken 		mutex_exit(&syncer_mutex);
    366   1.4       ad 		mutex_exit(&vfs_suspend_lock);
    367   1.1  hannken 	}
    368   1.1  hannken 
    369   1.1  hannken 	return error;
    370   1.1  hannken }
    371   1.1  hannken 
    372   1.1  hannken /*
    373   1.1  hannken  * Request a filesystem to resume all operations.
    374   1.1  hannken  */
    375   1.1  hannken void
    376   1.1  hannken vfs_resume(struct mount *mp)
    377   1.1  hannken {
    378   1.1  hannken 
    379   1.1  hannken 	VFS_SUSPENDCTL(mp, SUSPEND_RESUME);
    380   1.3  hannken 	mutex_exit(&syncer_mutex);
    381   1.4       ad 	mutex_exit(&vfs_suspend_lock);
    382   1.1  hannken }
    383   1.1  hannken 
    384   1.1  hannken #if defined(DDB)
    385   1.1  hannken void fstrans_dump(int);
    386   1.1  hannken 
    387   1.1  hannken static void
    388   1.1  hannken fstrans_print_lwp(struct proc *p, struct lwp *l, int verbose)
    389   1.1  hannken {
    390   1.1  hannken 	char prefix[9];
    391   1.1  hannken 	struct fstrans_lwp_info *fli;
    392   1.1  hannken 
    393   1.1  hannken 	snprintf(prefix, sizeof(prefix), "%d.%d", p->p_pid, l->l_lid);
    394   1.1  hannken 	for (fli = _lwp_getspecific_by_lwp(l, lwp_data_key);
    395   1.1  hannken 	     fli;
    396   1.1  hannken 	     fli = fli->fli_succ) {
    397   1.1  hannken 		if (!verbose && fli->fli_count == 0)
    398   1.1  hannken 			continue;
    399   1.1  hannken 		printf("%-8s", prefix);
    400   1.1  hannken 		if (verbose)
    401   1.1  hannken 			printf(" @%p", fli);
    402   1.1  hannken 		if (fli->fli_mount != NULL)
    403   1.1  hannken 			printf(" (%s)", fli->fli_mount->mnt_stat.f_mntonname);
    404   1.1  hannken 		else
    405   1.1  hannken 			printf(" NULL");
    406   1.1  hannken 		switch (fli->fli_lock_type) {
    407   1.2  hannken 		case FSTRANS_LAZY:
    408   1.1  hannken 			printf(" lazy");
    409   1.1  hannken 			break;
    410   1.2  hannken 		case FSTRANS_SHARED:
    411   1.1  hannken 			printf(" shared");
    412   1.1  hannken 			break;
    413   1.2  hannken 		case FSTRANS_EXCL:
    414   1.1  hannken 			printf(" excl");
    415   1.1  hannken 			break;
    416   1.1  hannken 		default:
    417   1.1  hannken 			printf(" %#x", fli->fli_lock_type);
    418   1.1  hannken 			break;
    419   1.1  hannken 		}
    420   1.1  hannken 		printf(" %d\n", fli->fli_count);
    421   1.1  hannken 		prefix[0] = '\0';
    422   1.1  hannken 	}
    423   1.1  hannken }
    424   1.1  hannken 
    425   1.1  hannken static void
    426   1.1  hannken fstrans_print_mount(struct mount *mp, int verbose)
    427   1.1  hannken {
    428   1.1  hannken 	struct fstrans_mount_info *fmi;
    429   1.1  hannken 
    430  1.16       ad 	fmi = mp->mnt_transinfo;
    431   1.2  hannken 	if (!verbose && (fmi == NULL || fmi->fmi_state == FSTRANS_NORMAL))
    432   1.1  hannken 		return;
    433   1.1  hannken 
    434   1.1  hannken 	printf("%-16s ", mp->mnt_stat.f_mntonname);
    435   1.1  hannken 	if (fmi == NULL) {
    436   1.1  hannken 		printf("(null)\n");
    437   1.1  hannken 		return;
    438   1.1  hannken 	}
    439   1.1  hannken 	switch (fmi->fmi_state) {
    440   1.2  hannken 	case FSTRANS_NORMAL:
    441   1.1  hannken 		printf("state normal\n");
    442   1.1  hannken 		break;
    443   1.2  hannken 	case FSTRANS_SUSPENDING:
    444   1.1  hannken 		printf("state suspending\n");
    445   1.1  hannken 		break;
    446   1.2  hannken 	case FSTRANS_SUSPENDED:
    447   1.1  hannken 		printf("state suspended\n");
    448   1.1  hannken 		break;
    449   1.1  hannken 	default:
    450   1.1  hannken 		printf("state %#x\n", fmi->fmi_state);
    451   1.1  hannken 		break;
    452   1.1  hannken 	}
    453   1.8  hannken 	printf("%16s r=%d w=%d\n", "lock_lazy:",
    454   1.8  hannken 	    rw_read_held(&fmi->fmi_lazy_lock),
    455   1.8  hannken 	    rw_write_held(&fmi->fmi_lazy_lock));
    456   1.8  hannken 	printf("%16s r=%d w=%d\n", "lock_shared:",
    457   1.8  hannken 	    rw_read_held(&fmi->fmi_shared_lock),
    458   1.8  hannken 	    rw_write_held(&fmi->fmi_shared_lock));
    459   1.1  hannken }
    460   1.1  hannken 
    461   1.1  hannken void
    462   1.1  hannken fstrans_dump(int full)
    463   1.1  hannken {
    464   1.1  hannken 	const struct proclist_desc *pd;
    465   1.1  hannken 	struct proc *p;
    466   1.1  hannken 	struct lwp *l;
    467   1.1  hannken 	struct mount *mp;
    468   1.1  hannken 
    469   1.1  hannken 	printf("Fstrans locks by lwp:\n");
    470   1.1  hannken 	for (pd = proclists; pd->pd_list != NULL; pd++)
    471   1.1  hannken 		LIST_FOREACH(p, pd->pd_list, p_list)
    472   1.1  hannken 			LIST_FOREACH(l, &p->p_lwps, l_sibling)
    473   1.1  hannken 				fstrans_print_lwp(p, l, full == 1);
    474   1.1  hannken 
    475   1.1  hannken 	printf("Fstrans state by mount:\n");
    476   1.1  hannken 	CIRCLEQ_FOREACH(mp, &mountlist, mnt_list)
    477   1.1  hannken 		fstrans_print_mount(mp, full == 1);
    478   1.1  hannken }
    479   1.1  hannken #endif /* defined(DDB) */
    480  1.12  hannken 
    481  1.12  hannken int
    482  1.15  hannken fscow_establish(struct mount *mp, int (*func)(void *, struct buf *, bool),
    483  1.15  hannken     void *arg)
    484  1.12  hannken {
    485  1.16       ad 	struct fstrans_mount_info *fmi;
    486  1.12  hannken 	struct fscow_handler *new;
    487  1.12  hannken 
    488  1.16       ad 	if ((mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    489  1.16       ad 		return EINVAL;
    490  1.16       ad 
    491  1.16       ad 	fmi = mp->mnt_transinfo;
    492  1.12  hannken 
    493  1.12  hannken 	if ((new = kmem_alloc(sizeof(*new), KM_SLEEP)) == NULL)
    494  1.12  hannken 		return ENOMEM;
    495  1.12  hannken 	new->ch_func = func;
    496  1.12  hannken 	new->ch_arg = arg;
    497  1.16       ad 	rw_enter(&fmi->fmi_cow_lock, RW_WRITER);
    498  1.16       ad 	SLIST_INSERT_HEAD(&fmi->fmi_cow_handler, new, ch_list);
    499  1.16       ad 	rw_exit(&fmi->fmi_cow_lock);
    500  1.12  hannken 
    501  1.12  hannken 	return 0;
    502  1.12  hannken }
    503  1.12  hannken 
    504  1.12  hannken int
    505  1.15  hannken fscow_disestablish(struct mount *mp, int (*func)(void *, struct buf *, bool),
    506  1.12  hannken     void *arg)
    507  1.12  hannken {
    508  1.16       ad 	struct fstrans_mount_info *fmi;
    509  1.12  hannken 	struct fscow_handler *hp = NULL;
    510  1.12  hannken 
    511  1.16       ad 	if ((mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    512  1.12  hannken 		return EINVAL;
    513  1.12  hannken 
    514  1.16       ad 	fmi = mp->mnt_transinfo;
    515  1.16       ad 
    516  1.16       ad 	rw_enter(&fmi->fmi_cow_lock, RW_WRITER);
    517  1.16       ad 	SLIST_FOREACH(hp, &fmi->fmi_cow_handler, ch_list)
    518  1.12  hannken 		if (hp->ch_func == func && hp->ch_arg == arg)
    519  1.12  hannken 			break;
    520  1.12  hannken 	if (hp != NULL) {
    521  1.16       ad 		SLIST_REMOVE(&fmi->fmi_cow_handler, hp, fscow_handler, ch_list);
    522  1.12  hannken 		kmem_free(hp, sizeof(*hp));
    523  1.12  hannken 	}
    524  1.16       ad 	rw_exit(&fmi->fmi_cow_lock);
    525  1.12  hannken 
    526  1.12  hannken 	return hp ? 0 : EINVAL;
    527  1.12  hannken }
    528  1.12  hannken 
    529  1.12  hannken int
    530  1.15  hannken fscow_run(struct buf *bp, bool data_valid)
    531  1.12  hannken {
    532  1.12  hannken 	int error = 0;
    533  1.12  hannken 	struct mount *mp;
    534  1.16       ad 	struct fstrans_mount_info *fmi;
    535  1.12  hannken 	struct fscow_handler *hp;
    536  1.12  hannken 
    537  1.17  hannken 	if ((bp->b_flags & B_COWDONE))
    538  1.15  hannken 		goto done;
    539  1.12  hannken 	if (bp->b_vp == NULL)
    540  1.15  hannken 		goto done;
    541  1.12  hannken 	if (bp->b_vp->v_type == VBLK)
    542  1.12  hannken 		mp = bp->b_vp->v_specmountpoint;
    543  1.12  hannken 	else
    544  1.12  hannken 		mp = bp->b_vp->v_mount;
    545  1.16       ad 	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
    546  1.15  hannken 		goto done;
    547  1.12  hannken 
    548  1.16       ad 	fmi = mp->mnt_transinfo;
    549  1.12  hannken 
    550  1.16       ad 	rw_enter(&fmi->fmi_cow_lock, RW_READER);
    551  1.16       ad 	SLIST_FOREACH(hp, &fmi->fmi_cow_handler, ch_list)
    552  1.15  hannken 		if ((error = (*hp->ch_func)(hp->ch_arg, bp, data_valid)) != 0)
    553  1.12  hannken 			break;
    554  1.16       ad 	rw_exit(&fmi->fmi_cow_lock);
    555  1.12  hannken 
    556  1.16       ad  done:
    557  1.17  hannken  	if (error == 0)
    558  1.17  hannken  		bp->b_flags |= B_COWDONE;
    559  1.15  hannken 
    560  1.12  hannken 	return error;
    561  1.12  hannken }
    562