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