1/*
2 * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
3 *
4 * The soft updates code is derived from the appendix of a University
5 * of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
6 * "Soft Updates: A Solution to the Metadata Update Problem in File
7 * Systems", CSE-TR-254-95, August 1995).
8 *
9 * Further information about soft updates can be obtained from:
10 *
11 * Marshall Kirk McKusick http://www.mckusick.com/softdep/
12 * 1614 Oxford Street mckusick@mckusick.com
13 * Berkeley, CA 94709-1608 +1-510-843-9542
14 * USA
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 *
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
27 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29 * DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
30 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * from: @(#)ffs_softdep.c 9.59 (McKusick) 6/21/00
| 1/*
2 * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
3 *
4 * The soft updates code is derived from the appendix of a University
5 * of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
6 * "Soft Updates: A Solution to the Metadata Update Problem in File
7 * Systems", CSE-TR-254-95, August 1995).
8 *
9 * Further information about soft updates can be obtained from:
10 *
11 * Marshall Kirk McKusick http://www.mckusick.com/softdep/
12 * 1614 Oxford Street mckusick@mckusick.com
13 * Berkeley, CA 94709-1608 +1-510-843-9542
14 * USA
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 *
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
27 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29 * DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
30 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * from: @(#)ffs_softdep.c 9.59 (McKusick) 6/21/00
|
39 * $FreeBSD: head/sys/ufs/ffs/ffs_softdep.c 76354 2001-05-08 07:13:00Z mckusick $
| 39 * $FreeBSD: head/sys/ufs/ffs/ffs_softdep.c 76357 2001-05-08 07:42:20Z mckusick $
|
40 */
41
42/*
43 * For now we want the safety net that the DIAGNOSTIC and DEBUG flags provide.
44 */
45#ifndef DIAGNOSTIC
46#define DIAGNOSTIC
47#endif
48#ifndef DEBUG
49#define DEBUG
50#endif
51
52#include <sys/param.h>
53#include <sys/kernel.h>
54#include <sys/systm.h>
55#include <sys/bio.h>
56#include <sys/buf.h>
57#include <sys/malloc.h>
58#include <sys/mount.h>
59#include <sys/proc.h>
| 40 */
41
42/*
43 * For now we want the safety net that the DIAGNOSTIC and DEBUG flags provide.
44 */
45#ifndef DIAGNOSTIC
46#define DIAGNOSTIC
47#endif
48#ifndef DEBUG
49#define DEBUG
50#endif
51
52#include <sys/param.h>
53#include <sys/kernel.h>
54#include <sys/systm.h>
55#include <sys/bio.h>
56#include <sys/buf.h>
57#include <sys/malloc.h>
58#include <sys/mount.h>
59#include <sys/proc.h>
|
| 60#include <sys/stat.h>
|
60#include <sys/syslog.h>
61#include <sys/vnode.h>
62#include <sys/conf.h>
63#include <ufs/ufs/dir.h>
64#include <ufs/ufs/extattr.h>
65#include <ufs/ufs/quota.h>
66#include <ufs/ufs/inode.h>
67#include <ufs/ufs/ufsmount.h>
68#include <ufs/ffs/fs.h>
69#include <ufs/ffs/softdep.h>
70#include <ufs/ffs/ffs_extern.h>
71#include <ufs/ufs/ufs_extern.h>
72
73/*
74 * These definitions need to be adapted to the system to which
75 * this file is being ported.
76 */
77/*
78 * malloc types defined for the softdep system.
79 */
80static MALLOC_DEFINE(M_PAGEDEP, "pagedep","File page dependencies");
81static MALLOC_DEFINE(M_INODEDEP, "inodedep","Inode dependencies");
82static MALLOC_DEFINE(M_NEWBLK, "newblk","New block allocation");
83static MALLOC_DEFINE(M_BMSAFEMAP, "bmsafemap","Block or frag allocated from cyl group map");
84static MALLOC_DEFINE(M_ALLOCDIRECT, "allocdirect","Block or frag dependency for an inode");
85static MALLOC_DEFINE(M_INDIRDEP, "indirdep","Indirect block dependencies");
86static MALLOC_DEFINE(M_ALLOCINDIR, "allocindir","Block dependency for an indirect block");
87static MALLOC_DEFINE(M_FREEFRAG, "freefrag","Previously used frag for an inode");
88static MALLOC_DEFINE(M_FREEBLKS, "freeblks","Blocks freed from an inode");
89static MALLOC_DEFINE(M_FREEFILE, "freefile","Inode deallocated");
90static MALLOC_DEFINE(M_DIRADD, "diradd","New directory entry");
91static MALLOC_DEFINE(M_MKDIR, "mkdir","New directory");
92static MALLOC_DEFINE(M_DIRREM, "dirrem","Directory entry deleted");
93
94#define M_SOFTDEP_FLAGS (M_WAITOK | M_USE_RESERVE)
95
96#define D_PAGEDEP 0
97#define D_INODEDEP 1
98#define D_NEWBLK 2
99#define D_BMSAFEMAP 3
100#define D_ALLOCDIRECT 4
101#define D_INDIRDEP 5
102#define D_ALLOCINDIR 6
103#define D_FREEFRAG 7
104#define D_FREEBLKS 8
105#define D_FREEFILE 9
106#define D_DIRADD 10
107#define D_MKDIR 11
108#define D_DIRREM 12
109#define D_LAST D_DIRREM
110
111/*
112 * translate from workitem type to memory type
113 * MUST match the defines above, such that memtype[D_XXX] == M_XXX
114 */
115static struct malloc_type *memtype[] = {
116 M_PAGEDEP,
117 M_INODEDEP,
118 M_NEWBLK,
119 M_BMSAFEMAP,
120 M_ALLOCDIRECT,
121 M_INDIRDEP,
122 M_ALLOCINDIR,
123 M_FREEFRAG,
124 M_FREEBLKS,
125 M_FREEFILE,
126 M_DIRADD,
127 M_MKDIR,
128 M_DIRREM
129};
130
131#define DtoM(type) (memtype[type])
132
133/*
134 * Names of malloc types.
135 */
136#define TYPENAME(type) \
137 ((unsigned)(type) < D_LAST ? memtype[type]->ks_shortdesc : "???")
138/*
139 * End system adaptaion definitions.
140 */
141
142/*
143 * Internal function prototypes.
144 */
145static void softdep_error __P((char *, int));
146static void drain_output __P((struct vnode *, int));
147static int getdirtybuf __P((struct buf **, int));
148static void clear_remove __P((struct proc *));
149static void clear_inodedeps __P((struct proc *));
150static int flush_pagedep_deps __P((struct vnode *, struct mount *,
151 struct diraddhd *));
152static int flush_inodedep_deps __P((struct fs *, ino_t));
153static int handle_written_filepage __P((struct pagedep *, struct buf *));
154static void diradd_inode_written __P((struct diradd *, struct inodedep *));
155static int handle_written_inodeblock __P((struct inodedep *, struct buf *));
156static void handle_allocdirect_partdone __P((struct allocdirect *));
157static void handle_allocindir_partdone __P((struct allocindir *));
158static void initiate_write_filepage __P((struct pagedep *, struct buf *));
159static void handle_written_mkdir __P((struct mkdir *, int));
160static void initiate_write_inodeblock __P((struct inodedep *, struct buf *));
161static void handle_workitem_freefile __P((struct freefile *));
162static void handle_workitem_remove __P((struct dirrem *));
163static struct dirrem *newdirrem __P((struct buf *, struct inode *,
164 struct inode *, int, struct dirrem **));
165static void free_diradd __P((struct diradd *));
166static void free_allocindir __P((struct allocindir *, struct inodedep *));
167static int indir_trunc __P((struct inode *, ufs_daddr_t, int, ufs_lbn_t,
168 long *));
169static void deallocate_dependencies __P((struct buf *, struct inodedep *));
170static void free_allocdirect __P((struct allocdirectlst *,
171 struct allocdirect *, int));
172static int check_inode_unwritten __P((struct inodedep *));
173static int free_inodedep __P((struct inodedep *));
174static void handle_workitem_freeblocks __P((struct freeblks *, int));
175static void merge_inode_lists __P((struct inodedep *));
176static void setup_allocindir_phase2 __P((struct buf *, struct inode *,
177 struct allocindir *));
178static struct allocindir *newallocindir __P((struct inode *, int, ufs_daddr_t,
179 ufs_daddr_t));
180static void handle_workitem_freefrag __P((struct freefrag *));
181static struct freefrag *newfreefrag __P((struct inode *, ufs_daddr_t, long));
182static void allocdirect_merge __P((struct allocdirectlst *,
183 struct allocdirect *, struct allocdirect *));
184static struct bmsafemap *bmsafemap_lookup __P((struct buf *));
185static int newblk_lookup __P((struct fs *, ufs_daddr_t, int,
186 struct newblk **));
187static int inodedep_lookup __P((struct fs *, ino_t, int, struct inodedep **));
188static int pagedep_lookup __P((struct inode *, ufs_lbn_t, int,
189 struct pagedep **));
190static void pause_timer __P((void *));
191static int request_cleanup __P((int, int));
192static int process_worklist_item __P((struct mount *, int));
193static void add_to_worklist __P((struct worklist *));
194
195/*
196 * Exported softdep operations.
197 */
198static void softdep_disk_io_initiation __P((struct buf *));
199static void softdep_disk_write_complete __P((struct buf *));
200static void softdep_deallocate_dependencies __P((struct buf *));
201static void softdep_move_dependencies __P((struct buf *, struct buf *));
202static int softdep_count_dependencies __P((struct buf *bp, int));
203
204struct bio_ops bioops = {
205 softdep_disk_io_initiation, /* io_start */
206 softdep_disk_write_complete, /* io_complete */
207 softdep_deallocate_dependencies, /* io_deallocate */
208 softdep_move_dependencies, /* io_movedeps */
209 softdep_count_dependencies, /* io_countdeps */
210};
211
212/*
213 * Locking primitives.
214 *
215 * For a uniprocessor, all we need to do is protect against disk
216 * interrupts. For a multiprocessor, this lock would have to be
217 * a mutex. A single mutex is used throughout this file, though
218 * finer grain locking could be used if contention warranted it.
219 *
220 * For a multiprocessor, the sleep call would accept a lock and
221 * release it after the sleep processing was complete. In a uniprocessor
222 * implementation there is no such interlock, so we simple mark
223 * the places where it needs to be done with the `interlocked' form
224 * of the lock calls. Since the uniprocessor sleep already interlocks
225 * the spl, there is nothing that really needs to be done.
226 */
227#ifndef /* NOT */ DEBUG
228static struct lockit {
229 int lkt_spl;
230} lk = { 0 };
231#define ACQUIRE_LOCK(lk) (lk)->lkt_spl = splbio()
232#define FREE_LOCK(lk) splx((lk)->lkt_spl)
233#define ACQUIRE_LOCK_INTERLOCKED(lk)
234#define FREE_LOCK_INTERLOCKED(lk)
235
236#else /* DEBUG */
237static struct lockit {
238 int lkt_spl;
239 pid_t lkt_held;
240} lk = { 0, -1 };
241static int lockcnt;
242
243static void acquire_lock __P((struct lockit *));
244static void free_lock __P((struct lockit *));
245static void acquire_lock_interlocked __P((struct lockit *));
246static void free_lock_interlocked __P((struct lockit *));
247
248#define ACQUIRE_LOCK(lk) acquire_lock(lk)
249#define FREE_LOCK(lk) free_lock(lk)
250#define ACQUIRE_LOCK_INTERLOCKED(lk) acquire_lock_interlocked(lk)
251#define FREE_LOCK_INTERLOCKED(lk) free_lock_interlocked(lk)
252
253static void
254acquire_lock(lk)
255 struct lockit *lk;
256{
257 pid_t holder;
258
259 if (lk->lkt_held != -1) {
260 holder = lk->lkt_held;
261 FREE_LOCK(lk);
262 if (holder == CURPROC->p_pid)
263 panic("softdep_lock: locking against myself");
264 else
265 panic("softdep_lock: lock held by %d", holder);
266 }
267 lk->lkt_spl = splbio();
268 lk->lkt_held = CURPROC->p_pid;
269 lockcnt++;
270}
271
272static void
273free_lock(lk)
274 struct lockit *lk;
275{
276
277 if (lk->lkt_held == -1)
278 panic("softdep_unlock: lock not held");
279 lk->lkt_held = -1;
280 splx(lk->lkt_spl);
281}
282
283static void
284acquire_lock_interlocked(lk)
285 struct lockit *lk;
286{
287 pid_t holder;
288
289 if (lk->lkt_held != -1) {
290 holder = lk->lkt_held;
291 FREE_LOCK(lk);
292 if (holder == CURPROC->p_pid)
293 panic("softdep_lock_interlocked: locking against self");
294 else
295 panic("softdep_lock_interlocked: lock held by %d",
296 holder);
297 }
298 lk->lkt_held = CURPROC->p_pid;
299 lockcnt++;
300}
301
302static void
303free_lock_interlocked(lk)
304 struct lockit *lk;
305{
306
307 if (lk->lkt_held == -1)
308 panic("softdep_unlock_interlocked: lock not held");
309 lk->lkt_held = -1;
310}
311#endif /* DEBUG */
312
313/*
314 * Place holder for real semaphores.
315 */
316struct sema {
317 int value;
318 pid_t holder;
319 char *name;
320 int prio;
321 int timo;
322};
323static void sema_init __P((struct sema *, char *, int, int));
324static int sema_get __P((struct sema *, struct lockit *));
325static void sema_release __P((struct sema *));
326
327static void
328sema_init(semap, name, prio, timo)
329 struct sema *semap;
330 char *name;
331 int prio, timo;
332{
333
334 semap->holder = -1;
335 semap->value = 0;
336 semap->name = name;
337 semap->prio = prio;
338 semap->timo = timo;
339}
340
341static int
342sema_get(semap, interlock)
343 struct sema *semap;
344 struct lockit *interlock;
345{
346
347 if (semap->value++ > 0) {
348 if (interlock != NULL)
349 FREE_LOCK_INTERLOCKED(interlock);
350 tsleep((caddr_t)semap, semap->prio, semap->name, semap->timo);
351 if (interlock != NULL) {
352 ACQUIRE_LOCK_INTERLOCKED(interlock);
353 FREE_LOCK(interlock);
354 }
355 return (0);
356 }
357 semap->holder = CURPROC->p_pid;
358 if (interlock != NULL)
359 FREE_LOCK(interlock);
360 return (1);
361}
362
363static void
364sema_release(semap)
365 struct sema *semap;
366{
367
368 if (semap->value <= 0 || semap->holder != CURPROC->p_pid) {
369 if (lk.lkt_held != -1)
370 FREE_LOCK(&lk);
371 panic("sema_release: not held");
372 }
373 if (--semap->value > 0) {
374 semap->value = 0;
375 wakeup(semap);
376 }
377 semap->holder = -1;
378}
379
380/*
381 * Worklist queue management.
382 * These routines require that the lock be held.
383 */
384#ifndef /* NOT */ DEBUG
385#define WORKLIST_INSERT(head, item) do { \
386 (item)->wk_state |= ONWORKLIST; \
387 LIST_INSERT_HEAD(head, item, wk_list); \
388} while (0)
389#define WORKLIST_REMOVE(item) do { \
390 (item)->wk_state &= ~ONWORKLIST; \
391 LIST_REMOVE(item, wk_list); \
392} while (0)
393#define WORKITEM_FREE(item, type) FREE(item, DtoM(type))
394
395#else /* DEBUG */
396static void worklist_insert __P((struct workhead *, struct worklist *));
397static void worklist_remove __P((struct worklist *));
398static void workitem_free __P((struct worklist *, int));
399
400#define WORKLIST_INSERT(head, item) worklist_insert(head, item)
401#define WORKLIST_REMOVE(item) worklist_remove(item)
402#define WORKITEM_FREE(item, type) workitem_free((struct worklist *)item, type)
403
404static void
405worklist_insert(head, item)
406 struct workhead *head;
407 struct worklist *item;
408{
409
410 if (lk.lkt_held == -1)
411 panic("worklist_insert: lock not held");
412 if (item->wk_state & ONWORKLIST) {
413 FREE_LOCK(&lk);
414 panic("worklist_insert: already on list");
415 }
416 item->wk_state |= ONWORKLIST;
417 LIST_INSERT_HEAD(head, item, wk_list);
418}
419
420static void
421worklist_remove(item)
422 struct worklist *item;
423{
424
425 if (lk.lkt_held == -1)
426 panic("worklist_remove: lock not held");
427 if ((item->wk_state & ONWORKLIST) == 0) {
428 FREE_LOCK(&lk);
429 panic("worklist_remove: not on list");
430 }
431 item->wk_state &= ~ONWORKLIST;
432 LIST_REMOVE(item, wk_list);
433}
434
435static void
436workitem_free(item, type)
437 struct worklist *item;
438 int type;
439{
440
441 if (item->wk_state & ONWORKLIST) {
442 if (lk.lkt_held != -1)
443 FREE_LOCK(&lk);
444 panic("workitem_free: still on list");
445 }
446 if (item->wk_type != type) {
447 if (lk.lkt_held != -1)
448 FREE_LOCK(&lk);
449 panic("workitem_free: type mismatch");
450 }
451 FREE(item, DtoM(type));
452}
453#endif /* DEBUG */
454
455/*
456 * Workitem queue management
457 */
458static struct workhead softdep_workitem_pending;
459static int num_on_worklist; /* number of worklist items to be processed */
460static int softdep_worklist_busy; /* 1 => trying to do unmount */
461static int softdep_worklist_req; /* serialized waiters */
462static int max_softdeps; /* maximum number of structs before slowdown */
463static int tickdelay = 2; /* number of ticks to pause during slowdown */
464static int proc_waiting; /* tracks whether we have a timeout posted */
465static int *stat_countp; /* statistic to count in proc_waiting timeout */
466static struct callout_handle handle; /* handle on posted proc_waiting timeout */
467static struct proc *filesys_syncer; /* proc of filesystem syncer process */
468static int req_clear_inodedeps; /* syncer process flush some inodedeps */
469#define FLUSH_INODES 1
470static int req_clear_remove; /* syncer process flush some freeblks */
471#define FLUSH_REMOVE 2
472/*
473 * runtime statistics
474 */
475static int stat_worklist_push; /* number of worklist cleanups */
476static int stat_blk_limit_push; /* number of times block limit neared */
477static int stat_ino_limit_push; /* number of times inode limit neared */
478static int stat_blk_limit_hit; /* number of times block slowdown imposed */
479static int stat_ino_limit_hit; /* number of times inode slowdown imposed */
480static int stat_sync_limit_hit; /* number of synchronous slowdowns imposed */
481static int stat_indir_blk_ptrs; /* bufs redirtied as indir ptrs not written */
482static int stat_inode_bitmap; /* bufs redirtied as inode bitmap not written */
483static int stat_direct_blk_ptrs;/* bufs redirtied as direct ptrs not written */
484static int stat_dir_entry; /* bufs redirtied as dir entry cannot write */
485#ifdef DEBUG
486#include <vm/vm.h>
487#include <sys/sysctl.h>
488SYSCTL_INT(_debug, OID_AUTO, max_softdeps, CTLFLAG_RW, &max_softdeps, 0, "");
489SYSCTL_INT(_debug, OID_AUTO, tickdelay, CTLFLAG_RW, &tickdelay, 0, "");
490SYSCTL_INT(_debug, OID_AUTO, worklist_push, CTLFLAG_RW, &stat_worklist_push, 0,"");
491SYSCTL_INT(_debug, OID_AUTO, blk_limit_push, CTLFLAG_RW, &stat_blk_limit_push, 0,"");
492SYSCTL_INT(_debug, OID_AUTO, ino_limit_push, CTLFLAG_RW, &stat_ino_limit_push, 0,"");
493SYSCTL_INT(_debug, OID_AUTO, blk_limit_hit, CTLFLAG_RW, &stat_blk_limit_hit, 0, "");
494SYSCTL_INT(_debug, OID_AUTO, ino_limit_hit, CTLFLAG_RW, &stat_ino_limit_hit, 0, "");
495SYSCTL_INT(_debug, OID_AUTO, sync_limit_hit, CTLFLAG_RW, &stat_sync_limit_hit, 0, "");
496SYSCTL_INT(_debug, OID_AUTO, indir_blk_ptrs, CTLFLAG_RW, &stat_indir_blk_ptrs, 0, "");
497SYSCTL_INT(_debug, OID_AUTO, inode_bitmap, CTLFLAG_RW, &stat_inode_bitmap, 0, "");
498SYSCTL_INT(_debug, OID_AUTO, direct_blk_ptrs, CTLFLAG_RW, &stat_direct_blk_ptrs, 0, "");
499SYSCTL_INT(_debug, OID_AUTO, dir_entry, CTLFLAG_RW, &stat_dir_entry, 0, "");
500#endif /* DEBUG */
501
502/*
503 * Add an item to the end of the work queue.
504 * This routine requires that the lock be held.
505 * This is the only routine that adds items to the list.
506 * The following routine is the only one that removes items
507 * and does so in order from first to last.
508 */
509static void
510add_to_worklist(wk)
511 struct worklist *wk;
512{
513 static struct worklist *worklist_tail;
514
515 if (wk->wk_state & ONWORKLIST) {
516 if (lk.lkt_held != -1)
517 FREE_LOCK(&lk);
518 panic("add_to_worklist: already on list");
519 }
520 wk->wk_state |= ONWORKLIST;
521 if (LIST_FIRST(&softdep_workitem_pending) == NULL)
522 LIST_INSERT_HEAD(&softdep_workitem_pending, wk, wk_list);
523 else
524 LIST_INSERT_AFTER(worklist_tail, wk, wk_list);
525 worklist_tail = wk;
526 num_on_worklist += 1;
527}
528
529/*
530 * Process that runs once per second to handle items in the background queue.
531 *
532 * Note that we ensure that everything is done in the order in which they
533 * appear in the queue. The code below depends on this property to ensure
534 * that blocks of a file are freed before the inode itself is freed. This
535 * ordering ensures that no new <vfsid, inum, lbn> triples will be generated
536 * until all the old ones have been purged from the dependency lists.
537 */
538int
539softdep_process_worklist(matchmnt)
540 struct mount *matchmnt;
541{
542 struct proc *p = CURPROC;
543 int matchcnt, loopcount;
544 long starttime;
545
546 /*
547 * Record the process identifier of our caller so that we can give
548 * this process preferential treatment in request_cleanup below.
549 */
550 filesys_syncer = p;
551 matchcnt = 0;
552
553 /*
554 * There is no danger of having multiple processes run this
555 * code, but we have to single-thread it when softdep_flushfiles()
556 * is in operation to get an accurate count of the number of items
557 * related to its mount point that are in the list.
558 */
559 if (matchmnt == NULL) {
560 if (softdep_worklist_busy < 0)
561 return(-1);
562 softdep_worklist_busy += 1;
563 }
564
565 /*
566 * If requested, try removing inode or removal dependencies.
567 */
568 if (req_clear_inodedeps) {
569 clear_inodedeps(p);
570 req_clear_inodedeps -= 1;
571 wakeup_one(&proc_waiting);
572 }
573 if (req_clear_remove) {
574 clear_remove(p);
575 req_clear_remove -= 1;
576 wakeup_one(&proc_waiting);
577 }
578 loopcount = 1;
579 starttime = time_second;
580 while (num_on_worklist > 0) {
581 matchcnt += process_worklist_item(matchmnt, 0);
582
583 /*
584 * If a umount operation wants to run the worklist
585 * accurately, abort.
586 */
587 if (softdep_worklist_req && matchmnt == NULL) {
588 matchcnt = -1;
589 break;
590 }
591
592 /*
593 * If requested, try removing inode or removal dependencies.
594 */
595 if (req_clear_inodedeps) {
596 clear_inodedeps(p);
597 req_clear_inodedeps -= 1;
598 wakeup_one(&proc_waiting);
599 }
600 if (req_clear_remove) {
601 clear_remove(p);
602 req_clear_remove -= 1;
603 wakeup_one(&proc_waiting);
604 }
605 /*
606 * We do not generally want to stop for buffer space, but if
607 * we are really being a buffer hog, we will stop and wait.
608 */
609 if (loopcount++ % 128 == 0)
610 bwillwrite();
611 /*
612 * Never allow processing to run for more than one
613 * second. Otherwise the other syncer tasks may get
614 * excessively backlogged.
615 */
616 if (starttime != time_second && matchmnt == NULL) {
617 matchcnt = -1;
618 break;
619 }
620 }
621 if (matchmnt == NULL) {
622 softdep_worklist_busy -= 1;
623 if (softdep_worklist_req && softdep_worklist_busy == 0)
624 wakeup(&softdep_worklist_req);
625 }
626 return (matchcnt);
627}
628
629/*
630 * Process one item on the worklist.
631 */
632static int
633process_worklist_item(matchmnt, flags)
634 struct mount *matchmnt;
635 int flags;
636{
637 struct worklist *wk;
638 struct dirrem *dirrem;
639 struct mount *mp;
640 struct vnode *vp;
641 int matchcnt = 0;
642
643 ACQUIRE_LOCK(&lk);
644 /*
645 * Normally we just process each item on the worklist in order.
646 * However, if we are in a situation where we cannot lock any
647 * inodes, we have to skip over any dirrem requests whose
648 * vnodes are resident and locked.
649 */
650 LIST_FOREACH(wk, &softdep_workitem_pending, wk_list) {
651 if ((flags & LK_NOWAIT) == 0 || wk->wk_type != D_DIRREM)
652 break;
653 dirrem = WK_DIRREM(wk);
654 vp = ufs_ihashlookup(VFSTOUFS(dirrem->dm_mnt)->um_dev,
655 dirrem->dm_oldinum);
656 if (vp == NULL || !VOP_ISLOCKED(vp, CURPROC))
657 break;
658 }
659 if (wk == 0) {
660 FREE_LOCK(&lk);
661 return (0);
662 }
663 WORKLIST_REMOVE(wk);
664 num_on_worklist -= 1;
665 FREE_LOCK(&lk);
666 switch (wk->wk_type) {
667
668 case D_DIRREM:
669 /* removal of a directory entry */
670 mp = WK_DIRREM(wk)->dm_mnt;
671 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
672 panic("%s: dirrem on suspended filesystem",
673 "process_worklist_item");
674 if (mp == matchmnt)
675 matchcnt += 1;
676 handle_workitem_remove(WK_DIRREM(wk));
677 break;
678
679 case D_FREEBLKS:
680 /* releasing blocks and/or fragments from a file */
681 mp = WK_FREEBLKS(wk)->fb_mnt;
682 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
683 panic("%s: freeblks on suspended filesystem",
684 "process_worklist_item");
685 if (mp == matchmnt)
686 matchcnt += 1;
687 handle_workitem_freeblocks(WK_FREEBLKS(wk), flags & LK_NOWAIT);
688 break;
689
690 case D_FREEFRAG:
691 /* releasing a fragment when replaced as a file grows */
692 mp = WK_FREEFRAG(wk)->ff_mnt;
693 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
694 panic("%s: freefrag on suspended filesystem",
695 "process_worklist_item");
696 if (mp == matchmnt)
697 matchcnt += 1;
698 handle_workitem_freefrag(WK_FREEFRAG(wk));
699 break;
700
701 case D_FREEFILE:
702 /* releasing an inode when its link count drops to 0 */
703 mp = WK_FREEFILE(wk)->fx_mnt;
704 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
705 panic("%s: freefile on suspended filesystem",
706 "process_worklist_item");
707 if (mp == matchmnt)
708 matchcnt += 1;
709 handle_workitem_freefile(WK_FREEFILE(wk));
710 break;
711
712 default:
713 panic("%s_process_worklist: Unknown type %s",
714 "softdep", TYPENAME(wk->wk_type));
715 /* NOTREACHED */
716 }
717 return (matchcnt);
718}
719
720/*
721 * Move dependencies from one buffer to another.
722 */
723static void
724softdep_move_dependencies(oldbp, newbp)
725 struct buf *oldbp;
726 struct buf *newbp;
727{
728 struct worklist *wk, *wktail;
729
730 if (LIST_FIRST(&newbp->b_dep) != NULL)
731 panic("softdep_move_dependencies: need merge code");
732 wktail = 0;
733 ACQUIRE_LOCK(&lk);
734 while ((wk = LIST_FIRST(&oldbp->b_dep)) != NULL) {
735 LIST_REMOVE(wk, wk_list);
736 if (wktail == 0)
737 LIST_INSERT_HEAD(&newbp->b_dep, wk, wk_list);
738 else
739 LIST_INSERT_AFTER(wktail, wk, wk_list);
740 wktail = wk;
741 }
742 FREE_LOCK(&lk);
743}
744
745/*
746 * Purge the work list of all items associated with a particular mount point.
747 */
748int
749softdep_flushworklist(oldmnt, countp, p)
750 struct mount *oldmnt;
751 int *countp;
752 struct proc *p;
753{
754 struct vnode *devvp;
755 int count, error = 0;
756
757 /*
758 * Await our turn to clear out the queue, then serialize access.
759 */
760 while (softdep_worklist_busy) {
761 softdep_worklist_req += 1;
762 tsleep(&softdep_worklist_req, PRIBIO, "softflush", 0);
763 softdep_worklist_req -= 1;
764 }
765 softdep_worklist_busy = -1;
766 /*
767 * Alternately flush the block device associated with the mount
768 * point and process any dependencies that the flushing
769 * creates. We continue until no more worklist dependencies
770 * are found.
771 */
772 *countp = 0;
773 devvp = VFSTOUFS(oldmnt)->um_devvp;
774 while ((count = softdep_process_worklist(oldmnt)) > 0) {
775 *countp += count;
776 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
777 error = VOP_FSYNC(devvp, p->p_ucred, MNT_WAIT, p);
778 VOP_UNLOCK(devvp, 0, p);
779 if (error)
780 break;
781 }
782 softdep_worklist_busy = 0;
783 if (softdep_worklist_req)
784 wakeup(&softdep_worklist_req);
785 return (error);
786}
787
788/*
789 * Flush all vnodes and worklist items associated with a specified mount point.
790 */
791int
792softdep_flushfiles(oldmnt, flags, p)
793 struct mount *oldmnt;
794 int flags;
795 struct proc *p;
796{
797 int error, count, loopcnt;
798
799 /*
800 * Alternately flush the vnodes associated with the mount
801 * point and process any dependencies that the flushing
802 * creates. In theory, this loop can happen at most twice,
803 * but we give it a few extra just to be sure.
804 */
805 for (loopcnt = 10; loopcnt > 0; loopcnt--) {
806 /*
807 * Do another flush in case any vnodes were brought in
808 * as part of the cleanup operations.
809 */
810 if ((error = ffs_flushfiles(oldmnt, flags, p)) != 0)
811 break;
812 if ((error = softdep_flushworklist(oldmnt, &count, p)) != 0 ||
813 count == 0)
814 break;
815 }
816 /*
817 * If we are unmounting then it is an error to fail. If we
818 * are simply trying to downgrade to read-only, then filesystem
819 * activity can keep us busy forever, so we just fail with EBUSY.
820 */
821 if (loopcnt == 0) {
822 if (oldmnt->mnt_kern_flag & MNTK_UNMOUNT)
823 panic("softdep_flushfiles: looping");
824 error = EBUSY;
825 }
826 return (error);
827}
828
829/*
830 * Structure hashing.
831 *
832 * There are three types of structures that can be looked up:
833 * 1) pagedep structures identified by mount point, inode number,
834 * and logical block.
835 * 2) inodedep structures identified by mount point and inode number.
836 * 3) newblk structures identified by mount point and
837 * physical block number.
838 *
839 * The "pagedep" and "inodedep" dependency structures are hashed
840 * separately from the file blocks and inodes to which they correspond.
841 * This separation helps when the in-memory copy of an inode or
842 * file block must be replaced. It also obviates the need to access
843 * an inode or file page when simply updating (or de-allocating)
844 * dependency structures. Lookup of newblk structures is needed to
845 * find newly allocated blocks when trying to associate them with
846 * their allocdirect or allocindir structure.
847 *
848 * The lookup routines optionally create and hash a new instance when
849 * an existing entry is not found.
850 */
851#define DEPALLOC 0x0001 /* allocate structure if lookup fails */
852#define NODELAY 0x0002 /* cannot do background work */
853
854/*
855 * Structures and routines associated with pagedep caching.
856 */
857LIST_HEAD(pagedep_hashhead, pagedep) *pagedep_hashtbl;
858u_long pagedep_hash; /* size of hash table - 1 */
859#define PAGEDEP_HASH(mp, inum, lbn) \
860 (&pagedep_hashtbl[((((register_t)(mp)) >> 13) + (inum) + (lbn)) & \
861 pagedep_hash])
862static struct sema pagedep_in_progress;
863
864/*
865 * Look up a pagedep. Return 1 if found, 0 if not found.
866 * If not found, allocate if DEPALLOC flag is passed.
867 * Found or allocated entry is returned in pagedeppp.
868 * This routine must be called with splbio interrupts blocked.
869 */
870static int
871pagedep_lookup(ip, lbn, flags, pagedeppp)
872 struct inode *ip;
873 ufs_lbn_t lbn;
874 int flags;
875 struct pagedep **pagedeppp;
876{
877 struct pagedep *pagedep;
878 struct pagedep_hashhead *pagedephd;
879 struct mount *mp;
880 int i;
881
882#ifdef DEBUG
883 if (lk.lkt_held == -1)
884 panic("pagedep_lookup: lock not held");
885#endif
886 mp = ITOV(ip)->v_mount;
887 pagedephd = PAGEDEP_HASH(mp, ip->i_number, lbn);
888top:
889 LIST_FOREACH(pagedep, pagedephd, pd_hash)
890 if (ip->i_number == pagedep->pd_ino &&
891 lbn == pagedep->pd_lbn &&
892 mp == pagedep->pd_mnt)
893 break;
894 if (pagedep) {
895 *pagedeppp = pagedep;
896 return (1);
897 }
898 if ((flags & DEPALLOC) == 0) {
899 *pagedeppp = NULL;
900 return (0);
901 }
902 if (sema_get(&pagedep_in_progress, &lk) == 0) {
903 ACQUIRE_LOCK(&lk);
904 goto top;
905 }
906 MALLOC(pagedep, struct pagedep *, sizeof(struct pagedep), M_PAGEDEP,
907 M_SOFTDEP_FLAGS|M_ZERO);
908 pagedep->pd_list.wk_type = D_PAGEDEP;
909 pagedep->pd_mnt = mp;
910 pagedep->pd_ino = ip->i_number;
911 pagedep->pd_lbn = lbn;
912 LIST_INIT(&pagedep->pd_dirremhd);
913 LIST_INIT(&pagedep->pd_pendinghd);
914 for (i = 0; i < DAHASHSZ; i++)
915 LIST_INIT(&pagedep->pd_diraddhd[i]);
916 ACQUIRE_LOCK(&lk);
917 LIST_INSERT_HEAD(pagedephd, pagedep, pd_hash);
918 sema_release(&pagedep_in_progress);
919 *pagedeppp = pagedep;
920 return (0);
921}
922
923/*
924 * Structures and routines associated with inodedep caching.
925 */
926LIST_HEAD(inodedep_hashhead, inodedep) *inodedep_hashtbl;
927static u_long inodedep_hash; /* size of hash table - 1 */
928static long num_inodedep; /* number of inodedep allocated */
929#define INODEDEP_HASH(fs, inum) \
930 (&inodedep_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & inodedep_hash])
931static struct sema inodedep_in_progress;
932
933/*
934 * Look up a inodedep. Return 1 if found, 0 if not found.
935 * If not found, allocate if DEPALLOC flag is passed.
936 * Found or allocated entry is returned in inodedeppp.
937 * This routine must be called with splbio interrupts blocked.
938 */
939static int
940inodedep_lookup(fs, inum, flags, inodedeppp)
941 struct fs *fs;
942 ino_t inum;
943 int flags;
944 struct inodedep **inodedeppp;
945{
946 struct inodedep *inodedep;
947 struct inodedep_hashhead *inodedephd;
948 int firsttry;
949
950#ifdef DEBUG
951 if (lk.lkt_held == -1)
952 panic("inodedep_lookup: lock not held");
953#endif
954 firsttry = 1;
955 inodedephd = INODEDEP_HASH(fs, inum);
956top:
957 LIST_FOREACH(inodedep, inodedephd, id_hash)
958 if (inum == inodedep->id_ino && fs == inodedep->id_fs)
959 break;
960 if (inodedep) {
961 *inodedeppp = inodedep;
962 return (1);
963 }
964 if ((flags & DEPALLOC) == 0) {
965 *inodedeppp = NULL;
966 return (0);
967 }
968 /*
969 * If we are over our limit, try to improve the situation.
970 */
971 if (num_inodedep > max_softdeps && firsttry && (flags & NODELAY) == 0 &&
972 request_cleanup(FLUSH_INODES, 1)) {
973 firsttry = 0;
974 goto top;
975 }
976 if (sema_get(&inodedep_in_progress, &lk) == 0) {
977 ACQUIRE_LOCK(&lk);
978 goto top;
979 }
980 num_inodedep += 1;
981 MALLOC(inodedep, struct inodedep *, sizeof(struct inodedep),
982 M_INODEDEP, M_SOFTDEP_FLAGS);
983 inodedep->id_list.wk_type = D_INODEDEP;
984 inodedep->id_fs = fs;
985 inodedep->id_ino = inum;
986 inodedep->id_state = ALLCOMPLETE;
987 inodedep->id_nlinkdelta = 0;
988 inodedep->id_savedino = NULL;
989 inodedep->id_savedsize = -1;
990 inodedep->id_buf = NULL;
991 LIST_INIT(&inodedep->id_pendinghd);
992 LIST_INIT(&inodedep->id_inowait);
993 LIST_INIT(&inodedep->id_bufwait);
994 TAILQ_INIT(&inodedep->id_inoupdt);
995 TAILQ_INIT(&inodedep->id_newinoupdt);
996 ACQUIRE_LOCK(&lk);
997 LIST_INSERT_HEAD(inodedephd, inodedep, id_hash);
998 sema_release(&inodedep_in_progress);
999 *inodedeppp = inodedep;
1000 return (0);
1001}
1002
1003/*
1004 * Structures and routines associated with newblk caching.
1005 */
1006LIST_HEAD(newblk_hashhead, newblk) *newblk_hashtbl;
1007u_long newblk_hash; /* size of hash table - 1 */
1008#define NEWBLK_HASH(fs, inum) \
1009 (&newblk_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & newblk_hash])
1010static struct sema newblk_in_progress;
1011
1012/*
1013 * Look up a newblk. Return 1 if found, 0 if not found.
1014 * If not found, allocate if DEPALLOC flag is passed.
1015 * Found or allocated entry is returned in newblkpp.
1016 */
1017static int
1018newblk_lookup(fs, newblkno, flags, newblkpp)
1019 struct fs *fs;
1020 ufs_daddr_t newblkno;
1021 int flags;
1022 struct newblk **newblkpp;
1023{
1024 struct newblk *newblk;
1025 struct newblk_hashhead *newblkhd;
1026
1027 newblkhd = NEWBLK_HASH(fs, newblkno);
1028top:
1029 LIST_FOREACH(newblk, newblkhd, nb_hash)
1030 if (newblkno == newblk->nb_newblkno && fs == newblk->nb_fs)
1031 break;
1032 if (newblk) {
1033 *newblkpp = newblk;
1034 return (1);
1035 }
1036 if ((flags & DEPALLOC) == 0) {
1037 *newblkpp = NULL;
1038 return (0);
1039 }
1040 if (sema_get(&newblk_in_progress, 0) == 0)
1041 goto top;
1042 MALLOC(newblk, struct newblk *, sizeof(struct newblk),
1043 M_NEWBLK, M_SOFTDEP_FLAGS);
1044 newblk->nb_state = 0;
1045 newblk->nb_fs = fs;
1046 newblk->nb_newblkno = newblkno;
1047 LIST_INSERT_HEAD(newblkhd, newblk, nb_hash);
1048 sema_release(&newblk_in_progress);
1049 *newblkpp = newblk;
1050 return (0);
1051}
1052
1053/*
1054 * Executed during filesystem system initialization before
1055 * mounting any file systems.
1056 */
1057void
1058softdep_initialize()
1059{
1060
1061 LIST_INIT(&mkdirlisthd);
1062 LIST_INIT(&softdep_workitem_pending);
1063 max_softdeps = min(desiredvnodes * 8,
1064 M_INODEDEP->ks_limit / (2 * sizeof(struct inodedep)));
1065 pagedep_hashtbl = hashinit(desiredvnodes / 5, M_PAGEDEP,
1066 &pagedep_hash);
1067 sema_init(&pagedep_in_progress, "pagedep", PRIBIO, 0);
1068 inodedep_hashtbl = hashinit(desiredvnodes, M_INODEDEP, &inodedep_hash);
1069 sema_init(&inodedep_in_progress, "inodedep", PRIBIO, 0);
1070 newblk_hashtbl = hashinit(64, M_NEWBLK, &newblk_hash);
1071 sema_init(&newblk_in_progress, "newblk", PRIBIO, 0);
1072}
1073
1074/*
1075 * Called at mount time to notify the dependency code that a
1076 * filesystem wishes to use it.
1077 */
1078int
1079softdep_mount(devvp, mp, fs, cred)
1080 struct vnode *devvp;
1081 struct mount *mp;
1082 struct fs *fs;
1083 struct ucred *cred;
1084{
1085 struct csum cstotal;
1086 struct cg *cgp;
1087 struct buf *bp;
1088 int error, cyl;
1089
1090 mp->mnt_flag &= ~MNT_ASYNC;
1091 mp->mnt_flag |= MNT_SOFTDEP;
1092 /*
1093 * When doing soft updates, the counters in the
1094 * superblock may have gotten out of sync, so we have
1095 * to scan the cylinder groups and recalculate them.
1096 */
1097 if (fs->fs_clean != 0)
1098 return (0);
1099 bzero(&cstotal, sizeof cstotal);
1100 for (cyl = 0; cyl < fs->fs_ncg; cyl++) {
1101 if ((error = bread(devvp, fsbtodb(fs, cgtod(fs, cyl)),
1102 fs->fs_cgsize, cred, &bp)) != 0) {
1103 brelse(bp);
1104 return (error);
1105 }
1106 cgp = (struct cg *)bp->b_data;
1107 cstotal.cs_nffree += cgp->cg_cs.cs_nffree;
1108 cstotal.cs_nbfree += cgp->cg_cs.cs_nbfree;
1109 cstotal.cs_nifree += cgp->cg_cs.cs_nifree;
1110 cstotal.cs_ndir += cgp->cg_cs.cs_ndir;
1111 fs->fs_cs(fs, cyl) = cgp->cg_cs;
1112 brelse(bp);
1113 }
1114#ifdef DEBUG
1115 if (bcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal))
1116 printf("%s: superblock summary recomputed\n", fs->fs_fsmnt);
1117#endif
1118 bcopy(&cstotal, &fs->fs_cstotal, sizeof cstotal);
1119 return (0);
1120}
1121
1122/*
1123 * Protecting the freemaps (or bitmaps).
1124 *
1125 * To eliminate the need to execute fsck before mounting a file system
1126 * after a power failure, one must (conservatively) guarantee that the
1127 * on-disk copy of the bitmaps never indicate that a live inode or block is
1128 * free. So, when a block or inode is allocated, the bitmap should be
1129 * updated (on disk) before any new pointers. When a block or inode is
1130 * freed, the bitmap should not be updated until all pointers have been
1131 * reset. The latter dependency is handled by the delayed de-allocation
1132 * approach described below for block and inode de-allocation. The former
1133 * dependency is handled by calling the following procedure when a block or
1134 * inode is allocated. When an inode is allocated an "inodedep" is created
1135 * with its DEPCOMPLETE flag cleared until its bitmap is written to disk.
1136 * Each "inodedep" is also inserted into the hash indexing structure so
1137 * that any additional link additions can be made dependent on the inode
1138 * allocation.
1139 *
1140 * The ufs file system maintains a number of free block counts (e.g., per
1141 * cylinder group, per cylinder and per <cylinder, rotational position> pair)
1142 * in addition to the bitmaps. These counts are used to improve efficiency
1143 * during allocation and therefore must be consistent with the bitmaps.
1144 * There is no convenient way to guarantee post-crash consistency of these
1145 * counts with simple update ordering, for two main reasons: (1) The counts
1146 * and bitmaps for a single cylinder group block are not in the same disk
1147 * sector. If a disk write is interrupted (e.g., by power failure), one may
1148 * be written and the other not. (2) Some of the counts are located in the
1149 * superblock rather than the cylinder group block. So, we focus our soft
1150 * updates implementation on protecting the bitmaps. When mounting a
1151 * filesystem, we recompute the auxiliary counts from the bitmaps.
1152 */
1153
1154/*
1155 * Called just after updating the cylinder group block to allocate an inode.
1156 */
1157void
1158softdep_setup_inomapdep(bp, ip, newinum)
1159 struct buf *bp; /* buffer for cylgroup block with inode map */
1160 struct inode *ip; /* inode related to allocation */
1161 ino_t newinum; /* new inode number being allocated */
1162{
1163 struct inodedep *inodedep;
1164 struct bmsafemap *bmsafemap;
1165
1166 /*
1167 * Create a dependency for the newly allocated inode.
1168 * Panic if it already exists as something is seriously wrong.
1169 * Otherwise add it to the dependency list for the buffer holding
1170 * the cylinder group map from which it was allocated.
1171 */
1172 ACQUIRE_LOCK(&lk);
1173 if ((inodedep_lookup(ip->i_fs, newinum, DEPALLOC|NODELAY, &inodedep))) {
1174 FREE_LOCK(&lk);
1175 panic("softdep_setup_inomapdep: found inode");
1176 }
1177 inodedep->id_buf = bp;
1178 inodedep->id_state &= ~DEPCOMPLETE;
1179 bmsafemap = bmsafemap_lookup(bp);
1180 LIST_INSERT_HEAD(&bmsafemap->sm_inodedephd, inodedep, id_deps);
1181 FREE_LOCK(&lk);
1182}
1183
1184/*
1185 * Called just after updating the cylinder group block to
1186 * allocate block or fragment.
1187 */
1188void
1189softdep_setup_blkmapdep(bp, fs, newblkno)
1190 struct buf *bp; /* buffer for cylgroup block with block map */
1191 struct fs *fs; /* filesystem doing allocation */
1192 ufs_daddr_t newblkno; /* number of newly allocated block */
1193{
1194 struct newblk *newblk;
1195 struct bmsafemap *bmsafemap;
1196
1197 /*
1198 * Create a dependency for the newly allocated block.
1199 * Add it to the dependency list for the buffer holding
1200 * the cylinder group map from which it was allocated.
1201 */
1202 if (newblk_lookup(fs, newblkno, DEPALLOC, &newblk) != 0)
1203 panic("softdep_setup_blkmapdep: found block");
1204 ACQUIRE_LOCK(&lk);
1205 newblk->nb_bmsafemap = bmsafemap = bmsafemap_lookup(bp);
1206 LIST_INSERT_HEAD(&bmsafemap->sm_newblkhd, newblk, nb_deps);
1207 FREE_LOCK(&lk);
1208}
1209
1210/*
1211 * Find the bmsafemap associated with a cylinder group buffer.
1212 * If none exists, create one. The buffer must be locked when
1213 * this routine is called and this routine must be called with
1214 * splbio interrupts blocked.
1215 */
1216static struct bmsafemap *
1217bmsafemap_lookup(bp)
1218 struct buf *bp;
1219{
1220 struct bmsafemap *bmsafemap;
1221 struct worklist *wk;
1222
1223#ifdef DEBUG
1224 if (lk.lkt_held == -1)
1225 panic("bmsafemap_lookup: lock not held");
1226#endif
1227 LIST_FOREACH(wk, &bp->b_dep, wk_list)
1228 if (wk->wk_type == D_BMSAFEMAP)
1229 return (WK_BMSAFEMAP(wk));
1230 FREE_LOCK(&lk);
1231 MALLOC(bmsafemap, struct bmsafemap *, sizeof(struct bmsafemap),
1232 M_BMSAFEMAP, M_SOFTDEP_FLAGS);
1233 bmsafemap->sm_list.wk_type = D_BMSAFEMAP;
1234 bmsafemap->sm_list.wk_state = 0;
1235 bmsafemap->sm_buf = bp;
1236 LIST_INIT(&bmsafemap->sm_allocdirecthd);
1237 LIST_INIT(&bmsafemap->sm_allocindirhd);
1238 LIST_INIT(&bmsafemap->sm_inodedephd);
1239 LIST_INIT(&bmsafemap->sm_newblkhd);
1240 ACQUIRE_LOCK(&lk);
1241 WORKLIST_INSERT(&bp->b_dep, &bmsafemap->sm_list);
1242 return (bmsafemap);
1243}
1244
1245/*
1246 * Direct block allocation dependencies.
1247 *
1248 * When a new block is allocated, the corresponding disk locations must be
1249 * initialized (with zeros or new data) before the on-disk inode points to
1250 * them. Also, the freemap from which the block was allocated must be
1251 * updated (on disk) before the inode's pointer. These two dependencies are
1252 * independent of each other and are needed for all file blocks and indirect
1253 * blocks that are pointed to directly by the inode. Just before the
1254 * "in-core" version of the inode is updated with a newly allocated block
1255 * number, a procedure (below) is called to setup allocation dependency
1256 * structures. These structures are removed when the corresponding
1257 * dependencies are satisfied or when the block allocation becomes obsolete
1258 * (i.e., the file is deleted, the block is de-allocated, or the block is a
1259 * fragment that gets upgraded). All of these cases are handled in
1260 * procedures described later.
1261 *
1262 * When a file extension causes a fragment to be upgraded, either to a larger
1263 * fragment or to a full block, the on-disk location may change (if the
1264 * previous fragment could not simply be extended). In this case, the old
1265 * fragment must be de-allocated, but not until after the inode's pointer has
1266 * been updated. In most cases, this is handled by later procedures, which
1267 * will construct a "freefrag" structure to be added to the workitem queue
1268 * when the inode update is complete (or obsolete). The main exception to
1269 * this is when an allocation occurs while a pending allocation dependency
1270 * (for the same block pointer) remains. This case is handled in the main
1271 * allocation dependency setup procedure by immediately freeing the
1272 * unreferenced fragments.
1273 */
1274void
1275softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp)
1276 struct inode *ip; /* inode to which block is being added */
1277 ufs_lbn_t lbn; /* block pointer within inode */
1278 ufs_daddr_t newblkno; /* disk block number being added */
1279 ufs_daddr_t oldblkno; /* previous block number, 0 unless frag */
1280 long newsize; /* size of new block */
1281 long oldsize; /* size of new block */
1282 struct buf *bp; /* bp for allocated block */
1283{
1284 struct allocdirect *adp, *oldadp;
1285 struct allocdirectlst *adphead;
1286 struct bmsafemap *bmsafemap;
1287 struct inodedep *inodedep;
1288 struct pagedep *pagedep;
1289 struct newblk *newblk;
1290
1291 MALLOC(adp, struct allocdirect *, sizeof(struct allocdirect),
1292 M_ALLOCDIRECT, M_SOFTDEP_FLAGS|M_ZERO);
1293 adp->ad_list.wk_type = D_ALLOCDIRECT;
1294 adp->ad_lbn = lbn;
1295 adp->ad_newblkno = newblkno;
1296 adp->ad_oldblkno = oldblkno;
1297 adp->ad_newsize = newsize;
1298 adp->ad_oldsize = oldsize;
1299 adp->ad_state = ATTACHED;
1300 if (newblkno == oldblkno)
1301 adp->ad_freefrag = NULL;
1302 else
1303 adp->ad_freefrag = newfreefrag(ip, oldblkno, oldsize);
1304
1305 if (newblk_lookup(ip->i_fs, newblkno, 0, &newblk) == 0)
1306 panic("softdep_setup_allocdirect: lost block");
1307
1308 ACQUIRE_LOCK(&lk);
1309 inodedep_lookup(ip->i_fs, ip->i_number, DEPALLOC | NODELAY, &inodedep);
1310 adp->ad_inodedep = inodedep;
1311
1312 if (newblk->nb_state == DEPCOMPLETE) {
1313 adp->ad_state |= DEPCOMPLETE;
1314 adp->ad_buf = NULL;
1315 } else {
1316 bmsafemap = newblk->nb_bmsafemap;
1317 adp->ad_buf = bmsafemap->sm_buf;
1318 LIST_REMOVE(newblk, nb_deps);
1319 LIST_INSERT_HEAD(&bmsafemap->sm_allocdirecthd, adp, ad_deps);
1320 }
1321 LIST_REMOVE(newblk, nb_hash);
1322 FREE(newblk, M_NEWBLK);
1323
1324 WORKLIST_INSERT(&bp->b_dep, &adp->ad_list);
1325 if (lbn >= NDADDR) {
1326 /* allocating an indirect block */
1327 if (oldblkno != 0) {
1328 FREE_LOCK(&lk);
1329 panic("softdep_setup_allocdirect: non-zero indir");
1330 }
1331 } else {
1332 /*
1333 * Allocating a direct block.
1334 *
1335 * If we are allocating a directory block, then we must
1336 * allocate an associated pagedep to track additions and
1337 * deletions.
1338 */
1339 if ((ip->i_mode & IFMT) == IFDIR &&
1340 pagedep_lookup(ip, lbn, DEPALLOC, &pagedep) == 0)
1341 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
1342 }
1343 /*
1344 * The list of allocdirects must be kept in sorted and ascending
1345 * order so that the rollback routines can quickly determine the
1346 * first uncommitted block (the size of the file stored on disk
1347 * ends at the end of the lowest committed fragment, or if there
1348 * are no fragments, at the end of the highest committed block).
1349 * Since files generally grow, the typical case is that the new
1350 * block is to be added at the end of the list. We speed this
1351 * special case by checking against the last allocdirect in the
1352 * list before laboriously traversing the list looking for the
1353 * insertion point.
1354 */
1355 adphead = &inodedep->id_newinoupdt;
1356 oldadp = TAILQ_LAST(adphead, allocdirectlst);
1357 if (oldadp == NULL || oldadp->ad_lbn <= lbn) {
1358 /* insert at end of list */
1359 TAILQ_INSERT_TAIL(adphead, adp, ad_next);
1360 if (oldadp != NULL && oldadp->ad_lbn == lbn)
1361 allocdirect_merge(adphead, adp, oldadp);
1362 FREE_LOCK(&lk);
1363 return;
1364 }
1365 TAILQ_FOREACH(oldadp, adphead, ad_next) {
1366 if (oldadp->ad_lbn >= lbn)
1367 break;
1368 }
1369 if (oldadp == NULL) {
1370 FREE_LOCK(&lk);
1371 panic("softdep_setup_allocdirect: lost entry");
1372 }
1373 /* insert in middle of list */
1374 TAILQ_INSERT_BEFORE(oldadp, adp, ad_next);
1375 if (oldadp->ad_lbn == lbn)
1376 allocdirect_merge(adphead, adp, oldadp);
1377 FREE_LOCK(&lk);
1378}
1379
1380/*
1381 * Replace an old allocdirect dependency with a newer one.
1382 * This routine must be called with splbio interrupts blocked.
1383 */
1384static void
1385allocdirect_merge(adphead, newadp, oldadp)
1386 struct allocdirectlst *adphead; /* head of list holding allocdirects */
1387 struct allocdirect *newadp; /* allocdirect being added */
1388 struct allocdirect *oldadp; /* existing allocdirect being checked */
1389{
1390 struct freefrag *freefrag;
1391
1392#ifdef DEBUG
1393 if (lk.lkt_held == -1)
1394 panic("allocdirect_merge: lock not held");
1395#endif
1396 if (newadp->ad_oldblkno != oldadp->ad_newblkno ||
1397 newadp->ad_oldsize != oldadp->ad_newsize ||
1398 newadp->ad_lbn >= NDADDR) {
1399 FREE_LOCK(&lk);
1400 panic("allocdirect_check: old %d != new %d || lbn %ld >= %d",
1401 newadp->ad_oldblkno, oldadp->ad_newblkno, newadp->ad_lbn,
1402 NDADDR);
1403 }
1404 newadp->ad_oldblkno = oldadp->ad_oldblkno;
1405 newadp->ad_oldsize = oldadp->ad_oldsize;
1406 /*
1407 * If the old dependency had a fragment to free or had never
1408 * previously had a block allocated, then the new dependency
1409 * can immediately post its freefrag and adopt the old freefrag.
1410 * This action is done by swapping the freefrag dependencies.
1411 * The new dependency gains the old one's freefrag, and the
1412 * old one gets the new one and then immediately puts it on
1413 * the worklist when it is freed by free_allocdirect. It is
1414 * not possible to do this swap when the old dependency had a
1415 * non-zero size but no previous fragment to free. This condition
1416 * arises when the new block is an extension of the old block.
1417 * Here, the first part of the fragment allocated to the new
1418 * dependency is part of the block currently claimed on disk by
1419 * the old dependency, so cannot legitimately be freed until the
1420 * conditions for the new dependency are fulfilled.
1421 */
1422 if (oldadp->ad_freefrag != NULL || oldadp->ad_oldblkno == 0) {
1423 freefrag = newadp->ad_freefrag;
1424 newadp->ad_freefrag = oldadp->ad_freefrag;
1425 oldadp->ad_freefrag = freefrag;
1426 }
1427 free_allocdirect(adphead, oldadp, 0);
1428}
1429
1430/*
1431 * Allocate a new freefrag structure if needed.
1432 */
1433static struct freefrag *
1434newfreefrag(ip, blkno, size)
1435 struct inode *ip;
1436 ufs_daddr_t blkno;
1437 long size;
1438{
1439 struct freefrag *freefrag;
1440 struct fs *fs;
1441
1442 if (blkno == 0)
1443 return (NULL);
1444 fs = ip->i_fs;
1445 if (fragnum(fs, blkno) + numfrags(fs, size) > fs->fs_frag)
1446 panic("newfreefrag: frag size");
1447 MALLOC(freefrag, struct freefrag *, sizeof(struct freefrag),
1448 M_FREEFRAG, M_SOFTDEP_FLAGS);
1449 freefrag->ff_list.wk_type = D_FREEFRAG;
1450 freefrag->ff_state = ip->i_uid & ~ONWORKLIST; /* XXX - used below */
1451 freefrag->ff_inum = ip->i_number;
1452 freefrag->ff_mnt = ITOV(ip)->v_mount;
1453 freefrag->ff_devvp = ip->i_devvp;
1454 freefrag->ff_blkno = blkno;
1455 freefrag->ff_fragsize = size;
1456 return (freefrag);
1457}
1458
1459/*
1460 * This workitem de-allocates fragments that were replaced during
1461 * file block allocation.
1462 */
1463static void
1464handle_workitem_freefrag(freefrag)
1465 struct freefrag *freefrag;
1466{
1467 struct inode tip;
1468
1469 tip.i_vnode = NULL;
1470 tip.i_fs = VFSTOUFS(freefrag->ff_mnt)->um_fs;
1471 tip.i_devvp = freefrag->ff_devvp;
1472 tip.i_dev = freefrag->ff_devvp->v_rdev;
1473 tip.i_number = freefrag->ff_inum;
1474 tip.i_uid = freefrag->ff_state & ~ONWORKLIST; /* XXX - set above */
1475 ffs_blkfree(&tip, freefrag->ff_blkno, freefrag->ff_fragsize);
1476 FREE(freefrag, M_FREEFRAG);
1477}
1478
1479/*
1480 * Indirect block allocation dependencies.
1481 *
1482 * The same dependencies that exist for a direct block also exist when
1483 * a new block is allocated and pointed to by an entry in a block of
1484 * indirect pointers. The undo/redo states described above are also
1485 * used here. Because an indirect block contains many pointers that
1486 * may have dependencies, a second copy of the entire in-memory indirect
1487 * block is kept. The buffer cache copy is always completely up-to-date.
1488 * The second copy, which is used only as a source for disk writes,
1489 * contains only the safe pointers (i.e., those that have no remaining
1490 * update dependencies). The second copy is freed when all pointers
1491 * are safe. The cache is not allowed to replace indirect blocks with
1492 * pending update dependencies. If a buffer containing an indirect
1493 * block with dependencies is written, these routines will mark it
1494 * dirty again. It can only be successfully written once all the
1495 * dependencies are removed. The ffs_fsync routine in conjunction with
1496 * softdep_sync_metadata work together to get all the dependencies
1497 * removed so that a file can be successfully written to disk. Three
1498 * procedures are used when setting up indirect block pointer
1499 * dependencies. The division is necessary because of the organization
1500 * of the "balloc" routine and because of the distinction between file
1501 * pages and file metadata blocks.
1502 */
1503
1504/*
1505 * Allocate a new allocindir structure.
1506 */
1507static struct allocindir *
1508newallocindir(ip, ptrno, newblkno, oldblkno)
1509 struct inode *ip; /* inode for file being extended */
1510 int ptrno; /* offset of pointer in indirect block */
1511 ufs_daddr_t newblkno; /* disk block number being added */
1512 ufs_daddr_t oldblkno; /* previous block number, 0 if none */
1513{
1514 struct allocindir *aip;
1515
1516 MALLOC(aip, struct allocindir *, sizeof(struct allocindir),
1517 M_ALLOCINDIR, M_SOFTDEP_FLAGS|M_ZERO);
1518 aip->ai_list.wk_type = D_ALLOCINDIR;
1519 aip->ai_state = ATTACHED;
1520 aip->ai_offset = ptrno;
1521 aip->ai_newblkno = newblkno;
1522 aip->ai_oldblkno = oldblkno;
1523 aip->ai_freefrag = newfreefrag(ip, oldblkno, ip->i_fs->fs_bsize);
1524 return (aip);
1525}
1526
1527/*
1528 * Called just before setting an indirect block pointer
1529 * to a newly allocated file page.
1530 */
1531void
1532softdep_setup_allocindir_page(ip, lbn, bp, ptrno, newblkno, oldblkno, nbp)
1533 struct inode *ip; /* inode for file being extended */
1534 ufs_lbn_t lbn; /* allocated block number within file */
1535 struct buf *bp; /* buffer with indirect blk referencing page */
1536 int ptrno; /* offset of pointer in indirect block */
1537 ufs_daddr_t newblkno; /* disk block number being added */
1538 ufs_daddr_t oldblkno; /* previous block number, 0 if none */
1539 struct buf *nbp; /* buffer holding allocated page */
1540{
1541 struct allocindir *aip;
1542 struct pagedep *pagedep;
1543
1544 aip = newallocindir(ip, ptrno, newblkno, oldblkno);
1545 ACQUIRE_LOCK(&lk);
1546 /*
1547 * If we are allocating a directory page, then we must
1548 * allocate an associated pagedep to track additions and
1549 * deletions.
1550 */
1551 if ((ip->i_mode & IFMT) == IFDIR &&
1552 pagedep_lookup(ip, lbn, DEPALLOC, &pagedep) == 0)
1553 WORKLIST_INSERT(&nbp->b_dep, &pagedep->pd_list);
1554 WORKLIST_INSERT(&nbp->b_dep, &aip->ai_list);
1555 FREE_LOCK(&lk);
1556 setup_allocindir_phase2(bp, ip, aip);
1557}
1558
1559/*
1560 * Called just before setting an indirect block pointer to a
1561 * newly allocated indirect block.
1562 */
1563void
1564softdep_setup_allocindir_meta(nbp, ip, bp, ptrno, newblkno)
1565 struct buf *nbp; /* newly allocated indirect block */
1566 struct inode *ip; /* inode for file being extended */
1567 struct buf *bp; /* indirect block referencing allocated block */
1568 int ptrno; /* offset of pointer in indirect block */
1569 ufs_daddr_t newblkno; /* disk block number being added */
1570{
1571 struct allocindir *aip;
1572
1573 aip = newallocindir(ip, ptrno, newblkno, 0);
1574 ACQUIRE_LOCK(&lk);
1575 WORKLIST_INSERT(&nbp->b_dep, &aip->ai_list);
1576 FREE_LOCK(&lk);
1577 setup_allocindir_phase2(bp, ip, aip);
1578}
1579
1580/*
1581 * Called to finish the allocation of the "aip" allocated
1582 * by one of the two routines above.
1583 */
1584static void
1585setup_allocindir_phase2(bp, ip, aip)
1586 struct buf *bp; /* in-memory copy of the indirect block */
1587 struct inode *ip; /* inode for file being extended */
1588 struct allocindir *aip; /* allocindir allocated by the above routines */
1589{
1590 struct worklist *wk;
1591 struct indirdep *indirdep, *newindirdep;
1592 struct bmsafemap *bmsafemap;
1593 struct allocindir *oldaip;
1594 struct freefrag *freefrag;
1595 struct newblk *newblk;
1596
1597 if (bp->b_lblkno >= 0)
1598 panic("setup_allocindir_phase2: not indir blk");
1599 for (indirdep = NULL, newindirdep = NULL; ; ) {
1600 ACQUIRE_LOCK(&lk);
1601 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
1602 if (wk->wk_type != D_INDIRDEP)
1603 continue;
1604 indirdep = WK_INDIRDEP(wk);
1605 break;
1606 }
1607 if (indirdep == NULL && newindirdep) {
1608 indirdep = newindirdep;
1609 WORKLIST_INSERT(&bp->b_dep, &indirdep->ir_list);
1610 newindirdep = NULL;
1611 }
1612 FREE_LOCK(&lk);
1613 if (indirdep) {
1614 if (newblk_lookup(ip->i_fs, aip->ai_newblkno, 0,
1615 &newblk) == 0)
1616 panic("setup_allocindir: lost block");
1617 ACQUIRE_LOCK(&lk);
1618 if (newblk->nb_state == DEPCOMPLETE) {
1619 aip->ai_state |= DEPCOMPLETE;
1620 aip->ai_buf = NULL;
1621 } else {
1622 bmsafemap = newblk->nb_bmsafemap;
1623 aip->ai_buf = bmsafemap->sm_buf;
1624 LIST_REMOVE(newblk, nb_deps);
1625 LIST_INSERT_HEAD(&bmsafemap->sm_allocindirhd,
1626 aip, ai_deps);
1627 }
1628 LIST_REMOVE(newblk, nb_hash);
1629 FREE(newblk, M_NEWBLK);
1630 aip->ai_indirdep = indirdep;
1631 /*
1632 * Check to see if there is an existing dependency
1633 * for this block. If there is, merge the old
1634 * dependency into the new one.
1635 */
1636 if (aip->ai_oldblkno == 0)
1637 oldaip = NULL;
1638 else
1639
1640 LIST_FOREACH(oldaip, &indirdep->ir_deplisthd, ai_next)
1641 if (oldaip->ai_offset == aip->ai_offset)
1642 break;
1643 freefrag = NULL;
1644 if (oldaip != NULL) {
1645 if (oldaip->ai_newblkno != aip->ai_oldblkno) {
1646 FREE_LOCK(&lk);
1647 panic("setup_allocindir_phase2: blkno");
1648 }
1649 aip->ai_oldblkno = oldaip->ai_oldblkno;
1650 freefrag = aip->ai_freefrag;
1651 aip->ai_freefrag = oldaip->ai_freefrag;
1652 oldaip->ai_freefrag = NULL;
1653 free_allocindir(oldaip, NULL);
1654 }
1655 LIST_INSERT_HEAD(&indirdep->ir_deplisthd, aip, ai_next);
1656 ((ufs_daddr_t *)indirdep->ir_savebp->b_data)
1657 [aip->ai_offset] = aip->ai_oldblkno;
1658 FREE_LOCK(&lk);
1659 if (freefrag != NULL)
1660 handle_workitem_freefrag(freefrag);
1661 }
1662 if (newindirdep) {
1663 if (indirdep->ir_savebp != NULL)
1664 brelse(newindirdep->ir_savebp);
1665 WORKITEM_FREE((caddr_t)newindirdep, D_INDIRDEP);
1666 }
1667 if (indirdep)
1668 break;
1669 MALLOC(newindirdep, struct indirdep *, sizeof(struct indirdep),
1670 M_INDIRDEP, M_SOFTDEP_FLAGS);
1671 newindirdep->ir_list.wk_type = D_INDIRDEP;
1672 newindirdep->ir_state = ATTACHED;
1673 LIST_INIT(&newindirdep->ir_deplisthd);
1674 LIST_INIT(&newindirdep->ir_donehd);
1675 if (bp->b_blkno == bp->b_lblkno)
1676 ufs_bmaparray(bp->b_vp, bp->b_lblkno, &bp->b_blkno, NULL, NULL);
1677 newindirdep->ir_savebp =
1678 getblk(ip->i_devvp, bp->b_blkno, bp->b_bcount, 0, 0);
1679 BUF_KERNPROC(newindirdep->ir_savebp);
1680 bcopy(bp->b_data, newindirdep->ir_savebp->b_data, bp->b_bcount);
1681 }
1682}
1683
1684/*
1685 * Block de-allocation dependencies.
1686 *
1687 * When blocks are de-allocated, the on-disk pointers must be nullified before
1688 * the blocks are made available for use by other files. (The true
1689 * requirement is that old pointers must be nullified before new on-disk
1690 * pointers are set. We chose this slightly more stringent requirement to
1691 * reduce complexity.) Our implementation handles this dependency by updating
1692 * the inode (or indirect block) appropriately but delaying the actual block
1693 * de-allocation (i.e., freemap and free space count manipulation) until
1694 * after the updated versions reach stable storage. After the disk is
1695 * updated, the blocks can be safely de-allocated whenever it is convenient.
1696 * This implementation handles only the common case of reducing a file's
1697 * length to zero. Other cases are handled by the conventional synchronous
1698 * write approach.
1699 *
1700 * The ffs implementation with which we worked double-checks
1701 * the state of the block pointers and file size as it reduces
1702 * a file's length. Some of this code is replicated here in our
1703 * soft updates implementation. The freeblks->fb_chkcnt field is
1704 * used to transfer a part of this information to the procedure
1705 * that eventually de-allocates the blocks.
1706 *
1707 * This routine should be called from the routine that shortens
1708 * a file's length, before the inode's size or block pointers
1709 * are modified. It will save the block pointer information for
1710 * later release and zero the inode so that the calling routine
1711 * can release it.
1712 */
1713void
1714softdep_setup_freeblocks(ip, length)
1715 struct inode *ip; /* The inode whose length is to be reduced */
1716 off_t length; /* The new length for the file */
1717{
1718 struct freeblks *freeblks;
1719 struct inodedep *inodedep;
1720 struct allocdirect *adp;
1721 struct vnode *vp;
1722 struct buf *bp;
1723 struct fs *fs;
1724 int i, delay, error;
1725
1726 fs = ip->i_fs;
1727 if (length != 0)
| 61#include <sys/syslog.h>
62#include <sys/vnode.h>
63#include <sys/conf.h>
64#include <ufs/ufs/dir.h>
65#include <ufs/ufs/extattr.h>
66#include <ufs/ufs/quota.h>
67#include <ufs/ufs/inode.h>
68#include <ufs/ufs/ufsmount.h>
69#include <ufs/ffs/fs.h>
70#include <ufs/ffs/softdep.h>
71#include <ufs/ffs/ffs_extern.h>
72#include <ufs/ufs/ufs_extern.h>
73
74/*
75 * These definitions need to be adapted to the system to which
76 * this file is being ported.
77 */
78/*
79 * malloc types defined for the softdep system.
80 */
81static MALLOC_DEFINE(M_PAGEDEP, "pagedep","File page dependencies");
82static MALLOC_DEFINE(M_INODEDEP, "inodedep","Inode dependencies");
83static MALLOC_DEFINE(M_NEWBLK, "newblk","New block allocation");
84static MALLOC_DEFINE(M_BMSAFEMAP, "bmsafemap","Block or frag allocated from cyl group map");
85static MALLOC_DEFINE(M_ALLOCDIRECT, "allocdirect","Block or frag dependency for an inode");
86static MALLOC_DEFINE(M_INDIRDEP, "indirdep","Indirect block dependencies");
87static MALLOC_DEFINE(M_ALLOCINDIR, "allocindir","Block dependency for an indirect block");
88static MALLOC_DEFINE(M_FREEFRAG, "freefrag","Previously used frag for an inode");
89static MALLOC_DEFINE(M_FREEBLKS, "freeblks","Blocks freed from an inode");
90static MALLOC_DEFINE(M_FREEFILE, "freefile","Inode deallocated");
91static MALLOC_DEFINE(M_DIRADD, "diradd","New directory entry");
92static MALLOC_DEFINE(M_MKDIR, "mkdir","New directory");
93static MALLOC_DEFINE(M_DIRREM, "dirrem","Directory entry deleted");
94
95#define M_SOFTDEP_FLAGS (M_WAITOK | M_USE_RESERVE)
96
97#define D_PAGEDEP 0
98#define D_INODEDEP 1
99#define D_NEWBLK 2
100#define D_BMSAFEMAP 3
101#define D_ALLOCDIRECT 4
102#define D_INDIRDEP 5
103#define D_ALLOCINDIR 6
104#define D_FREEFRAG 7
105#define D_FREEBLKS 8
106#define D_FREEFILE 9
107#define D_DIRADD 10
108#define D_MKDIR 11
109#define D_DIRREM 12
110#define D_LAST D_DIRREM
111
112/*
113 * translate from workitem type to memory type
114 * MUST match the defines above, such that memtype[D_XXX] == M_XXX
115 */
116static struct malloc_type *memtype[] = {
117 M_PAGEDEP,
118 M_INODEDEP,
119 M_NEWBLK,
120 M_BMSAFEMAP,
121 M_ALLOCDIRECT,
122 M_INDIRDEP,
123 M_ALLOCINDIR,
124 M_FREEFRAG,
125 M_FREEBLKS,
126 M_FREEFILE,
127 M_DIRADD,
128 M_MKDIR,
129 M_DIRREM
130};
131
132#define DtoM(type) (memtype[type])
133
134/*
135 * Names of malloc types.
136 */
137#define TYPENAME(type) \
138 ((unsigned)(type) < D_LAST ? memtype[type]->ks_shortdesc : "???")
139/*
140 * End system adaptaion definitions.
141 */
142
143/*
144 * Internal function prototypes.
145 */
146static void softdep_error __P((char *, int));
147static void drain_output __P((struct vnode *, int));
148static int getdirtybuf __P((struct buf **, int));
149static void clear_remove __P((struct proc *));
150static void clear_inodedeps __P((struct proc *));
151static int flush_pagedep_deps __P((struct vnode *, struct mount *,
152 struct diraddhd *));
153static int flush_inodedep_deps __P((struct fs *, ino_t));
154static int handle_written_filepage __P((struct pagedep *, struct buf *));
155static void diradd_inode_written __P((struct diradd *, struct inodedep *));
156static int handle_written_inodeblock __P((struct inodedep *, struct buf *));
157static void handle_allocdirect_partdone __P((struct allocdirect *));
158static void handle_allocindir_partdone __P((struct allocindir *));
159static void initiate_write_filepage __P((struct pagedep *, struct buf *));
160static void handle_written_mkdir __P((struct mkdir *, int));
161static void initiate_write_inodeblock __P((struct inodedep *, struct buf *));
162static void handle_workitem_freefile __P((struct freefile *));
163static void handle_workitem_remove __P((struct dirrem *));
164static struct dirrem *newdirrem __P((struct buf *, struct inode *,
165 struct inode *, int, struct dirrem **));
166static void free_diradd __P((struct diradd *));
167static void free_allocindir __P((struct allocindir *, struct inodedep *));
168static int indir_trunc __P((struct inode *, ufs_daddr_t, int, ufs_lbn_t,
169 long *));
170static void deallocate_dependencies __P((struct buf *, struct inodedep *));
171static void free_allocdirect __P((struct allocdirectlst *,
172 struct allocdirect *, int));
173static int check_inode_unwritten __P((struct inodedep *));
174static int free_inodedep __P((struct inodedep *));
175static void handle_workitem_freeblocks __P((struct freeblks *, int));
176static void merge_inode_lists __P((struct inodedep *));
177static void setup_allocindir_phase2 __P((struct buf *, struct inode *,
178 struct allocindir *));
179static struct allocindir *newallocindir __P((struct inode *, int, ufs_daddr_t,
180 ufs_daddr_t));
181static void handle_workitem_freefrag __P((struct freefrag *));
182static struct freefrag *newfreefrag __P((struct inode *, ufs_daddr_t, long));
183static void allocdirect_merge __P((struct allocdirectlst *,
184 struct allocdirect *, struct allocdirect *));
185static struct bmsafemap *bmsafemap_lookup __P((struct buf *));
186static int newblk_lookup __P((struct fs *, ufs_daddr_t, int,
187 struct newblk **));
188static int inodedep_lookup __P((struct fs *, ino_t, int, struct inodedep **));
189static int pagedep_lookup __P((struct inode *, ufs_lbn_t, int,
190 struct pagedep **));
191static void pause_timer __P((void *));
192static int request_cleanup __P((int, int));
193static int process_worklist_item __P((struct mount *, int));
194static void add_to_worklist __P((struct worklist *));
195
196/*
197 * Exported softdep operations.
198 */
199static void softdep_disk_io_initiation __P((struct buf *));
200static void softdep_disk_write_complete __P((struct buf *));
201static void softdep_deallocate_dependencies __P((struct buf *));
202static void softdep_move_dependencies __P((struct buf *, struct buf *));
203static int softdep_count_dependencies __P((struct buf *bp, int));
204
205struct bio_ops bioops = {
206 softdep_disk_io_initiation, /* io_start */
207 softdep_disk_write_complete, /* io_complete */
208 softdep_deallocate_dependencies, /* io_deallocate */
209 softdep_move_dependencies, /* io_movedeps */
210 softdep_count_dependencies, /* io_countdeps */
211};
212
213/*
214 * Locking primitives.
215 *
216 * For a uniprocessor, all we need to do is protect against disk
217 * interrupts. For a multiprocessor, this lock would have to be
218 * a mutex. A single mutex is used throughout this file, though
219 * finer grain locking could be used if contention warranted it.
220 *
221 * For a multiprocessor, the sleep call would accept a lock and
222 * release it after the sleep processing was complete. In a uniprocessor
223 * implementation there is no such interlock, so we simple mark
224 * the places where it needs to be done with the `interlocked' form
225 * of the lock calls. Since the uniprocessor sleep already interlocks
226 * the spl, there is nothing that really needs to be done.
227 */
228#ifndef /* NOT */ DEBUG
229static struct lockit {
230 int lkt_spl;
231} lk = { 0 };
232#define ACQUIRE_LOCK(lk) (lk)->lkt_spl = splbio()
233#define FREE_LOCK(lk) splx((lk)->lkt_spl)
234#define ACQUIRE_LOCK_INTERLOCKED(lk)
235#define FREE_LOCK_INTERLOCKED(lk)
236
237#else /* DEBUG */
238static struct lockit {
239 int lkt_spl;
240 pid_t lkt_held;
241} lk = { 0, -1 };
242static int lockcnt;
243
244static void acquire_lock __P((struct lockit *));
245static void free_lock __P((struct lockit *));
246static void acquire_lock_interlocked __P((struct lockit *));
247static void free_lock_interlocked __P((struct lockit *));
248
249#define ACQUIRE_LOCK(lk) acquire_lock(lk)
250#define FREE_LOCK(lk) free_lock(lk)
251#define ACQUIRE_LOCK_INTERLOCKED(lk) acquire_lock_interlocked(lk)
252#define FREE_LOCK_INTERLOCKED(lk) free_lock_interlocked(lk)
253
254static void
255acquire_lock(lk)
256 struct lockit *lk;
257{
258 pid_t holder;
259
260 if (lk->lkt_held != -1) {
261 holder = lk->lkt_held;
262 FREE_LOCK(lk);
263 if (holder == CURPROC->p_pid)
264 panic("softdep_lock: locking against myself");
265 else
266 panic("softdep_lock: lock held by %d", holder);
267 }
268 lk->lkt_spl = splbio();
269 lk->lkt_held = CURPROC->p_pid;
270 lockcnt++;
271}
272
273static void
274free_lock(lk)
275 struct lockit *lk;
276{
277
278 if (lk->lkt_held == -1)
279 panic("softdep_unlock: lock not held");
280 lk->lkt_held = -1;
281 splx(lk->lkt_spl);
282}
283
284static void
285acquire_lock_interlocked(lk)
286 struct lockit *lk;
287{
288 pid_t holder;
289
290 if (lk->lkt_held != -1) {
291 holder = lk->lkt_held;
292 FREE_LOCK(lk);
293 if (holder == CURPROC->p_pid)
294 panic("softdep_lock_interlocked: locking against self");
295 else
296 panic("softdep_lock_interlocked: lock held by %d",
297 holder);
298 }
299 lk->lkt_held = CURPROC->p_pid;
300 lockcnt++;
301}
302
303static void
304free_lock_interlocked(lk)
305 struct lockit *lk;
306{
307
308 if (lk->lkt_held == -1)
309 panic("softdep_unlock_interlocked: lock not held");
310 lk->lkt_held = -1;
311}
312#endif /* DEBUG */
313
314/*
315 * Place holder for real semaphores.
316 */
317struct sema {
318 int value;
319 pid_t holder;
320 char *name;
321 int prio;
322 int timo;
323};
324static void sema_init __P((struct sema *, char *, int, int));
325static int sema_get __P((struct sema *, struct lockit *));
326static void sema_release __P((struct sema *));
327
328static void
329sema_init(semap, name, prio, timo)
330 struct sema *semap;
331 char *name;
332 int prio, timo;
333{
334
335 semap->holder = -1;
336 semap->value = 0;
337 semap->name = name;
338 semap->prio = prio;
339 semap->timo = timo;
340}
341
342static int
343sema_get(semap, interlock)
344 struct sema *semap;
345 struct lockit *interlock;
346{
347
348 if (semap->value++ > 0) {
349 if (interlock != NULL)
350 FREE_LOCK_INTERLOCKED(interlock);
351 tsleep((caddr_t)semap, semap->prio, semap->name, semap->timo);
352 if (interlock != NULL) {
353 ACQUIRE_LOCK_INTERLOCKED(interlock);
354 FREE_LOCK(interlock);
355 }
356 return (0);
357 }
358 semap->holder = CURPROC->p_pid;
359 if (interlock != NULL)
360 FREE_LOCK(interlock);
361 return (1);
362}
363
364static void
365sema_release(semap)
366 struct sema *semap;
367{
368
369 if (semap->value <= 0 || semap->holder != CURPROC->p_pid) {
370 if (lk.lkt_held != -1)
371 FREE_LOCK(&lk);
372 panic("sema_release: not held");
373 }
374 if (--semap->value > 0) {
375 semap->value = 0;
376 wakeup(semap);
377 }
378 semap->holder = -1;
379}
380
381/*
382 * Worklist queue management.
383 * These routines require that the lock be held.
384 */
385#ifndef /* NOT */ DEBUG
386#define WORKLIST_INSERT(head, item) do { \
387 (item)->wk_state |= ONWORKLIST; \
388 LIST_INSERT_HEAD(head, item, wk_list); \
389} while (0)
390#define WORKLIST_REMOVE(item) do { \
391 (item)->wk_state &= ~ONWORKLIST; \
392 LIST_REMOVE(item, wk_list); \
393} while (0)
394#define WORKITEM_FREE(item, type) FREE(item, DtoM(type))
395
396#else /* DEBUG */
397static void worklist_insert __P((struct workhead *, struct worklist *));
398static void worklist_remove __P((struct worklist *));
399static void workitem_free __P((struct worklist *, int));
400
401#define WORKLIST_INSERT(head, item) worklist_insert(head, item)
402#define WORKLIST_REMOVE(item) worklist_remove(item)
403#define WORKITEM_FREE(item, type) workitem_free((struct worklist *)item, type)
404
405static void
406worklist_insert(head, item)
407 struct workhead *head;
408 struct worklist *item;
409{
410
411 if (lk.lkt_held == -1)
412 panic("worklist_insert: lock not held");
413 if (item->wk_state & ONWORKLIST) {
414 FREE_LOCK(&lk);
415 panic("worklist_insert: already on list");
416 }
417 item->wk_state |= ONWORKLIST;
418 LIST_INSERT_HEAD(head, item, wk_list);
419}
420
421static void
422worklist_remove(item)
423 struct worklist *item;
424{
425
426 if (lk.lkt_held == -1)
427 panic("worklist_remove: lock not held");
428 if ((item->wk_state & ONWORKLIST) == 0) {
429 FREE_LOCK(&lk);
430 panic("worklist_remove: not on list");
431 }
432 item->wk_state &= ~ONWORKLIST;
433 LIST_REMOVE(item, wk_list);
434}
435
436static void
437workitem_free(item, type)
438 struct worklist *item;
439 int type;
440{
441
442 if (item->wk_state & ONWORKLIST) {
443 if (lk.lkt_held != -1)
444 FREE_LOCK(&lk);
445 panic("workitem_free: still on list");
446 }
447 if (item->wk_type != type) {
448 if (lk.lkt_held != -1)
449 FREE_LOCK(&lk);
450 panic("workitem_free: type mismatch");
451 }
452 FREE(item, DtoM(type));
453}
454#endif /* DEBUG */
455
456/*
457 * Workitem queue management
458 */
459static struct workhead softdep_workitem_pending;
460static int num_on_worklist; /* number of worklist items to be processed */
461static int softdep_worklist_busy; /* 1 => trying to do unmount */
462static int softdep_worklist_req; /* serialized waiters */
463static int max_softdeps; /* maximum number of structs before slowdown */
464static int tickdelay = 2; /* number of ticks to pause during slowdown */
465static int proc_waiting; /* tracks whether we have a timeout posted */
466static int *stat_countp; /* statistic to count in proc_waiting timeout */
467static struct callout_handle handle; /* handle on posted proc_waiting timeout */
468static struct proc *filesys_syncer; /* proc of filesystem syncer process */
469static int req_clear_inodedeps; /* syncer process flush some inodedeps */
470#define FLUSH_INODES 1
471static int req_clear_remove; /* syncer process flush some freeblks */
472#define FLUSH_REMOVE 2
473/*
474 * runtime statistics
475 */
476static int stat_worklist_push; /* number of worklist cleanups */
477static int stat_blk_limit_push; /* number of times block limit neared */
478static int stat_ino_limit_push; /* number of times inode limit neared */
479static int stat_blk_limit_hit; /* number of times block slowdown imposed */
480static int stat_ino_limit_hit; /* number of times inode slowdown imposed */
481static int stat_sync_limit_hit; /* number of synchronous slowdowns imposed */
482static int stat_indir_blk_ptrs; /* bufs redirtied as indir ptrs not written */
483static int stat_inode_bitmap; /* bufs redirtied as inode bitmap not written */
484static int stat_direct_blk_ptrs;/* bufs redirtied as direct ptrs not written */
485static int stat_dir_entry; /* bufs redirtied as dir entry cannot write */
486#ifdef DEBUG
487#include <vm/vm.h>
488#include <sys/sysctl.h>
489SYSCTL_INT(_debug, OID_AUTO, max_softdeps, CTLFLAG_RW, &max_softdeps, 0, "");
490SYSCTL_INT(_debug, OID_AUTO, tickdelay, CTLFLAG_RW, &tickdelay, 0, "");
491SYSCTL_INT(_debug, OID_AUTO, worklist_push, CTLFLAG_RW, &stat_worklist_push, 0,"");
492SYSCTL_INT(_debug, OID_AUTO, blk_limit_push, CTLFLAG_RW, &stat_blk_limit_push, 0,"");
493SYSCTL_INT(_debug, OID_AUTO, ino_limit_push, CTLFLAG_RW, &stat_ino_limit_push, 0,"");
494SYSCTL_INT(_debug, OID_AUTO, blk_limit_hit, CTLFLAG_RW, &stat_blk_limit_hit, 0, "");
495SYSCTL_INT(_debug, OID_AUTO, ino_limit_hit, CTLFLAG_RW, &stat_ino_limit_hit, 0, "");
496SYSCTL_INT(_debug, OID_AUTO, sync_limit_hit, CTLFLAG_RW, &stat_sync_limit_hit, 0, "");
497SYSCTL_INT(_debug, OID_AUTO, indir_blk_ptrs, CTLFLAG_RW, &stat_indir_blk_ptrs, 0, "");
498SYSCTL_INT(_debug, OID_AUTO, inode_bitmap, CTLFLAG_RW, &stat_inode_bitmap, 0, "");
499SYSCTL_INT(_debug, OID_AUTO, direct_blk_ptrs, CTLFLAG_RW, &stat_direct_blk_ptrs, 0, "");
500SYSCTL_INT(_debug, OID_AUTO, dir_entry, CTLFLAG_RW, &stat_dir_entry, 0, "");
501#endif /* DEBUG */
502
503/*
504 * Add an item to the end of the work queue.
505 * This routine requires that the lock be held.
506 * This is the only routine that adds items to the list.
507 * The following routine is the only one that removes items
508 * and does so in order from first to last.
509 */
510static void
511add_to_worklist(wk)
512 struct worklist *wk;
513{
514 static struct worklist *worklist_tail;
515
516 if (wk->wk_state & ONWORKLIST) {
517 if (lk.lkt_held != -1)
518 FREE_LOCK(&lk);
519 panic("add_to_worklist: already on list");
520 }
521 wk->wk_state |= ONWORKLIST;
522 if (LIST_FIRST(&softdep_workitem_pending) == NULL)
523 LIST_INSERT_HEAD(&softdep_workitem_pending, wk, wk_list);
524 else
525 LIST_INSERT_AFTER(worklist_tail, wk, wk_list);
526 worklist_tail = wk;
527 num_on_worklist += 1;
528}
529
530/*
531 * Process that runs once per second to handle items in the background queue.
532 *
533 * Note that we ensure that everything is done in the order in which they
534 * appear in the queue. The code below depends on this property to ensure
535 * that blocks of a file are freed before the inode itself is freed. This
536 * ordering ensures that no new <vfsid, inum, lbn> triples will be generated
537 * until all the old ones have been purged from the dependency lists.
538 */
539int
540softdep_process_worklist(matchmnt)
541 struct mount *matchmnt;
542{
543 struct proc *p = CURPROC;
544 int matchcnt, loopcount;
545 long starttime;
546
547 /*
548 * Record the process identifier of our caller so that we can give
549 * this process preferential treatment in request_cleanup below.
550 */
551 filesys_syncer = p;
552 matchcnt = 0;
553
554 /*
555 * There is no danger of having multiple processes run this
556 * code, but we have to single-thread it when softdep_flushfiles()
557 * is in operation to get an accurate count of the number of items
558 * related to its mount point that are in the list.
559 */
560 if (matchmnt == NULL) {
561 if (softdep_worklist_busy < 0)
562 return(-1);
563 softdep_worklist_busy += 1;
564 }
565
566 /*
567 * If requested, try removing inode or removal dependencies.
568 */
569 if (req_clear_inodedeps) {
570 clear_inodedeps(p);
571 req_clear_inodedeps -= 1;
572 wakeup_one(&proc_waiting);
573 }
574 if (req_clear_remove) {
575 clear_remove(p);
576 req_clear_remove -= 1;
577 wakeup_one(&proc_waiting);
578 }
579 loopcount = 1;
580 starttime = time_second;
581 while (num_on_worklist > 0) {
582 matchcnt += process_worklist_item(matchmnt, 0);
583
584 /*
585 * If a umount operation wants to run the worklist
586 * accurately, abort.
587 */
588 if (softdep_worklist_req && matchmnt == NULL) {
589 matchcnt = -1;
590 break;
591 }
592
593 /*
594 * If requested, try removing inode or removal dependencies.
595 */
596 if (req_clear_inodedeps) {
597 clear_inodedeps(p);
598 req_clear_inodedeps -= 1;
599 wakeup_one(&proc_waiting);
600 }
601 if (req_clear_remove) {
602 clear_remove(p);
603 req_clear_remove -= 1;
604 wakeup_one(&proc_waiting);
605 }
606 /*
607 * We do not generally want to stop for buffer space, but if
608 * we are really being a buffer hog, we will stop and wait.
609 */
610 if (loopcount++ % 128 == 0)
611 bwillwrite();
612 /*
613 * Never allow processing to run for more than one
614 * second. Otherwise the other syncer tasks may get
615 * excessively backlogged.
616 */
617 if (starttime != time_second && matchmnt == NULL) {
618 matchcnt = -1;
619 break;
620 }
621 }
622 if (matchmnt == NULL) {
623 softdep_worklist_busy -= 1;
624 if (softdep_worklist_req && softdep_worklist_busy == 0)
625 wakeup(&softdep_worklist_req);
626 }
627 return (matchcnt);
628}
629
630/*
631 * Process one item on the worklist.
632 */
633static int
634process_worklist_item(matchmnt, flags)
635 struct mount *matchmnt;
636 int flags;
637{
638 struct worklist *wk;
639 struct dirrem *dirrem;
640 struct mount *mp;
641 struct vnode *vp;
642 int matchcnt = 0;
643
644 ACQUIRE_LOCK(&lk);
645 /*
646 * Normally we just process each item on the worklist in order.
647 * However, if we are in a situation where we cannot lock any
648 * inodes, we have to skip over any dirrem requests whose
649 * vnodes are resident and locked.
650 */
651 LIST_FOREACH(wk, &softdep_workitem_pending, wk_list) {
652 if ((flags & LK_NOWAIT) == 0 || wk->wk_type != D_DIRREM)
653 break;
654 dirrem = WK_DIRREM(wk);
655 vp = ufs_ihashlookup(VFSTOUFS(dirrem->dm_mnt)->um_dev,
656 dirrem->dm_oldinum);
657 if (vp == NULL || !VOP_ISLOCKED(vp, CURPROC))
658 break;
659 }
660 if (wk == 0) {
661 FREE_LOCK(&lk);
662 return (0);
663 }
664 WORKLIST_REMOVE(wk);
665 num_on_worklist -= 1;
666 FREE_LOCK(&lk);
667 switch (wk->wk_type) {
668
669 case D_DIRREM:
670 /* removal of a directory entry */
671 mp = WK_DIRREM(wk)->dm_mnt;
672 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
673 panic("%s: dirrem on suspended filesystem",
674 "process_worklist_item");
675 if (mp == matchmnt)
676 matchcnt += 1;
677 handle_workitem_remove(WK_DIRREM(wk));
678 break;
679
680 case D_FREEBLKS:
681 /* releasing blocks and/or fragments from a file */
682 mp = WK_FREEBLKS(wk)->fb_mnt;
683 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
684 panic("%s: freeblks on suspended filesystem",
685 "process_worklist_item");
686 if (mp == matchmnt)
687 matchcnt += 1;
688 handle_workitem_freeblocks(WK_FREEBLKS(wk), flags & LK_NOWAIT);
689 break;
690
691 case D_FREEFRAG:
692 /* releasing a fragment when replaced as a file grows */
693 mp = WK_FREEFRAG(wk)->ff_mnt;
694 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
695 panic("%s: freefrag on suspended filesystem",
696 "process_worklist_item");
697 if (mp == matchmnt)
698 matchcnt += 1;
699 handle_workitem_freefrag(WK_FREEFRAG(wk));
700 break;
701
702 case D_FREEFILE:
703 /* releasing an inode when its link count drops to 0 */
704 mp = WK_FREEFILE(wk)->fx_mnt;
705 if (vn_write_suspend_wait(NULL, mp, V_NOWAIT))
706 panic("%s: freefile on suspended filesystem",
707 "process_worklist_item");
708 if (mp == matchmnt)
709 matchcnt += 1;
710 handle_workitem_freefile(WK_FREEFILE(wk));
711 break;
712
713 default:
714 panic("%s_process_worklist: Unknown type %s",
715 "softdep", TYPENAME(wk->wk_type));
716 /* NOTREACHED */
717 }
718 return (matchcnt);
719}
720
721/*
722 * Move dependencies from one buffer to another.
723 */
724static void
725softdep_move_dependencies(oldbp, newbp)
726 struct buf *oldbp;
727 struct buf *newbp;
728{
729 struct worklist *wk, *wktail;
730
731 if (LIST_FIRST(&newbp->b_dep) != NULL)
732 panic("softdep_move_dependencies: need merge code");
733 wktail = 0;
734 ACQUIRE_LOCK(&lk);
735 while ((wk = LIST_FIRST(&oldbp->b_dep)) != NULL) {
736 LIST_REMOVE(wk, wk_list);
737 if (wktail == 0)
738 LIST_INSERT_HEAD(&newbp->b_dep, wk, wk_list);
739 else
740 LIST_INSERT_AFTER(wktail, wk, wk_list);
741 wktail = wk;
742 }
743 FREE_LOCK(&lk);
744}
745
746/*
747 * Purge the work list of all items associated with a particular mount point.
748 */
749int
750softdep_flushworklist(oldmnt, countp, p)
751 struct mount *oldmnt;
752 int *countp;
753 struct proc *p;
754{
755 struct vnode *devvp;
756 int count, error = 0;
757
758 /*
759 * Await our turn to clear out the queue, then serialize access.
760 */
761 while (softdep_worklist_busy) {
762 softdep_worklist_req += 1;
763 tsleep(&softdep_worklist_req, PRIBIO, "softflush", 0);
764 softdep_worklist_req -= 1;
765 }
766 softdep_worklist_busy = -1;
767 /*
768 * Alternately flush the block device associated with the mount
769 * point and process any dependencies that the flushing
770 * creates. We continue until no more worklist dependencies
771 * are found.
772 */
773 *countp = 0;
774 devvp = VFSTOUFS(oldmnt)->um_devvp;
775 while ((count = softdep_process_worklist(oldmnt)) > 0) {
776 *countp += count;
777 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
778 error = VOP_FSYNC(devvp, p->p_ucred, MNT_WAIT, p);
779 VOP_UNLOCK(devvp, 0, p);
780 if (error)
781 break;
782 }
783 softdep_worklist_busy = 0;
784 if (softdep_worklist_req)
785 wakeup(&softdep_worklist_req);
786 return (error);
787}
788
789/*
790 * Flush all vnodes and worklist items associated with a specified mount point.
791 */
792int
793softdep_flushfiles(oldmnt, flags, p)
794 struct mount *oldmnt;
795 int flags;
796 struct proc *p;
797{
798 int error, count, loopcnt;
799
800 /*
801 * Alternately flush the vnodes associated with the mount
802 * point and process any dependencies that the flushing
803 * creates. In theory, this loop can happen at most twice,
804 * but we give it a few extra just to be sure.
805 */
806 for (loopcnt = 10; loopcnt > 0; loopcnt--) {
807 /*
808 * Do another flush in case any vnodes were brought in
809 * as part of the cleanup operations.
810 */
811 if ((error = ffs_flushfiles(oldmnt, flags, p)) != 0)
812 break;
813 if ((error = softdep_flushworklist(oldmnt, &count, p)) != 0 ||
814 count == 0)
815 break;
816 }
817 /*
818 * If we are unmounting then it is an error to fail. If we
819 * are simply trying to downgrade to read-only, then filesystem
820 * activity can keep us busy forever, so we just fail with EBUSY.
821 */
822 if (loopcnt == 0) {
823 if (oldmnt->mnt_kern_flag & MNTK_UNMOUNT)
824 panic("softdep_flushfiles: looping");
825 error = EBUSY;
826 }
827 return (error);
828}
829
830/*
831 * Structure hashing.
832 *
833 * There are three types of structures that can be looked up:
834 * 1) pagedep structures identified by mount point, inode number,
835 * and logical block.
836 * 2) inodedep structures identified by mount point and inode number.
837 * 3) newblk structures identified by mount point and
838 * physical block number.
839 *
840 * The "pagedep" and "inodedep" dependency structures are hashed
841 * separately from the file blocks and inodes to which they correspond.
842 * This separation helps when the in-memory copy of an inode or
843 * file block must be replaced. It also obviates the need to access
844 * an inode or file page when simply updating (or de-allocating)
845 * dependency structures. Lookup of newblk structures is needed to
846 * find newly allocated blocks when trying to associate them with
847 * their allocdirect or allocindir structure.
848 *
849 * The lookup routines optionally create and hash a new instance when
850 * an existing entry is not found.
851 */
852#define DEPALLOC 0x0001 /* allocate structure if lookup fails */
853#define NODELAY 0x0002 /* cannot do background work */
854
855/*
856 * Structures and routines associated with pagedep caching.
857 */
858LIST_HEAD(pagedep_hashhead, pagedep) *pagedep_hashtbl;
859u_long pagedep_hash; /* size of hash table - 1 */
860#define PAGEDEP_HASH(mp, inum, lbn) \
861 (&pagedep_hashtbl[((((register_t)(mp)) >> 13) + (inum) + (lbn)) & \
862 pagedep_hash])
863static struct sema pagedep_in_progress;
864
865/*
866 * Look up a pagedep. Return 1 if found, 0 if not found.
867 * If not found, allocate if DEPALLOC flag is passed.
868 * Found or allocated entry is returned in pagedeppp.
869 * This routine must be called with splbio interrupts blocked.
870 */
871static int
872pagedep_lookup(ip, lbn, flags, pagedeppp)
873 struct inode *ip;
874 ufs_lbn_t lbn;
875 int flags;
876 struct pagedep **pagedeppp;
877{
878 struct pagedep *pagedep;
879 struct pagedep_hashhead *pagedephd;
880 struct mount *mp;
881 int i;
882
883#ifdef DEBUG
884 if (lk.lkt_held == -1)
885 panic("pagedep_lookup: lock not held");
886#endif
887 mp = ITOV(ip)->v_mount;
888 pagedephd = PAGEDEP_HASH(mp, ip->i_number, lbn);
889top:
890 LIST_FOREACH(pagedep, pagedephd, pd_hash)
891 if (ip->i_number == pagedep->pd_ino &&
892 lbn == pagedep->pd_lbn &&
893 mp == pagedep->pd_mnt)
894 break;
895 if (pagedep) {
896 *pagedeppp = pagedep;
897 return (1);
898 }
899 if ((flags & DEPALLOC) == 0) {
900 *pagedeppp = NULL;
901 return (0);
902 }
903 if (sema_get(&pagedep_in_progress, &lk) == 0) {
904 ACQUIRE_LOCK(&lk);
905 goto top;
906 }
907 MALLOC(pagedep, struct pagedep *, sizeof(struct pagedep), M_PAGEDEP,
908 M_SOFTDEP_FLAGS|M_ZERO);
909 pagedep->pd_list.wk_type = D_PAGEDEP;
910 pagedep->pd_mnt = mp;
911 pagedep->pd_ino = ip->i_number;
912 pagedep->pd_lbn = lbn;
913 LIST_INIT(&pagedep->pd_dirremhd);
914 LIST_INIT(&pagedep->pd_pendinghd);
915 for (i = 0; i < DAHASHSZ; i++)
916 LIST_INIT(&pagedep->pd_diraddhd[i]);
917 ACQUIRE_LOCK(&lk);
918 LIST_INSERT_HEAD(pagedephd, pagedep, pd_hash);
919 sema_release(&pagedep_in_progress);
920 *pagedeppp = pagedep;
921 return (0);
922}
923
924/*
925 * Structures and routines associated with inodedep caching.
926 */
927LIST_HEAD(inodedep_hashhead, inodedep) *inodedep_hashtbl;
928static u_long inodedep_hash; /* size of hash table - 1 */
929static long num_inodedep; /* number of inodedep allocated */
930#define INODEDEP_HASH(fs, inum) \
931 (&inodedep_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & inodedep_hash])
932static struct sema inodedep_in_progress;
933
934/*
935 * Look up a inodedep. Return 1 if found, 0 if not found.
936 * If not found, allocate if DEPALLOC flag is passed.
937 * Found or allocated entry is returned in inodedeppp.
938 * This routine must be called with splbio interrupts blocked.
939 */
940static int
941inodedep_lookup(fs, inum, flags, inodedeppp)
942 struct fs *fs;
943 ino_t inum;
944 int flags;
945 struct inodedep **inodedeppp;
946{
947 struct inodedep *inodedep;
948 struct inodedep_hashhead *inodedephd;
949 int firsttry;
950
951#ifdef DEBUG
952 if (lk.lkt_held == -1)
953 panic("inodedep_lookup: lock not held");
954#endif
955 firsttry = 1;
956 inodedephd = INODEDEP_HASH(fs, inum);
957top:
958 LIST_FOREACH(inodedep, inodedephd, id_hash)
959 if (inum == inodedep->id_ino && fs == inodedep->id_fs)
960 break;
961 if (inodedep) {
962 *inodedeppp = inodedep;
963 return (1);
964 }
965 if ((flags & DEPALLOC) == 0) {
966 *inodedeppp = NULL;
967 return (0);
968 }
969 /*
970 * If we are over our limit, try to improve the situation.
971 */
972 if (num_inodedep > max_softdeps && firsttry && (flags & NODELAY) == 0 &&
973 request_cleanup(FLUSH_INODES, 1)) {
974 firsttry = 0;
975 goto top;
976 }
977 if (sema_get(&inodedep_in_progress, &lk) == 0) {
978 ACQUIRE_LOCK(&lk);
979 goto top;
980 }
981 num_inodedep += 1;
982 MALLOC(inodedep, struct inodedep *, sizeof(struct inodedep),
983 M_INODEDEP, M_SOFTDEP_FLAGS);
984 inodedep->id_list.wk_type = D_INODEDEP;
985 inodedep->id_fs = fs;
986 inodedep->id_ino = inum;
987 inodedep->id_state = ALLCOMPLETE;
988 inodedep->id_nlinkdelta = 0;
989 inodedep->id_savedino = NULL;
990 inodedep->id_savedsize = -1;
991 inodedep->id_buf = NULL;
992 LIST_INIT(&inodedep->id_pendinghd);
993 LIST_INIT(&inodedep->id_inowait);
994 LIST_INIT(&inodedep->id_bufwait);
995 TAILQ_INIT(&inodedep->id_inoupdt);
996 TAILQ_INIT(&inodedep->id_newinoupdt);
997 ACQUIRE_LOCK(&lk);
998 LIST_INSERT_HEAD(inodedephd, inodedep, id_hash);
999 sema_release(&inodedep_in_progress);
1000 *inodedeppp = inodedep;
1001 return (0);
1002}
1003
1004/*
1005 * Structures and routines associated with newblk caching.
1006 */
1007LIST_HEAD(newblk_hashhead, newblk) *newblk_hashtbl;
1008u_long newblk_hash; /* size of hash table - 1 */
1009#define NEWBLK_HASH(fs, inum) \
1010 (&newblk_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & newblk_hash])
1011static struct sema newblk_in_progress;
1012
1013/*
1014 * Look up a newblk. Return 1 if found, 0 if not found.
1015 * If not found, allocate if DEPALLOC flag is passed.
1016 * Found or allocated entry is returned in newblkpp.
1017 */
1018static int
1019newblk_lookup(fs, newblkno, flags, newblkpp)
1020 struct fs *fs;
1021 ufs_daddr_t newblkno;
1022 int flags;
1023 struct newblk **newblkpp;
1024{
1025 struct newblk *newblk;
1026 struct newblk_hashhead *newblkhd;
1027
1028 newblkhd = NEWBLK_HASH(fs, newblkno);
1029top:
1030 LIST_FOREACH(newblk, newblkhd, nb_hash)
1031 if (newblkno == newblk->nb_newblkno && fs == newblk->nb_fs)
1032 break;
1033 if (newblk) {
1034 *newblkpp = newblk;
1035 return (1);
1036 }
1037 if ((flags & DEPALLOC) == 0) {
1038 *newblkpp = NULL;
1039 return (0);
1040 }
1041 if (sema_get(&newblk_in_progress, 0) == 0)
1042 goto top;
1043 MALLOC(newblk, struct newblk *, sizeof(struct newblk),
1044 M_NEWBLK, M_SOFTDEP_FLAGS);
1045 newblk->nb_state = 0;
1046 newblk->nb_fs = fs;
1047 newblk->nb_newblkno = newblkno;
1048 LIST_INSERT_HEAD(newblkhd, newblk, nb_hash);
1049 sema_release(&newblk_in_progress);
1050 *newblkpp = newblk;
1051 return (0);
1052}
1053
1054/*
1055 * Executed during filesystem system initialization before
1056 * mounting any file systems.
1057 */
1058void
1059softdep_initialize()
1060{
1061
1062 LIST_INIT(&mkdirlisthd);
1063 LIST_INIT(&softdep_workitem_pending);
1064 max_softdeps = min(desiredvnodes * 8,
1065 M_INODEDEP->ks_limit / (2 * sizeof(struct inodedep)));
1066 pagedep_hashtbl = hashinit(desiredvnodes / 5, M_PAGEDEP,
1067 &pagedep_hash);
1068 sema_init(&pagedep_in_progress, "pagedep", PRIBIO, 0);
1069 inodedep_hashtbl = hashinit(desiredvnodes, M_INODEDEP, &inodedep_hash);
1070 sema_init(&inodedep_in_progress, "inodedep", PRIBIO, 0);
1071 newblk_hashtbl = hashinit(64, M_NEWBLK, &newblk_hash);
1072 sema_init(&newblk_in_progress, "newblk", PRIBIO, 0);
1073}
1074
1075/*
1076 * Called at mount time to notify the dependency code that a
1077 * filesystem wishes to use it.
1078 */
1079int
1080softdep_mount(devvp, mp, fs, cred)
1081 struct vnode *devvp;
1082 struct mount *mp;
1083 struct fs *fs;
1084 struct ucred *cred;
1085{
1086 struct csum cstotal;
1087 struct cg *cgp;
1088 struct buf *bp;
1089 int error, cyl;
1090
1091 mp->mnt_flag &= ~MNT_ASYNC;
1092 mp->mnt_flag |= MNT_SOFTDEP;
1093 /*
1094 * When doing soft updates, the counters in the
1095 * superblock may have gotten out of sync, so we have
1096 * to scan the cylinder groups and recalculate them.
1097 */
1098 if (fs->fs_clean != 0)
1099 return (0);
1100 bzero(&cstotal, sizeof cstotal);
1101 for (cyl = 0; cyl < fs->fs_ncg; cyl++) {
1102 if ((error = bread(devvp, fsbtodb(fs, cgtod(fs, cyl)),
1103 fs->fs_cgsize, cred, &bp)) != 0) {
1104 brelse(bp);
1105 return (error);
1106 }
1107 cgp = (struct cg *)bp->b_data;
1108 cstotal.cs_nffree += cgp->cg_cs.cs_nffree;
1109 cstotal.cs_nbfree += cgp->cg_cs.cs_nbfree;
1110 cstotal.cs_nifree += cgp->cg_cs.cs_nifree;
1111 cstotal.cs_ndir += cgp->cg_cs.cs_ndir;
1112 fs->fs_cs(fs, cyl) = cgp->cg_cs;
1113 brelse(bp);
1114 }
1115#ifdef DEBUG
1116 if (bcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal))
1117 printf("%s: superblock summary recomputed\n", fs->fs_fsmnt);
1118#endif
1119 bcopy(&cstotal, &fs->fs_cstotal, sizeof cstotal);
1120 return (0);
1121}
1122
1123/*
1124 * Protecting the freemaps (or bitmaps).
1125 *
1126 * To eliminate the need to execute fsck before mounting a file system
1127 * after a power failure, one must (conservatively) guarantee that the
1128 * on-disk copy of the bitmaps never indicate that a live inode or block is
1129 * free. So, when a block or inode is allocated, the bitmap should be
1130 * updated (on disk) before any new pointers. When a block or inode is
1131 * freed, the bitmap should not be updated until all pointers have been
1132 * reset. The latter dependency is handled by the delayed de-allocation
1133 * approach described below for block and inode de-allocation. The former
1134 * dependency is handled by calling the following procedure when a block or
1135 * inode is allocated. When an inode is allocated an "inodedep" is created
1136 * with its DEPCOMPLETE flag cleared until its bitmap is written to disk.
1137 * Each "inodedep" is also inserted into the hash indexing structure so
1138 * that any additional link additions can be made dependent on the inode
1139 * allocation.
1140 *
1141 * The ufs file system maintains a number of free block counts (e.g., per
1142 * cylinder group, per cylinder and per <cylinder, rotational position> pair)
1143 * in addition to the bitmaps. These counts are used to improve efficiency
1144 * during allocation and therefore must be consistent with the bitmaps.
1145 * There is no convenient way to guarantee post-crash consistency of these
1146 * counts with simple update ordering, for two main reasons: (1) The counts
1147 * and bitmaps for a single cylinder group block are not in the same disk
1148 * sector. If a disk write is interrupted (e.g., by power failure), one may
1149 * be written and the other not. (2) Some of the counts are located in the
1150 * superblock rather than the cylinder group block. So, we focus our soft
1151 * updates implementation on protecting the bitmaps. When mounting a
1152 * filesystem, we recompute the auxiliary counts from the bitmaps.
1153 */
1154
1155/*
1156 * Called just after updating the cylinder group block to allocate an inode.
1157 */
1158void
1159softdep_setup_inomapdep(bp, ip, newinum)
1160 struct buf *bp; /* buffer for cylgroup block with inode map */
1161 struct inode *ip; /* inode related to allocation */
1162 ino_t newinum; /* new inode number being allocated */
1163{
1164 struct inodedep *inodedep;
1165 struct bmsafemap *bmsafemap;
1166
1167 /*
1168 * Create a dependency for the newly allocated inode.
1169 * Panic if it already exists as something is seriously wrong.
1170 * Otherwise add it to the dependency list for the buffer holding
1171 * the cylinder group map from which it was allocated.
1172 */
1173 ACQUIRE_LOCK(&lk);
1174 if ((inodedep_lookup(ip->i_fs, newinum, DEPALLOC|NODELAY, &inodedep))) {
1175 FREE_LOCK(&lk);
1176 panic("softdep_setup_inomapdep: found inode");
1177 }
1178 inodedep->id_buf = bp;
1179 inodedep->id_state &= ~DEPCOMPLETE;
1180 bmsafemap = bmsafemap_lookup(bp);
1181 LIST_INSERT_HEAD(&bmsafemap->sm_inodedephd, inodedep, id_deps);
1182 FREE_LOCK(&lk);
1183}
1184
1185/*
1186 * Called just after updating the cylinder group block to
1187 * allocate block or fragment.
1188 */
1189void
1190softdep_setup_blkmapdep(bp, fs, newblkno)
1191 struct buf *bp; /* buffer for cylgroup block with block map */
1192 struct fs *fs; /* filesystem doing allocation */
1193 ufs_daddr_t newblkno; /* number of newly allocated block */
1194{
1195 struct newblk *newblk;
1196 struct bmsafemap *bmsafemap;
1197
1198 /*
1199 * Create a dependency for the newly allocated block.
1200 * Add it to the dependency list for the buffer holding
1201 * the cylinder group map from which it was allocated.
1202 */
1203 if (newblk_lookup(fs, newblkno, DEPALLOC, &newblk) != 0)
1204 panic("softdep_setup_blkmapdep: found block");
1205 ACQUIRE_LOCK(&lk);
1206 newblk->nb_bmsafemap = bmsafemap = bmsafemap_lookup(bp);
1207 LIST_INSERT_HEAD(&bmsafemap->sm_newblkhd, newblk, nb_deps);
1208 FREE_LOCK(&lk);
1209}
1210
1211/*
1212 * Find the bmsafemap associated with a cylinder group buffer.
1213 * If none exists, create one. The buffer must be locked when
1214 * this routine is called and this routine must be called with
1215 * splbio interrupts blocked.
1216 */
1217static struct bmsafemap *
1218bmsafemap_lookup(bp)
1219 struct buf *bp;
1220{
1221 struct bmsafemap *bmsafemap;
1222 struct worklist *wk;
1223
1224#ifdef DEBUG
1225 if (lk.lkt_held == -1)
1226 panic("bmsafemap_lookup: lock not held");
1227#endif
1228 LIST_FOREACH(wk, &bp->b_dep, wk_list)
1229 if (wk->wk_type == D_BMSAFEMAP)
1230 return (WK_BMSAFEMAP(wk));
1231 FREE_LOCK(&lk);
1232 MALLOC(bmsafemap, struct bmsafemap *, sizeof(struct bmsafemap),
1233 M_BMSAFEMAP, M_SOFTDEP_FLAGS);
1234 bmsafemap->sm_list.wk_type = D_BMSAFEMAP;
1235 bmsafemap->sm_list.wk_state = 0;
1236 bmsafemap->sm_buf = bp;
1237 LIST_INIT(&bmsafemap->sm_allocdirecthd);
1238 LIST_INIT(&bmsafemap->sm_allocindirhd);
1239 LIST_INIT(&bmsafemap->sm_inodedephd);
1240 LIST_INIT(&bmsafemap->sm_newblkhd);
1241 ACQUIRE_LOCK(&lk);
1242 WORKLIST_INSERT(&bp->b_dep, &bmsafemap->sm_list);
1243 return (bmsafemap);
1244}
1245
1246/*
1247 * Direct block allocation dependencies.
1248 *
1249 * When a new block is allocated, the corresponding disk locations must be
1250 * initialized (with zeros or new data) before the on-disk inode points to
1251 * them. Also, the freemap from which the block was allocated must be
1252 * updated (on disk) before the inode's pointer. These two dependencies are
1253 * independent of each other and are needed for all file blocks and indirect
1254 * blocks that are pointed to directly by the inode. Just before the
1255 * "in-core" version of the inode is updated with a newly allocated block
1256 * number, a procedure (below) is called to setup allocation dependency
1257 * structures. These structures are removed when the corresponding
1258 * dependencies are satisfied or when the block allocation becomes obsolete
1259 * (i.e., the file is deleted, the block is de-allocated, or the block is a
1260 * fragment that gets upgraded). All of these cases are handled in
1261 * procedures described later.
1262 *
1263 * When a file extension causes a fragment to be upgraded, either to a larger
1264 * fragment or to a full block, the on-disk location may change (if the
1265 * previous fragment could not simply be extended). In this case, the old
1266 * fragment must be de-allocated, but not until after the inode's pointer has
1267 * been updated. In most cases, this is handled by later procedures, which
1268 * will construct a "freefrag" structure to be added to the workitem queue
1269 * when the inode update is complete (or obsolete). The main exception to
1270 * this is when an allocation occurs while a pending allocation dependency
1271 * (for the same block pointer) remains. This case is handled in the main
1272 * allocation dependency setup procedure by immediately freeing the
1273 * unreferenced fragments.
1274 */
1275void
1276softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp)
1277 struct inode *ip; /* inode to which block is being added */
1278 ufs_lbn_t lbn; /* block pointer within inode */
1279 ufs_daddr_t newblkno; /* disk block number being added */
1280 ufs_daddr_t oldblkno; /* previous block number, 0 unless frag */
1281 long newsize; /* size of new block */
1282 long oldsize; /* size of new block */
1283 struct buf *bp; /* bp for allocated block */
1284{
1285 struct allocdirect *adp, *oldadp;
1286 struct allocdirectlst *adphead;
1287 struct bmsafemap *bmsafemap;
1288 struct inodedep *inodedep;
1289 struct pagedep *pagedep;
1290 struct newblk *newblk;
1291
1292 MALLOC(adp, struct allocdirect *, sizeof(struct allocdirect),
1293 M_ALLOCDIRECT, M_SOFTDEP_FLAGS|M_ZERO);
1294 adp->ad_list.wk_type = D_ALLOCDIRECT;
1295 adp->ad_lbn = lbn;
1296 adp->ad_newblkno = newblkno;
1297 adp->ad_oldblkno = oldblkno;
1298 adp->ad_newsize = newsize;
1299 adp->ad_oldsize = oldsize;
1300 adp->ad_state = ATTACHED;
1301 if (newblkno == oldblkno)
1302 adp->ad_freefrag = NULL;
1303 else
1304 adp->ad_freefrag = newfreefrag(ip, oldblkno, oldsize);
1305
1306 if (newblk_lookup(ip->i_fs, newblkno, 0, &newblk) == 0)
1307 panic("softdep_setup_allocdirect: lost block");
1308
1309 ACQUIRE_LOCK(&lk);
1310 inodedep_lookup(ip->i_fs, ip->i_number, DEPALLOC | NODELAY, &inodedep);
1311 adp->ad_inodedep = inodedep;
1312
1313 if (newblk->nb_state == DEPCOMPLETE) {
1314 adp->ad_state |= DEPCOMPLETE;
1315 adp->ad_buf = NULL;
1316 } else {
1317 bmsafemap = newblk->nb_bmsafemap;
1318 adp->ad_buf = bmsafemap->sm_buf;
1319 LIST_REMOVE(newblk, nb_deps);
1320 LIST_INSERT_HEAD(&bmsafemap->sm_allocdirecthd, adp, ad_deps);
1321 }
1322 LIST_REMOVE(newblk, nb_hash);
1323 FREE(newblk, M_NEWBLK);
1324
1325 WORKLIST_INSERT(&bp->b_dep, &adp->ad_list);
1326 if (lbn >= NDADDR) {
1327 /* allocating an indirect block */
1328 if (oldblkno != 0) {
1329 FREE_LOCK(&lk);
1330 panic("softdep_setup_allocdirect: non-zero indir");
1331 }
1332 } else {
1333 /*
1334 * Allocating a direct block.
1335 *
1336 * If we are allocating a directory block, then we must
1337 * allocate an associated pagedep to track additions and
1338 * deletions.
1339 */
1340 if ((ip->i_mode & IFMT) == IFDIR &&
1341 pagedep_lookup(ip, lbn, DEPALLOC, &pagedep) == 0)
1342 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
1343 }
1344 /*
1345 * The list of allocdirects must be kept in sorted and ascending
1346 * order so that the rollback routines can quickly determine the
1347 * first uncommitted block (the size of the file stored on disk
1348 * ends at the end of the lowest committed fragment, or if there
1349 * are no fragments, at the end of the highest committed block).
1350 * Since files generally grow, the typical case is that the new
1351 * block is to be added at the end of the list. We speed this
1352 * special case by checking against the last allocdirect in the
1353 * list before laboriously traversing the list looking for the
1354 * insertion point.
1355 */
1356 adphead = &inodedep->id_newinoupdt;
1357 oldadp = TAILQ_LAST(adphead, allocdirectlst);
1358 if (oldadp == NULL || oldadp->ad_lbn <= lbn) {
1359 /* insert at end of list */
1360 TAILQ_INSERT_TAIL(adphead, adp, ad_next);
1361 if (oldadp != NULL && oldadp->ad_lbn == lbn)
1362 allocdirect_merge(adphead, adp, oldadp);
1363 FREE_LOCK(&lk);
1364 return;
1365 }
1366 TAILQ_FOREACH(oldadp, adphead, ad_next) {
1367 if (oldadp->ad_lbn >= lbn)
1368 break;
1369 }
1370 if (oldadp == NULL) {
1371 FREE_LOCK(&lk);
1372 panic("softdep_setup_allocdirect: lost entry");
1373 }
1374 /* insert in middle of list */
1375 TAILQ_INSERT_BEFORE(oldadp, adp, ad_next);
1376 if (oldadp->ad_lbn == lbn)
1377 allocdirect_merge(adphead, adp, oldadp);
1378 FREE_LOCK(&lk);
1379}
1380
1381/*
1382 * Replace an old allocdirect dependency with a newer one.
1383 * This routine must be called with splbio interrupts blocked.
1384 */
1385static void
1386allocdirect_merge(adphead, newadp, oldadp)
1387 struct allocdirectlst *adphead; /* head of list holding allocdirects */
1388 struct allocdirect *newadp; /* allocdirect being added */
1389 struct allocdirect *oldadp; /* existing allocdirect being checked */
1390{
1391 struct freefrag *freefrag;
1392
1393#ifdef DEBUG
1394 if (lk.lkt_held == -1)
1395 panic("allocdirect_merge: lock not held");
1396#endif
1397 if (newadp->ad_oldblkno != oldadp->ad_newblkno ||
1398 newadp->ad_oldsize != oldadp->ad_newsize ||
1399 newadp->ad_lbn >= NDADDR) {
1400 FREE_LOCK(&lk);
1401 panic("allocdirect_check: old %d != new %d || lbn %ld >= %d",
1402 newadp->ad_oldblkno, oldadp->ad_newblkno, newadp->ad_lbn,
1403 NDADDR);
1404 }
1405 newadp->ad_oldblkno = oldadp->ad_oldblkno;
1406 newadp->ad_oldsize = oldadp->ad_oldsize;
1407 /*
1408 * If the old dependency had a fragment to free or had never
1409 * previously had a block allocated, then the new dependency
1410 * can immediately post its freefrag and adopt the old freefrag.
1411 * This action is done by swapping the freefrag dependencies.
1412 * The new dependency gains the old one's freefrag, and the
1413 * old one gets the new one and then immediately puts it on
1414 * the worklist when it is freed by free_allocdirect. It is
1415 * not possible to do this swap when the old dependency had a
1416 * non-zero size but no previous fragment to free. This condition
1417 * arises when the new block is an extension of the old block.
1418 * Here, the first part of the fragment allocated to the new
1419 * dependency is part of the block currently claimed on disk by
1420 * the old dependency, so cannot legitimately be freed until the
1421 * conditions for the new dependency are fulfilled.
1422 */
1423 if (oldadp->ad_freefrag != NULL || oldadp->ad_oldblkno == 0) {
1424 freefrag = newadp->ad_freefrag;
1425 newadp->ad_freefrag = oldadp->ad_freefrag;
1426 oldadp->ad_freefrag = freefrag;
1427 }
1428 free_allocdirect(adphead, oldadp, 0);
1429}
1430
1431/*
1432 * Allocate a new freefrag structure if needed.
1433 */
1434static struct freefrag *
1435newfreefrag(ip, blkno, size)
1436 struct inode *ip;
1437 ufs_daddr_t blkno;
1438 long size;
1439{
1440 struct freefrag *freefrag;
1441 struct fs *fs;
1442
1443 if (blkno == 0)
1444 return (NULL);
1445 fs = ip->i_fs;
1446 if (fragnum(fs, blkno) + numfrags(fs, size) > fs->fs_frag)
1447 panic("newfreefrag: frag size");
1448 MALLOC(freefrag, struct freefrag *, sizeof(struct freefrag),
1449 M_FREEFRAG, M_SOFTDEP_FLAGS);
1450 freefrag->ff_list.wk_type = D_FREEFRAG;
1451 freefrag->ff_state = ip->i_uid & ~ONWORKLIST; /* XXX - used below */
1452 freefrag->ff_inum = ip->i_number;
1453 freefrag->ff_mnt = ITOV(ip)->v_mount;
1454 freefrag->ff_devvp = ip->i_devvp;
1455 freefrag->ff_blkno = blkno;
1456 freefrag->ff_fragsize = size;
1457 return (freefrag);
1458}
1459
1460/*
1461 * This workitem de-allocates fragments that were replaced during
1462 * file block allocation.
1463 */
1464static void
1465handle_workitem_freefrag(freefrag)
1466 struct freefrag *freefrag;
1467{
1468 struct inode tip;
1469
1470 tip.i_vnode = NULL;
1471 tip.i_fs = VFSTOUFS(freefrag->ff_mnt)->um_fs;
1472 tip.i_devvp = freefrag->ff_devvp;
1473 tip.i_dev = freefrag->ff_devvp->v_rdev;
1474 tip.i_number = freefrag->ff_inum;
1475 tip.i_uid = freefrag->ff_state & ~ONWORKLIST; /* XXX - set above */
1476 ffs_blkfree(&tip, freefrag->ff_blkno, freefrag->ff_fragsize);
1477 FREE(freefrag, M_FREEFRAG);
1478}
1479
1480/*
1481 * Indirect block allocation dependencies.
1482 *
1483 * The same dependencies that exist for a direct block also exist when
1484 * a new block is allocated and pointed to by an entry in a block of
1485 * indirect pointers. The undo/redo states described above are also
1486 * used here. Because an indirect block contains many pointers that
1487 * may have dependencies, a second copy of the entire in-memory indirect
1488 * block is kept. The buffer cache copy is always completely up-to-date.
1489 * The second copy, which is used only as a source for disk writes,
1490 * contains only the safe pointers (i.e., those that have no remaining
1491 * update dependencies). The second copy is freed when all pointers
1492 * are safe. The cache is not allowed to replace indirect blocks with
1493 * pending update dependencies. If a buffer containing an indirect
1494 * block with dependencies is written, these routines will mark it
1495 * dirty again. It can only be successfully written once all the
1496 * dependencies are removed. The ffs_fsync routine in conjunction with
1497 * softdep_sync_metadata work together to get all the dependencies
1498 * removed so that a file can be successfully written to disk. Three
1499 * procedures are used when setting up indirect block pointer
1500 * dependencies. The division is necessary because of the organization
1501 * of the "balloc" routine and because of the distinction between file
1502 * pages and file metadata blocks.
1503 */
1504
1505/*
1506 * Allocate a new allocindir structure.
1507 */
1508static struct allocindir *
1509newallocindir(ip, ptrno, newblkno, oldblkno)
1510 struct inode *ip; /* inode for file being extended */
1511 int ptrno; /* offset of pointer in indirect block */
1512 ufs_daddr_t newblkno; /* disk block number being added */
1513 ufs_daddr_t oldblkno; /* previous block number, 0 if none */
1514{
1515 struct allocindir *aip;
1516
1517 MALLOC(aip, struct allocindir *, sizeof(struct allocindir),
1518 M_ALLOCINDIR, M_SOFTDEP_FLAGS|M_ZERO);
1519 aip->ai_list.wk_type = D_ALLOCINDIR;
1520 aip->ai_state = ATTACHED;
1521 aip->ai_offset = ptrno;
1522 aip->ai_newblkno = newblkno;
1523 aip->ai_oldblkno = oldblkno;
1524 aip->ai_freefrag = newfreefrag(ip, oldblkno, ip->i_fs->fs_bsize);
1525 return (aip);
1526}
1527
1528/*
1529 * Called just before setting an indirect block pointer
1530 * to a newly allocated file page.
1531 */
1532void
1533softdep_setup_allocindir_page(ip, lbn, bp, ptrno, newblkno, oldblkno, nbp)
1534 struct inode *ip; /* inode for file being extended */
1535 ufs_lbn_t lbn; /* allocated block number within file */
1536 struct buf *bp; /* buffer with indirect blk referencing page */
1537 int ptrno; /* offset of pointer in indirect block */
1538 ufs_daddr_t newblkno; /* disk block number being added */
1539 ufs_daddr_t oldblkno; /* previous block number, 0 if none */
1540 struct buf *nbp; /* buffer holding allocated page */
1541{
1542 struct allocindir *aip;
1543 struct pagedep *pagedep;
1544
1545 aip = newallocindir(ip, ptrno, newblkno, oldblkno);
1546 ACQUIRE_LOCK(&lk);
1547 /*
1548 * If we are allocating a directory page, then we must
1549 * allocate an associated pagedep to track additions and
1550 * deletions.
1551 */
1552 if ((ip->i_mode & IFMT) == IFDIR &&
1553 pagedep_lookup(ip, lbn, DEPALLOC, &pagedep) == 0)
1554 WORKLIST_INSERT(&nbp->b_dep, &pagedep->pd_list);
1555 WORKLIST_INSERT(&nbp->b_dep, &aip->ai_list);
1556 FREE_LOCK(&lk);
1557 setup_allocindir_phase2(bp, ip, aip);
1558}
1559
1560/*
1561 * Called just before setting an indirect block pointer to a
1562 * newly allocated indirect block.
1563 */
1564void
1565softdep_setup_allocindir_meta(nbp, ip, bp, ptrno, newblkno)
1566 struct buf *nbp; /* newly allocated indirect block */
1567 struct inode *ip; /* inode for file being extended */
1568 struct buf *bp; /* indirect block referencing allocated block */
1569 int ptrno; /* offset of pointer in indirect block */
1570 ufs_daddr_t newblkno; /* disk block number being added */
1571{
1572 struct allocindir *aip;
1573
1574 aip = newallocindir(ip, ptrno, newblkno, 0);
1575 ACQUIRE_LOCK(&lk);
1576 WORKLIST_INSERT(&nbp->b_dep, &aip->ai_list);
1577 FREE_LOCK(&lk);
1578 setup_allocindir_phase2(bp, ip, aip);
1579}
1580
1581/*
1582 * Called to finish the allocation of the "aip" allocated
1583 * by one of the two routines above.
1584 */
1585static void
1586setup_allocindir_phase2(bp, ip, aip)
1587 struct buf *bp; /* in-memory copy of the indirect block */
1588 struct inode *ip; /* inode for file being extended */
1589 struct allocindir *aip; /* allocindir allocated by the above routines */
1590{
1591 struct worklist *wk;
1592 struct indirdep *indirdep, *newindirdep;
1593 struct bmsafemap *bmsafemap;
1594 struct allocindir *oldaip;
1595 struct freefrag *freefrag;
1596 struct newblk *newblk;
1597
1598 if (bp->b_lblkno >= 0)
1599 panic("setup_allocindir_phase2: not indir blk");
1600 for (indirdep = NULL, newindirdep = NULL; ; ) {
1601 ACQUIRE_LOCK(&lk);
1602 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
1603 if (wk->wk_type != D_INDIRDEP)
1604 continue;
1605 indirdep = WK_INDIRDEP(wk);
1606 break;
1607 }
1608 if (indirdep == NULL && newindirdep) {
1609 indirdep = newindirdep;
1610 WORKLIST_INSERT(&bp->b_dep, &indirdep->ir_list);
1611 newindirdep = NULL;
1612 }
1613 FREE_LOCK(&lk);
1614 if (indirdep) {
1615 if (newblk_lookup(ip->i_fs, aip->ai_newblkno, 0,
1616 &newblk) == 0)
1617 panic("setup_allocindir: lost block");
1618 ACQUIRE_LOCK(&lk);
1619 if (newblk->nb_state == DEPCOMPLETE) {
1620 aip->ai_state |= DEPCOMPLETE;
1621 aip->ai_buf = NULL;
1622 } else {
1623 bmsafemap = newblk->nb_bmsafemap;
1624 aip->ai_buf = bmsafemap->sm_buf;
1625 LIST_REMOVE(newblk, nb_deps);
1626 LIST_INSERT_HEAD(&bmsafemap->sm_allocindirhd,
1627 aip, ai_deps);
1628 }
1629 LIST_REMOVE(newblk, nb_hash);
1630 FREE(newblk, M_NEWBLK);
1631 aip->ai_indirdep = indirdep;
1632 /*
1633 * Check to see if there is an existing dependency
1634 * for this block. If there is, merge the old
1635 * dependency into the new one.
1636 */
1637 if (aip->ai_oldblkno == 0)
1638 oldaip = NULL;
1639 else
1640
1641 LIST_FOREACH(oldaip, &indirdep->ir_deplisthd, ai_next)
1642 if (oldaip->ai_offset == aip->ai_offset)
1643 break;
1644 freefrag = NULL;
1645 if (oldaip != NULL) {
1646 if (oldaip->ai_newblkno != aip->ai_oldblkno) {
1647 FREE_LOCK(&lk);
1648 panic("setup_allocindir_phase2: blkno");
1649 }
1650 aip->ai_oldblkno = oldaip->ai_oldblkno;
1651 freefrag = aip->ai_freefrag;
1652 aip->ai_freefrag = oldaip->ai_freefrag;
1653 oldaip->ai_freefrag = NULL;
1654 free_allocindir(oldaip, NULL);
1655 }
1656 LIST_INSERT_HEAD(&indirdep->ir_deplisthd, aip, ai_next);
1657 ((ufs_daddr_t *)indirdep->ir_savebp->b_data)
1658 [aip->ai_offset] = aip->ai_oldblkno;
1659 FREE_LOCK(&lk);
1660 if (freefrag != NULL)
1661 handle_workitem_freefrag(freefrag);
1662 }
1663 if (newindirdep) {
1664 if (indirdep->ir_savebp != NULL)
1665 brelse(newindirdep->ir_savebp);
1666 WORKITEM_FREE((caddr_t)newindirdep, D_INDIRDEP);
1667 }
1668 if (indirdep)
1669 break;
1670 MALLOC(newindirdep, struct indirdep *, sizeof(struct indirdep),
1671 M_INDIRDEP, M_SOFTDEP_FLAGS);
1672 newindirdep->ir_list.wk_type = D_INDIRDEP;
1673 newindirdep->ir_state = ATTACHED;
1674 LIST_INIT(&newindirdep->ir_deplisthd);
1675 LIST_INIT(&newindirdep->ir_donehd);
1676 if (bp->b_blkno == bp->b_lblkno)
1677 ufs_bmaparray(bp->b_vp, bp->b_lblkno, &bp->b_blkno, NULL, NULL);
1678 newindirdep->ir_savebp =
1679 getblk(ip->i_devvp, bp->b_blkno, bp->b_bcount, 0, 0);
1680 BUF_KERNPROC(newindirdep->ir_savebp);
1681 bcopy(bp->b_data, newindirdep->ir_savebp->b_data, bp->b_bcount);
1682 }
1683}
1684
1685/*
1686 * Block de-allocation dependencies.
1687 *
1688 * When blocks are de-allocated, the on-disk pointers must be nullified before
1689 * the blocks are made available for use by other files. (The true
1690 * requirement is that old pointers must be nullified before new on-disk
1691 * pointers are set. We chose this slightly more stringent requirement to
1692 * reduce complexity.) Our implementation handles this dependency by updating
1693 * the inode (or indirect block) appropriately but delaying the actual block
1694 * de-allocation (i.e., freemap and free space count manipulation) until
1695 * after the updated versions reach stable storage. After the disk is
1696 * updated, the blocks can be safely de-allocated whenever it is convenient.
1697 * This implementation handles only the common case of reducing a file's
1698 * length to zero. Other cases are handled by the conventional synchronous
1699 * write approach.
1700 *
1701 * The ffs implementation with which we worked double-checks
1702 * the state of the block pointers and file size as it reduces
1703 * a file's length. Some of this code is replicated here in our
1704 * soft updates implementation. The freeblks->fb_chkcnt field is
1705 * used to transfer a part of this information to the procedure
1706 * that eventually de-allocates the blocks.
1707 *
1708 * This routine should be called from the routine that shortens
1709 * a file's length, before the inode's size or block pointers
1710 * are modified. It will save the block pointer information for
1711 * later release and zero the inode so that the calling routine
1712 * can release it.
1713 */
1714void
1715softdep_setup_freeblocks(ip, length)
1716 struct inode *ip; /* The inode whose length is to be reduced */
1717 off_t length; /* The new length for the file */
1718{
1719 struct freeblks *freeblks;
1720 struct inodedep *inodedep;
1721 struct allocdirect *adp;
1722 struct vnode *vp;
1723 struct buf *bp;
1724 struct fs *fs;
1725 int i, delay, error;
1726
1727 fs = ip->i_fs;
1728 if (length != 0)
|
1728 panic("softde_setup_freeblocks: non-zero length");
| 1729 panic("softdep_setup_freeblocks: non-zero length");
|
1729 MALLOC(freeblks, struct freeblks *, sizeof(struct freeblks),
1730 M_FREEBLKS, M_SOFTDEP_FLAGS|M_ZERO);
1731 freeblks->fb_list.wk_type = D_FREEBLKS;
1732 freeblks->fb_uid = ip->i_uid;
1733 freeblks->fb_previousinum = ip->i_number;
1734 freeblks->fb_devvp = ip->i_devvp;
1735 freeblks->fb_mnt = ITOV(ip)->v_mount;
1736 freeblks->fb_oldsize = ip->i_size;
1737 freeblks->fb_newsize = length;
1738 freeblks->fb_chkcnt = ip->i_blocks;
1739 for (i = 0; i < NDADDR; i++) {
1740 freeblks->fb_dblks[i] = ip->i_db[i];
1741 ip->i_db[i] = 0;
1742 }
1743 for (i = 0; i < NIADDR; i++) {
1744 freeblks->fb_iblks[i] = ip->i_ib[i];
1745 ip->i_ib[i] = 0;
1746 }
1747 ip->i_blocks = 0;
1748 ip->i_size = 0;
1749 /*
| 1730 MALLOC(freeblks, struct freeblks *, sizeof(struct freeblks),
1731 M_FREEBLKS, M_SOFTDEP_FLAGS|M_ZERO);
1732 freeblks->fb_list.wk_type = D_FREEBLKS;
1733 freeblks->fb_uid = ip->i_uid;
1734 freeblks->fb_previousinum = ip->i_number;
1735 freeblks->fb_devvp = ip->i_devvp;
1736 freeblks->fb_mnt = ITOV(ip)->v_mount;
1737 freeblks->fb_oldsize = ip->i_size;
1738 freeblks->fb_newsize = length;
1739 freeblks->fb_chkcnt = ip->i_blocks;
1740 for (i = 0; i < NDADDR; i++) {
1741 freeblks->fb_dblks[i] = ip->i_db[i];
1742 ip->i_db[i] = 0;
1743 }
1744 for (i = 0; i < NIADDR; i++) {
1745 freeblks->fb_iblks[i] = ip->i_ib[i];
1746 ip->i_ib[i] = 0;
1747 }
1748 ip->i_blocks = 0;
1749 ip->i_size = 0;
1750 /*
|
| 1751 * If the file was removed, then the space being freed was
1752 * accounted for then (see softdep_filereleased()). If the
1753 * file is merely being truncated, then we account for it now.
1754 */
1755 if ((ip->i_flag & IN_SPACECOUNTED) == 0)
1756 fs->fs_pendingblocks += freeblks->fb_chkcnt;
1757 /*
|
1750 * Push the zero'ed inode to to its disk buffer so that we are free
1751 * to delete its dependencies below. Once the dependencies are gone
1752 * the buffer can be safely released.
1753 */
1754 if ((error = bread(ip->i_devvp,
1755 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
1756 (int)fs->fs_bsize, NOCRED, &bp)) != 0)
1757 softdep_error("softdep_setup_freeblocks", error);
1758 *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number)) =
1759 ip->i_din;
1760 /*
1761 * Find and eliminate any inode dependencies.
1762 */
1763 ACQUIRE_LOCK(&lk);
1764 (void) inodedep_lookup(fs, ip->i_number, DEPALLOC, &inodedep);
1765 if ((inodedep->id_state & IOSTARTED) != 0) {
1766 FREE_LOCK(&lk);
1767 panic("softdep_setup_freeblocks: inode busy");
1768 }
1769 /*
1770 * Add the freeblks structure to the list of operations that
1771 * must await the zero'ed inode being written to disk. If we
1772 * still have a bitmap dependency (delay == 0), then the inode
1773 * has never been written to disk, so we can process the
1774 * freeblks below once we have deleted the dependencies.
1775 */
1776 delay = (inodedep->id_state & DEPCOMPLETE);
1777 if (delay)
1778 WORKLIST_INSERT(&inodedep->id_bufwait, &freeblks->fb_list);
1779 /*
1780 * Because the file length has been truncated to zero, any
1781 * pending block allocation dependency structures associated
1782 * with this inode are obsolete and can simply be de-allocated.
1783 * We must first merge the two dependency lists to get rid of
1784 * any duplicate freefrag structures, then purge the merged list.
1785 * If we still have a bitmap dependency, then the inode has never
1786 * been written to disk, so we can free any fragments without delay.
1787 */
1788 merge_inode_lists(inodedep);
1789 while ((adp = TAILQ_FIRST(&inodedep->id_inoupdt)) != 0)
1790 free_allocdirect(&inodedep->id_inoupdt, adp, delay);
1791 FREE_LOCK(&lk);
1792 bdwrite(bp);
1793 /*
1794 * We must wait for any I/O in progress to finish so that
1795 * all potential buffers on the dirty list will be visible.
1796 * Once they are all there, walk the list and get rid of
1797 * any dependencies.
1798 */
1799 vp = ITOV(ip);
1800 ACQUIRE_LOCK(&lk);
1801 drain_output(vp, 1);
1802 while (getdirtybuf(&TAILQ_FIRST(&vp->v_dirtyblkhd), MNT_WAIT)) {
1803 bp = TAILQ_FIRST(&vp->v_dirtyblkhd);
1804 (void) inodedep_lookup(fs, ip->i_number, 0, &inodedep);
1805 deallocate_dependencies(bp, inodedep);
1806 bp->b_flags |= B_INVAL | B_NOCACHE;
1807 FREE_LOCK(&lk);
1808 brelse(bp);
1809 ACQUIRE_LOCK(&lk);
1810 }
1811 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) != 0)
1812 (void) free_inodedep(inodedep);
1813 FREE_LOCK(&lk);
1814 /*
1815 * If the inode has never been written to disk (delay == 0),
1816 * then we can process the freeblks now that we have deleted
1817 * the dependencies.
1818 */
1819 if (!delay)
1820 handle_workitem_freeblocks(freeblks, 0);
1821}
1822
1823/*
1824 * Reclaim any dependency structures from a buffer that is about to
1825 * be reallocated to a new vnode. The buffer must be locked, thus,
1826 * no I/O completion operations can occur while we are manipulating
1827 * its associated dependencies. The mutex is held so that other I/O's
1828 * associated with related dependencies do not occur.
1829 */
1830static void
1831deallocate_dependencies(bp, inodedep)
1832 struct buf *bp;
1833 struct inodedep *inodedep;
1834{
1835 struct worklist *wk;
1836 struct indirdep *indirdep;
1837 struct allocindir *aip;
1838 struct pagedep *pagedep;
1839 struct dirrem *dirrem;
1840 struct diradd *dap;
1841 int i;
1842
1843 while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
1844 switch (wk->wk_type) {
1845
1846 case D_INDIRDEP:
1847 indirdep = WK_INDIRDEP(wk);
1848 /*
1849 * None of the indirect pointers will ever be visible,
1850 * so they can simply be tossed. GOINGAWAY ensures
1851 * that allocated pointers will be saved in the buffer
1852 * cache until they are freed. Note that they will
1853 * only be able to be found by their physical address
1854 * since the inode mapping the logical address will
1855 * be gone. The save buffer used for the safe copy
1856 * was allocated in setup_allocindir_phase2 using
1857 * the physical address so it could be used for this
1858 * purpose. Hence we swap the safe copy with the real
1859 * copy, allowing the safe copy to be freed and holding
1860 * on to the real copy for later use in indir_trunc.
1861 */
1862 if (indirdep->ir_state & GOINGAWAY) {
1863 FREE_LOCK(&lk);
1864 panic("deallocate_dependencies: already gone");
1865 }
1866 indirdep->ir_state |= GOINGAWAY;
1867 while ((aip = LIST_FIRST(&indirdep->ir_deplisthd)) != 0)
1868 free_allocindir(aip, inodedep);
1869 if (bp->b_lblkno >= 0 ||
1870 bp->b_blkno != indirdep->ir_savebp->b_lblkno) {
1871 FREE_LOCK(&lk);
1872 panic("deallocate_dependencies: not indir");
1873 }
1874 bcopy(bp->b_data, indirdep->ir_savebp->b_data,
1875 bp->b_bcount);
1876 WORKLIST_REMOVE(wk);
1877 WORKLIST_INSERT(&indirdep->ir_savebp->b_dep, wk);
1878 continue;
1879
1880 case D_PAGEDEP:
1881 pagedep = WK_PAGEDEP(wk);
1882 /*
1883 * None of the directory additions will ever be
1884 * visible, so they can simply be tossed.
1885 */
1886 for (i = 0; i < DAHASHSZ; i++)
1887 while ((dap =
1888 LIST_FIRST(&pagedep->pd_diraddhd[i])))
1889 free_diradd(dap);
1890 while ((dap = LIST_FIRST(&pagedep->pd_pendinghd)) != 0)
1891 free_diradd(dap);
1892 /*
1893 * Copy any directory remove dependencies to the list
1894 * to be processed after the zero'ed inode is written.
1895 * If the inode has already been written, then they
1896 * can be dumped directly onto the work list.
1897 */
1898 LIST_FOREACH(dirrem, &pagedep->pd_dirremhd, dm_next) {
1899 LIST_REMOVE(dirrem, dm_next);
1900 dirrem->dm_dirinum = pagedep->pd_ino;
1901 if (inodedep == NULL ||
1902 (inodedep->id_state & ALLCOMPLETE) ==
1903 ALLCOMPLETE)
1904 add_to_worklist(&dirrem->dm_list);
1905 else
1906 WORKLIST_INSERT(&inodedep->id_bufwait,
1907 &dirrem->dm_list);
1908 }
1909 WORKLIST_REMOVE(&pagedep->pd_list);
1910 LIST_REMOVE(pagedep, pd_hash);
1911 WORKITEM_FREE(pagedep, D_PAGEDEP);
1912 continue;
1913
1914 case D_ALLOCINDIR:
1915 free_allocindir(WK_ALLOCINDIR(wk), inodedep);
1916 continue;
1917
1918 case D_ALLOCDIRECT:
1919 case D_INODEDEP:
1920 FREE_LOCK(&lk);
1921 panic("deallocate_dependencies: Unexpected type %s",
1922 TYPENAME(wk->wk_type));
1923 /* NOTREACHED */
1924
1925 default:
1926 FREE_LOCK(&lk);
1927 panic("deallocate_dependencies: Unknown type %s",
1928 TYPENAME(wk->wk_type));
1929 /* NOTREACHED */
1930 }
1931 }
1932}
1933
1934/*
1935 * Free an allocdirect. Generate a new freefrag work request if appropriate.
1936 * This routine must be called with splbio interrupts blocked.
1937 */
1938static void
1939free_allocdirect(adphead, adp, delay)
1940 struct allocdirectlst *adphead;
1941 struct allocdirect *adp;
1942 int delay;
1943{
1944
1945#ifdef DEBUG
1946 if (lk.lkt_held == -1)
1947 panic("free_allocdirect: lock not held");
1948#endif
1949 if ((adp->ad_state & DEPCOMPLETE) == 0)
1950 LIST_REMOVE(adp, ad_deps);
1951 TAILQ_REMOVE(adphead, adp, ad_next);
1952 if ((adp->ad_state & COMPLETE) == 0)
1953 WORKLIST_REMOVE(&adp->ad_list);
1954 if (adp->ad_freefrag != NULL) {
1955 if (delay)
1956 WORKLIST_INSERT(&adp->ad_inodedep->id_bufwait,
1957 &adp->ad_freefrag->ff_list);
1958 else
1959 add_to_worklist(&adp->ad_freefrag->ff_list);
1960 }
1961 WORKITEM_FREE(adp, D_ALLOCDIRECT);
1962}
1963
1964/*
1965 * Prepare an inode to be freed. The actual free operation is not
1966 * done until the zero'ed inode has been written to disk.
1967 */
1968void
1969softdep_freefile(pvp, ino, mode)
1970 struct vnode *pvp;
1971 ino_t ino;
1972 int mode;
1973{
1974 struct inode *ip = VTOI(pvp);
1975 struct inodedep *inodedep;
1976 struct freefile *freefile;
1977
1978 /*
1979 * This sets up the inode de-allocation dependency.
1980 */
1981 MALLOC(freefile, struct freefile *, sizeof(struct freefile),
1982 M_FREEFILE, M_SOFTDEP_FLAGS);
1983 freefile->fx_list.wk_type = D_FREEFILE;
1984 freefile->fx_list.wk_state = 0;
1985 freefile->fx_mode = mode;
1986 freefile->fx_oldinum = ino;
1987 freefile->fx_devvp = ip->i_devvp;
1988 freefile->fx_mnt = ITOV(ip)->v_mount;
| 1758 * Push the zero'ed inode to to its disk buffer so that we are free
1759 * to delete its dependencies below. Once the dependencies are gone
1760 * the buffer can be safely released.
1761 */
1762 if ((error = bread(ip->i_devvp,
1763 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
1764 (int)fs->fs_bsize, NOCRED, &bp)) != 0)
1765 softdep_error("softdep_setup_freeblocks", error);
1766 *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number)) =
1767 ip->i_din;
1768 /*
1769 * Find and eliminate any inode dependencies.
1770 */
1771 ACQUIRE_LOCK(&lk);
1772 (void) inodedep_lookup(fs, ip->i_number, DEPALLOC, &inodedep);
1773 if ((inodedep->id_state & IOSTARTED) != 0) {
1774 FREE_LOCK(&lk);
1775 panic("softdep_setup_freeblocks: inode busy");
1776 }
1777 /*
1778 * Add the freeblks structure to the list of operations that
1779 * must await the zero'ed inode being written to disk. If we
1780 * still have a bitmap dependency (delay == 0), then the inode
1781 * has never been written to disk, so we can process the
1782 * freeblks below once we have deleted the dependencies.
1783 */
1784 delay = (inodedep->id_state & DEPCOMPLETE);
1785 if (delay)
1786 WORKLIST_INSERT(&inodedep->id_bufwait, &freeblks->fb_list);
1787 /*
1788 * Because the file length has been truncated to zero, any
1789 * pending block allocation dependency structures associated
1790 * with this inode are obsolete and can simply be de-allocated.
1791 * We must first merge the two dependency lists to get rid of
1792 * any duplicate freefrag structures, then purge the merged list.
1793 * If we still have a bitmap dependency, then the inode has never
1794 * been written to disk, so we can free any fragments without delay.
1795 */
1796 merge_inode_lists(inodedep);
1797 while ((adp = TAILQ_FIRST(&inodedep->id_inoupdt)) != 0)
1798 free_allocdirect(&inodedep->id_inoupdt, adp, delay);
1799 FREE_LOCK(&lk);
1800 bdwrite(bp);
1801 /*
1802 * We must wait for any I/O in progress to finish so that
1803 * all potential buffers on the dirty list will be visible.
1804 * Once they are all there, walk the list and get rid of
1805 * any dependencies.
1806 */
1807 vp = ITOV(ip);
1808 ACQUIRE_LOCK(&lk);
1809 drain_output(vp, 1);
1810 while (getdirtybuf(&TAILQ_FIRST(&vp->v_dirtyblkhd), MNT_WAIT)) {
1811 bp = TAILQ_FIRST(&vp->v_dirtyblkhd);
1812 (void) inodedep_lookup(fs, ip->i_number, 0, &inodedep);
1813 deallocate_dependencies(bp, inodedep);
1814 bp->b_flags |= B_INVAL | B_NOCACHE;
1815 FREE_LOCK(&lk);
1816 brelse(bp);
1817 ACQUIRE_LOCK(&lk);
1818 }
1819 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) != 0)
1820 (void) free_inodedep(inodedep);
1821 FREE_LOCK(&lk);
1822 /*
1823 * If the inode has never been written to disk (delay == 0),
1824 * then we can process the freeblks now that we have deleted
1825 * the dependencies.
1826 */
1827 if (!delay)
1828 handle_workitem_freeblocks(freeblks, 0);
1829}
1830
1831/*
1832 * Reclaim any dependency structures from a buffer that is about to
1833 * be reallocated to a new vnode. The buffer must be locked, thus,
1834 * no I/O completion operations can occur while we are manipulating
1835 * its associated dependencies. The mutex is held so that other I/O's
1836 * associated with related dependencies do not occur.
1837 */
1838static void
1839deallocate_dependencies(bp, inodedep)
1840 struct buf *bp;
1841 struct inodedep *inodedep;
1842{
1843 struct worklist *wk;
1844 struct indirdep *indirdep;
1845 struct allocindir *aip;
1846 struct pagedep *pagedep;
1847 struct dirrem *dirrem;
1848 struct diradd *dap;
1849 int i;
1850
1851 while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
1852 switch (wk->wk_type) {
1853
1854 case D_INDIRDEP:
1855 indirdep = WK_INDIRDEP(wk);
1856 /*
1857 * None of the indirect pointers will ever be visible,
1858 * so they can simply be tossed. GOINGAWAY ensures
1859 * that allocated pointers will be saved in the buffer
1860 * cache until they are freed. Note that they will
1861 * only be able to be found by their physical address
1862 * since the inode mapping the logical address will
1863 * be gone. The save buffer used for the safe copy
1864 * was allocated in setup_allocindir_phase2 using
1865 * the physical address so it could be used for this
1866 * purpose. Hence we swap the safe copy with the real
1867 * copy, allowing the safe copy to be freed and holding
1868 * on to the real copy for later use in indir_trunc.
1869 */
1870 if (indirdep->ir_state & GOINGAWAY) {
1871 FREE_LOCK(&lk);
1872 panic("deallocate_dependencies: already gone");
1873 }
1874 indirdep->ir_state |= GOINGAWAY;
1875 while ((aip = LIST_FIRST(&indirdep->ir_deplisthd)) != 0)
1876 free_allocindir(aip, inodedep);
1877 if (bp->b_lblkno >= 0 ||
1878 bp->b_blkno != indirdep->ir_savebp->b_lblkno) {
1879 FREE_LOCK(&lk);
1880 panic("deallocate_dependencies: not indir");
1881 }
1882 bcopy(bp->b_data, indirdep->ir_savebp->b_data,
1883 bp->b_bcount);
1884 WORKLIST_REMOVE(wk);
1885 WORKLIST_INSERT(&indirdep->ir_savebp->b_dep, wk);
1886 continue;
1887
1888 case D_PAGEDEP:
1889 pagedep = WK_PAGEDEP(wk);
1890 /*
1891 * None of the directory additions will ever be
1892 * visible, so they can simply be tossed.
1893 */
1894 for (i = 0; i < DAHASHSZ; i++)
1895 while ((dap =
1896 LIST_FIRST(&pagedep->pd_diraddhd[i])))
1897 free_diradd(dap);
1898 while ((dap = LIST_FIRST(&pagedep->pd_pendinghd)) != 0)
1899 free_diradd(dap);
1900 /*
1901 * Copy any directory remove dependencies to the list
1902 * to be processed after the zero'ed inode is written.
1903 * If the inode has already been written, then they
1904 * can be dumped directly onto the work list.
1905 */
1906 LIST_FOREACH(dirrem, &pagedep->pd_dirremhd, dm_next) {
1907 LIST_REMOVE(dirrem, dm_next);
1908 dirrem->dm_dirinum = pagedep->pd_ino;
1909 if (inodedep == NULL ||
1910 (inodedep->id_state & ALLCOMPLETE) ==
1911 ALLCOMPLETE)
1912 add_to_worklist(&dirrem->dm_list);
1913 else
1914 WORKLIST_INSERT(&inodedep->id_bufwait,
1915 &dirrem->dm_list);
1916 }
1917 WORKLIST_REMOVE(&pagedep->pd_list);
1918 LIST_REMOVE(pagedep, pd_hash);
1919 WORKITEM_FREE(pagedep, D_PAGEDEP);
1920 continue;
1921
1922 case D_ALLOCINDIR:
1923 free_allocindir(WK_ALLOCINDIR(wk), inodedep);
1924 continue;
1925
1926 case D_ALLOCDIRECT:
1927 case D_INODEDEP:
1928 FREE_LOCK(&lk);
1929 panic("deallocate_dependencies: Unexpected type %s",
1930 TYPENAME(wk->wk_type));
1931 /* NOTREACHED */
1932
1933 default:
1934 FREE_LOCK(&lk);
1935 panic("deallocate_dependencies: Unknown type %s",
1936 TYPENAME(wk->wk_type));
1937 /* NOTREACHED */
1938 }
1939 }
1940}
1941
1942/*
1943 * Free an allocdirect. Generate a new freefrag work request if appropriate.
1944 * This routine must be called with splbio interrupts blocked.
1945 */
1946static void
1947free_allocdirect(adphead, adp, delay)
1948 struct allocdirectlst *adphead;
1949 struct allocdirect *adp;
1950 int delay;
1951{
1952
1953#ifdef DEBUG
1954 if (lk.lkt_held == -1)
1955 panic("free_allocdirect: lock not held");
1956#endif
1957 if ((adp->ad_state & DEPCOMPLETE) == 0)
1958 LIST_REMOVE(adp, ad_deps);
1959 TAILQ_REMOVE(adphead, adp, ad_next);
1960 if ((adp->ad_state & COMPLETE) == 0)
1961 WORKLIST_REMOVE(&adp->ad_list);
1962 if (adp->ad_freefrag != NULL) {
1963 if (delay)
1964 WORKLIST_INSERT(&adp->ad_inodedep->id_bufwait,
1965 &adp->ad_freefrag->ff_list);
1966 else
1967 add_to_worklist(&adp->ad_freefrag->ff_list);
1968 }
1969 WORKITEM_FREE(adp, D_ALLOCDIRECT);
1970}
1971
1972/*
1973 * Prepare an inode to be freed. The actual free operation is not
1974 * done until the zero'ed inode has been written to disk.
1975 */
1976void
1977softdep_freefile(pvp, ino, mode)
1978 struct vnode *pvp;
1979 ino_t ino;
1980 int mode;
1981{
1982 struct inode *ip = VTOI(pvp);
1983 struct inodedep *inodedep;
1984 struct freefile *freefile;
1985
1986 /*
1987 * This sets up the inode de-allocation dependency.
1988 */
1989 MALLOC(freefile, struct freefile *, sizeof(struct freefile),
1990 M_FREEFILE, M_SOFTDEP_FLAGS);
1991 freefile->fx_list.wk_type = D_FREEFILE;
1992 freefile->fx_list.wk_state = 0;
1993 freefile->fx_mode = mode;
1994 freefile->fx_oldinum = ino;
1995 freefile->fx_devvp = ip->i_devvp;
1996 freefile->fx_mnt = ITOV(ip)->v_mount;
|
| 1997 if ((ip->i_flag & IN_SPACECOUNTED) == 0)
1998 ip->i_fs->fs_pendinginodes += 1;
|
1989
1990 /*
1991 * If the inodedep does not exist, then the zero'ed inode has
1992 * been written to disk. If the allocated inode has never been
1993 * written to disk, then the on-disk inode is zero'ed. In either
1994 * case we can free the file immediately.
1995 */
1996 ACQUIRE_LOCK(&lk);
1997 if (inodedep_lookup(ip->i_fs, ino, 0, &inodedep) == 0 ||
1998 check_inode_unwritten(inodedep)) {
1999 FREE_LOCK(&lk);
2000 handle_workitem_freefile(freefile);
2001 return;
2002 }
2003 WORKLIST_INSERT(&inodedep->id_inowait, &freefile->fx_list);
2004 FREE_LOCK(&lk);
2005}
2006
2007/*
2008 * Check to see if an inode has never been written to disk. If
2009 * so free the inodedep and return success, otherwise return failure.
2010 * This routine must be called with splbio interrupts blocked.
2011 *
2012 * If we still have a bitmap dependency, then the inode has never
2013 * been written to disk. Drop the dependency as it is no longer
2014 * necessary since the inode is being deallocated. We set the
2015 * ALLCOMPLETE flags since the bitmap now properly shows that the
2016 * inode is not allocated. Even if the inode is actively being
2017 * written, it has been rolled back to its zero'ed state, so we
2018 * are ensured that a zero inode is what is on the disk. For short
2019 * lived files, this change will usually result in removing all the
2020 * dependencies from the inode so that it can be freed immediately.
2021 */
2022static int
2023check_inode_unwritten(inodedep)
2024 struct inodedep *inodedep;
2025{
2026
2027 if ((inodedep->id_state & DEPCOMPLETE) != 0 ||
2028 LIST_FIRST(&inodedep->id_pendinghd) != NULL ||
2029 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
2030 LIST_FIRST(&inodedep->id_inowait) != NULL ||
2031 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
2032 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL ||
2033 inodedep->id_nlinkdelta != 0)
2034 return (0);
2035 inodedep->id_state |= ALLCOMPLETE;
2036 LIST_REMOVE(inodedep, id_deps);
2037 inodedep->id_buf = NULL;
2038 if (inodedep->id_state & ONWORKLIST)
2039 WORKLIST_REMOVE(&inodedep->id_list);
2040 if (inodedep->id_savedino != NULL) {
2041 FREE(inodedep->id_savedino, M_INODEDEP);
2042 inodedep->id_savedino = NULL;
2043 }
2044 if (free_inodedep(inodedep) == 0) {
2045 FREE_LOCK(&lk);
2046 panic("check_inode_unwritten: busy inode");
2047 }
2048 return (1);
2049}
2050
2051/*
2052 * Try to free an inodedep structure. Return 1 if it could be freed.
2053 */
2054static int
2055free_inodedep(inodedep)
2056 struct inodedep *inodedep;
2057{
2058
2059 if ((inodedep->id_state & ONWORKLIST) != 0 ||
2060 (inodedep->id_state & ALLCOMPLETE) != ALLCOMPLETE ||
2061 LIST_FIRST(&inodedep->id_pendinghd) != NULL ||
2062 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
2063 LIST_FIRST(&inodedep->id_inowait) != NULL ||
2064 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
2065 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL ||
2066 inodedep->id_nlinkdelta != 0 || inodedep->id_savedino != NULL)
2067 return (0);
2068 LIST_REMOVE(inodedep, id_hash);
2069 WORKITEM_FREE(inodedep, D_INODEDEP);
2070 num_inodedep -= 1;
2071 return (1);
2072}
2073
2074/*
2075 * This workitem routine performs the block de-allocation.
2076 * The workitem is added to the pending list after the updated
2077 * inode block has been written to disk. As mentioned above,
2078 * checks regarding the number of blocks de-allocated (compared
2079 * to the number of blocks allocated for the file) are also
2080 * performed in this function.
2081 */
2082static void
2083handle_workitem_freeblocks(freeblks, flags)
2084 struct freeblks *freeblks;
2085 int flags;
2086{
2087 struct inode tip, *ip;
2088 struct vnode *vp;
2089 ufs_daddr_t bn;
2090 struct fs *fs;
2091 int i, level, bsize;
2092 long nblocks, blocksreleased = 0;
2093 int error, allerror = 0;
2094 ufs_lbn_t baselbns[NIADDR], tmpval;
2095
2096 tip.i_fs = fs = VFSTOUFS(freeblks->fb_mnt)->um_fs;
2097 tip.i_number = freeblks->fb_previousinum;
2098 tip.i_devvp = freeblks->fb_devvp;
2099 tip.i_dev = freeblks->fb_devvp->v_rdev;
2100 tip.i_size = freeblks->fb_oldsize;
2101 tip.i_uid = freeblks->fb_uid;
2102 tip.i_vnode = NULL;
2103 tmpval = 1;
2104 baselbns[0] = NDADDR;
2105 for (i = 1; i < NIADDR; i++) {
2106 tmpval *= NINDIR(fs);
2107 baselbns[i] = baselbns[i - 1] + tmpval;
2108 }
2109 nblocks = btodb(fs->fs_bsize);
2110 blocksreleased = 0;
2111 /*
2112 * Indirect blocks first.
2113 */
2114 for (level = (NIADDR - 1); level >= 0; level--) {
2115 if ((bn = freeblks->fb_iblks[level]) == 0)
2116 continue;
2117 if ((error = indir_trunc(&tip, fsbtodb(fs, bn), level,
2118 baselbns[level], &blocksreleased)) == 0)
2119 allerror = error;
2120 ffs_blkfree(&tip, bn, fs->fs_bsize);
| 1999
2000 /*
2001 * If the inodedep does not exist, then the zero'ed inode has
2002 * been written to disk. If the allocated inode has never been
2003 * written to disk, then the on-disk inode is zero'ed. In either
2004 * case we can free the file immediately.
2005 */
2006 ACQUIRE_LOCK(&lk);
2007 if (inodedep_lookup(ip->i_fs, ino, 0, &inodedep) == 0 ||
2008 check_inode_unwritten(inodedep)) {
2009 FREE_LOCK(&lk);
2010 handle_workitem_freefile(freefile);
2011 return;
2012 }
2013 WORKLIST_INSERT(&inodedep->id_inowait, &freefile->fx_list);
2014 FREE_LOCK(&lk);
2015}
2016
2017/*
2018 * Check to see if an inode has never been written to disk. If
2019 * so free the inodedep and return success, otherwise return failure.
2020 * This routine must be called with splbio interrupts blocked.
2021 *
2022 * If we still have a bitmap dependency, then the inode has never
2023 * been written to disk. Drop the dependency as it is no longer
2024 * necessary since the inode is being deallocated. We set the
2025 * ALLCOMPLETE flags since the bitmap now properly shows that the
2026 * inode is not allocated. Even if the inode is actively being
2027 * written, it has been rolled back to its zero'ed state, so we
2028 * are ensured that a zero inode is what is on the disk. For short
2029 * lived files, this change will usually result in removing all the
2030 * dependencies from the inode so that it can be freed immediately.
2031 */
2032static int
2033check_inode_unwritten(inodedep)
2034 struct inodedep *inodedep;
2035{
2036
2037 if ((inodedep->id_state & DEPCOMPLETE) != 0 ||
2038 LIST_FIRST(&inodedep->id_pendinghd) != NULL ||
2039 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
2040 LIST_FIRST(&inodedep->id_inowait) != NULL ||
2041 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
2042 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL ||
2043 inodedep->id_nlinkdelta != 0)
2044 return (0);
2045 inodedep->id_state |= ALLCOMPLETE;
2046 LIST_REMOVE(inodedep, id_deps);
2047 inodedep->id_buf = NULL;
2048 if (inodedep->id_state & ONWORKLIST)
2049 WORKLIST_REMOVE(&inodedep->id_list);
2050 if (inodedep->id_savedino != NULL) {
2051 FREE(inodedep->id_savedino, M_INODEDEP);
2052 inodedep->id_savedino = NULL;
2053 }
2054 if (free_inodedep(inodedep) == 0) {
2055 FREE_LOCK(&lk);
2056 panic("check_inode_unwritten: busy inode");
2057 }
2058 return (1);
2059}
2060
2061/*
2062 * Try to free an inodedep structure. Return 1 if it could be freed.
2063 */
2064static int
2065free_inodedep(inodedep)
2066 struct inodedep *inodedep;
2067{
2068
2069 if ((inodedep->id_state & ONWORKLIST) != 0 ||
2070 (inodedep->id_state & ALLCOMPLETE) != ALLCOMPLETE ||
2071 LIST_FIRST(&inodedep->id_pendinghd) != NULL ||
2072 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
2073 LIST_FIRST(&inodedep->id_inowait) != NULL ||
2074 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
2075 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL ||
2076 inodedep->id_nlinkdelta != 0 || inodedep->id_savedino != NULL)
2077 return (0);
2078 LIST_REMOVE(inodedep, id_hash);
2079 WORKITEM_FREE(inodedep, D_INODEDEP);
2080 num_inodedep -= 1;
2081 return (1);
2082}
2083
2084/*
2085 * This workitem routine performs the block de-allocation.
2086 * The workitem is added to the pending list after the updated
2087 * inode block has been written to disk. As mentioned above,
2088 * checks regarding the number of blocks de-allocated (compared
2089 * to the number of blocks allocated for the file) are also
2090 * performed in this function.
2091 */
2092static void
2093handle_workitem_freeblocks(freeblks, flags)
2094 struct freeblks *freeblks;
2095 int flags;
2096{
2097 struct inode tip, *ip;
2098 struct vnode *vp;
2099 ufs_daddr_t bn;
2100 struct fs *fs;
2101 int i, level, bsize;
2102 long nblocks, blocksreleased = 0;
2103 int error, allerror = 0;
2104 ufs_lbn_t baselbns[NIADDR], tmpval;
2105
2106 tip.i_fs = fs = VFSTOUFS(freeblks->fb_mnt)->um_fs;
2107 tip.i_number = freeblks->fb_previousinum;
2108 tip.i_devvp = freeblks->fb_devvp;
2109 tip.i_dev = freeblks->fb_devvp->v_rdev;
2110 tip.i_size = freeblks->fb_oldsize;
2111 tip.i_uid = freeblks->fb_uid;
2112 tip.i_vnode = NULL;
2113 tmpval = 1;
2114 baselbns[0] = NDADDR;
2115 for (i = 1; i < NIADDR; i++) {
2116 tmpval *= NINDIR(fs);
2117 baselbns[i] = baselbns[i - 1] + tmpval;
2118 }
2119 nblocks = btodb(fs->fs_bsize);
2120 blocksreleased = 0;
2121 /*
2122 * Indirect blocks first.
2123 */
2124 for (level = (NIADDR - 1); level >= 0; level--) {
2125 if ((bn = freeblks->fb_iblks[level]) == 0)
2126 continue;
2127 if ((error = indir_trunc(&tip, fsbtodb(fs, bn), level,
2128 baselbns[level], &blocksreleased)) == 0)
2129 allerror = error;
2130 ffs_blkfree(&tip, bn, fs->fs_bsize);
|
| 2131 fs->fs_pendingblocks -= nblocks;
|
2121 blocksreleased += nblocks;
2122 }
2123 /*
2124 * All direct blocks or frags.
2125 */
2126 for (i = (NDADDR - 1); i >= 0; i--) {
2127 if ((bn = freeblks->fb_dblks[i]) == 0)
2128 continue;
2129 bsize = blksize(fs, &tip, i);
2130 ffs_blkfree(&tip, bn, bsize);
| 2132 blocksreleased += nblocks;
2133 }
2134 /*
2135 * All direct blocks or frags.
2136 */
2137 for (i = (NDADDR - 1); i >= 0; i--) {
2138 if ((bn = freeblks->fb_dblks[i]) == 0)
2139 continue;
2140 bsize = blksize(fs, &tip, i);
2141 ffs_blkfree(&tip, bn, bsize);
|
| 2142 fs->fs_pendingblocks -= btodb(bsize);
|
2131 blocksreleased += btodb(bsize);
2132 }
2133 /*
2134 * If we still have not finished background cleanup, then check
2135 * to see if the block count needs to be adjusted.
2136 */
2137 if (freeblks->fb_chkcnt != blocksreleased &&
2138 (fs->fs_flags & FS_UNCLEAN) != 0 && (flags & LK_NOWAIT) == 0 &&
2139 VFS_VGET(freeblks->fb_mnt, freeblks->fb_previousinum, &vp) == 0) {
2140 ip = VTOI(vp);
2141 ip->i_blocks += freeblks->fb_chkcnt - blocksreleased;
2142 ip->i_flag |= IN_CHANGE;
2143 vput(vp);
2144 }
2145
2146#ifdef DIAGNOSTIC
2147 if (freeblks->fb_chkcnt != blocksreleased &&
2148 ((fs->fs_flags & FS_UNCLEAN) == 0 || (flags & LK_NOWAIT) != 0))
2149 printf("handle_workitem_freeblocks: block count");
2150 if (allerror)
2151 softdep_error("handle_workitem_freeblks", allerror);
2152#endif /* DIAGNOSTIC */
2153
2154 WORKITEM_FREE(freeblks, D_FREEBLKS);
2155}
2156
2157/*
2158 * Release blocks associated with the inode ip and stored in the indirect
2159 * block dbn. If level is greater than SINGLE, the block is an indirect block
2160 * and recursive calls to indirtrunc must be used to cleanse other indirect
2161 * blocks.
2162 */
2163static int
2164indir_trunc(ip, dbn, level, lbn, countp)
2165 struct inode *ip;
2166 ufs_daddr_t dbn;
2167 int level;
2168 ufs_lbn_t lbn;
2169 long *countp;
2170{
2171 struct buf *bp;
2172 ufs_daddr_t *bap;
2173 ufs_daddr_t nb;
2174 struct fs *fs;
2175 struct worklist *wk;
2176 struct indirdep *indirdep;
2177 int i, lbnadd, nblocks;
2178 int error, allerror = 0;
2179
2180 fs = ip->i_fs;
2181 lbnadd = 1;
2182 for (i = level; i > 0; i--)
2183 lbnadd *= NINDIR(fs);
2184 /*
2185 * Get buffer of block pointers to be freed. This routine is not
2186 * called until the zero'ed inode has been written, so it is safe
2187 * to free blocks as they are encountered. Because the inode has
2188 * been zero'ed, calls to bmap on these blocks will fail. So, we
2189 * have to use the on-disk address and the block device for the
2190 * filesystem to look them up. If the file was deleted before its
2191 * indirect blocks were all written to disk, the routine that set
2192 * us up (deallocate_dependencies) will have arranged to leave
2193 * a complete copy of the indirect block in memory for our use.
2194 * Otherwise we have to read the blocks in from the disk.
2195 */
2196 ACQUIRE_LOCK(&lk);
2197 if ((bp = incore(ip->i_devvp, dbn)) != NULL &&
2198 (wk = LIST_FIRST(&bp->b_dep)) != NULL) {
2199 if (wk->wk_type != D_INDIRDEP ||
2200 (indirdep = WK_INDIRDEP(wk))->ir_savebp != bp ||
2201 (indirdep->ir_state & GOINGAWAY) == 0) {
2202 FREE_LOCK(&lk);
2203 panic("indir_trunc: lost indirdep");
2204 }
2205 WORKLIST_REMOVE(wk);
2206 WORKITEM_FREE(indirdep, D_INDIRDEP);
2207 if (LIST_FIRST(&bp->b_dep) != NULL) {
2208 FREE_LOCK(&lk);
2209 panic("indir_trunc: dangling dep");
2210 }
2211 FREE_LOCK(&lk);
2212 } else {
2213 FREE_LOCK(&lk);
2214 error = bread(ip->i_devvp, dbn, (int)fs->fs_bsize, NOCRED, &bp);
2215 if (error)
2216 return (error);
2217 }
2218 /*
2219 * Recursively free indirect blocks.
2220 */
2221 bap = (ufs_daddr_t *)bp->b_data;
2222 nblocks = btodb(fs->fs_bsize);
2223 for (i = NINDIR(fs) - 1; i >= 0; i--) {
2224 if ((nb = bap[i]) == 0)
2225 continue;
2226 if (level != 0) {
2227 if ((error = indir_trunc(ip, fsbtodb(fs, nb),
2228 level - 1, lbn + (i * lbnadd), countp)) != 0)
2229 allerror = error;
2230 }
2231 ffs_blkfree(ip, nb, fs->fs_bsize);
| 2143 blocksreleased += btodb(bsize);
2144 }
2145 /*
2146 * If we still have not finished background cleanup, then check
2147 * to see if the block count needs to be adjusted.
2148 */
2149 if (freeblks->fb_chkcnt != blocksreleased &&
2150 (fs->fs_flags & FS_UNCLEAN) != 0 && (flags & LK_NOWAIT) == 0 &&
2151 VFS_VGET(freeblks->fb_mnt, freeblks->fb_previousinum, &vp) == 0) {
2152 ip = VTOI(vp);
2153 ip->i_blocks += freeblks->fb_chkcnt - blocksreleased;
2154 ip->i_flag |= IN_CHANGE;
2155 vput(vp);
2156 }
2157
2158#ifdef DIAGNOSTIC
2159 if (freeblks->fb_chkcnt != blocksreleased &&
2160 ((fs->fs_flags & FS_UNCLEAN) == 0 || (flags & LK_NOWAIT) != 0))
2161 printf("handle_workitem_freeblocks: block count");
2162 if (allerror)
2163 softdep_error("handle_workitem_freeblks", allerror);
2164#endif /* DIAGNOSTIC */
2165
2166 WORKITEM_FREE(freeblks, D_FREEBLKS);
2167}
2168
2169/*
2170 * Release blocks associated with the inode ip and stored in the indirect
2171 * block dbn. If level is greater than SINGLE, the block is an indirect block
2172 * and recursive calls to indirtrunc must be used to cleanse other indirect
2173 * blocks.
2174 */
2175static int
2176indir_trunc(ip, dbn, level, lbn, countp)
2177 struct inode *ip;
2178 ufs_daddr_t dbn;
2179 int level;
2180 ufs_lbn_t lbn;
2181 long *countp;
2182{
2183 struct buf *bp;
2184 ufs_daddr_t *bap;
2185 ufs_daddr_t nb;
2186 struct fs *fs;
2187 struct worklist *wk;
2188 struct indirdep *indirdep;
2189 int i, lbnadd, nblocks;
2190 int error, allerror = 0;
2191
2192 fs = ip->i_fs;
2193 lbnadd = 1;
2194 for (i = level; i > 0; i--)
2195 lbnadd *= NINDIR(fs);
2196 /*
2197 * Get buffer of block pointers to be freed. This routine is not
2198 * called until the zero'ed inode has been written, so it is safe
2199 * to free blocks as they are encountered. Because the inode has
2200 * been zero'ed, calls to bmap on these blocks will fail. So, we
2201 * have to use the on-disk address and the block device for the
2202 * filesystem to look them up. If the file was deleted before its
2203 * indirect blocks were all written to disk, the routine that set
2204 * us up (deallocate_dependencies) will have arranged to leave
2205 * a complete copy of the indirect block in memory for our use.
2206 * Otherwise we have to read the blocks in from the disk.
2207 */
2208 ACQUIRE_LOCK(&lk);
2209 if ((bp = incore(ip->i_devvp, dbn)) != NULL &&
2210 (wk = LIST_FIRST(&bp->b_dep)) != NULL) {
2211 if (wk->wk_type != D_INDIRDEP ||
2212 (indirdep = WK_INDIRDEP(wk))->ir_savebp != bp ||
2213 (indirdep->ir_state & GOINGAWAY) == 0) {
2214 FREE_LOCK(&lk);
2215 panic("indir_trunc: lost indirdep");
2216 }
2217 WORKLIST_REMOVE(wk);
2218 WORKITEM_FREE(indirdep, D_INDIRDEP);
2219 if (LIST_FIRST(&bp->b_dep) != NULL) {
2220 FREE_LOCK(&lk);
2221 panic("indir_trunc: dangling dep");
2222 }
2223 FREE_LOCK(&lk);
2224 } else {
2225 FREE_LOCK(&lk);
2226 error = bread(ip->i_devvp, dbn, (int)fs->fs_bsize, NOCRED, &bp);
2227 if (error)
2228 return (error);
2229 }
2230 /*
2231 * Recursively free indirect blocks.
2232 */
2233 bap = (ufs_daddr_t *)bp->b_data;
2234 nblocks = btodb(fs->fs_bsize);
2235 for (i = NINDIR(fs) - 1; i >= 0; i--) {
2236 if ((nb = bap[i]) == 0)
2237 continue;
2238 if (level != 0) {
2239 if ((error = indir_trunc(ip, fsbtodb(fs, nb),
2240 level - 1, lbn + (i * lbnadd), countp)) != 0)
2241 allerror = error;
2242 }
2243 ffs_blkfree(ip, nb, fs->fs_bsize);
|
| 2244 fs->fs_pendingblocks -= nblocks;
|
2232 *countp += nblocks;
2233 }
2234 bp->b_flags |= B_INVAL | B_NOCACHE;
2235 brelse(bp);
2236 return (allerror);
2237}
2238
2239/*
2240 * Free an allocindir.
2241 * This routine must be called with splbio interrupts blocked.
2242 */
2243static void
2244free_allocindir(aip, inodedep)
2245 struct allocindir *aip;
2246 struct inodedep *inodedep;
2247{
2248 struct freefrag *freefrag;
2249
2250#ifdef DEBUG
2251 if (lk.lkt_held == -1)
2252 panic("free_allocindir: lock not held");
2253#endif
2254 if ((aip->ai_state & DEPCOMPLETE) == 0)
2255 LIST_REMOVE(aip, ai_deps);
2256 if (aip->ai_state & ONWORKLIST)
2257 WORKLIST_REMOVE(&aip->ai_list);
2258 LIST_REMOVE(aip, ai_next);
2259 if ((freefrag = aip->ai_freefrag) != NULL) {
2260 if (inodedep == NULL)
2261 add_to_worklist(&freefrag->ff_list);
2262 else
2263 WORKLIST_INSERT(&inodedep->id_bufwait,
2264 &freefrag->ff_list);
2265 }
2266 WORKITEM_FREE(aip, D_ALLOCINDIR);
2267}
2268
2269/*
2270 * Directory entry addition dependencies.
2271 *
2272 * When adding a new directory entry, the inode (with its incremented link
2273 * count) must be written to disk before the directory entry's pointer to it.
2274 * Also, if the inode is newly allocated, the corresponding freemap must be
2275 * updated (on disk) before the directory entry's pointer. These requirements
2276 * are met via undo/redo on the directory entry's pointer, which consists
2277 * simply of the inode number.
2278 *
2279 * As directory entries are added and deleted, the free space within a
2280 * directory block can become fragmented. The ufs file system will compact
2281 * a fragmented directory block to make space for a new entry. When this
2282 * occurs, the offsets of previously added entries change. Any "diradd"
2283 * dependency structures corresponding to these entries must be updated with
2284 * the new offsets.
2285 */
2286
2287/*
2288 * This routine is called after the in-memory inode's link
2289 * count has been incremented, but before the directory entry's
2290 * pointer to the inode has been set.
2291 */
2292void
2293softdep_setup_directory_add(bp, dp, diroffset, newinum, newdirbp)
2294 struct buf *bp; /* buffer containing directory block */
2295 struct inode *dp; /* inode for directory */
2296 off_t diroffset; /* offset of new entry in directory */
2297 long newinum; /* inode referenced by new directory entry */
2298 struct buf *newdirbp; /* non-NULL => contents of new mkdir */
2299{
2300 int offset; /* offset of new entry within directory block */
2301 ufs_lbn_t lbn; /* block in directory containing new entry */
2302 struct fs *fs;
2303 struct diradd *dap;
2304 struct pagedep *pagedep;
2305 struct inodedep *inodedep;
2306 struct mkdir *mkdir1, *mkdir2;
2307
2308 /*
2309 * Whiteouts have no dependencies.
2310 */
2311 if (newinum == WINO) {
2312 if (newdirbp != NULL)
2313 bdwrite(newdirbp);
2314 return;
2315 }
2316
2317 fs = dp->i_fs;
2318 lbn = lblkno(fs, diroffset);
2319 offset = blkoff(fs, diroffset);
2320 MALLOC(dap, struct diradd *, sizeof(struct diradd), M_DIRADD,
2321 M_SOFTDEP_FLAGS|M_ZERO);
2322 dap->da_list.wk_type = D_DIRADD;
2323 dap->da_offset = offset;
2324 dap->da_newinum = newinum;
2325 dap->da_state = ATTACHED;
2326 if (newdirbp == NULL) {
2327 dap->da_state |= DEPCOMPLETE;
2328 ACQUIRE_LOCK(&lk);
2329 } else {
2330 dap->da_state |= MKDIR_BODY | MKDIR_PARENT;
2331 MALLOC(mkdir1, struct mkdir *, sizeof(struct mkdir), M_MKDIR,
2332 M_SOFTDEP_FLAGS);
2333 mkdir1->md_list.wk_type = D_MKDIR;
2334 mkdir1->md_state = MKDIR_BODY;
2335 mkdir1->md_diradd = dap;
2336 MALLOC(mkdir2, struct mkdir *, sizeof(struct mkdir), M_MKDIR,
2337 M_SOFTDEP_FLAGS);
2338 mkdir2->md_list.wk_type = D_MKDIR;
2339 mkdir2->md_state = MKDIR_PARENT;
2340 mkdir2->md_diradd = dap;
2341 /*
2342 * Dependency on "." and ".." being written to disk.
2343 */
2344 mkdir1->md_buf = newdirbp;
2345 ACQUIRE_LOCK(&lk);
2346 LIST_INSERT_HEAD(&mkdirlisthd, mkdir1, md_mkdirs);
2347 WORKLIST_INSERT(&newdirbp->b_dep, &mkdir1->md_list);
2348 FREE_LOCK(&lk);
2349 bdwrite(newdirbp);
2350 /*
2351 * Dependency on link count increase for parent directory
2352 */
2353 ACQUIRE_LOCK(&lk);
2354 if (inodedep_lookup(dp->i_fs, dp->i_number, 0, &inodedep) == 0
2355 || (inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE) {
2356 dap->da_state &= ~MKDIR_PARENT;
2357 WORKITEM_FREE(mkdir2, D_MKDIR);
2358 } else {
2359 LIST_INSERT_HEAD(&mkdirlisthd, mkdir2, md_mkdirs);
2360 WORKLIST_INSERT(&inodedep->id_bufwait,&mkdir2->md_list);
2361 }
2362 }
2363 /*
2364 * Link into parent directory pagedep to await its being written.
2365 */
2366 if (pagedep_lookup(dp, lbn, DEPALLOC, &pagedep) == 0)
2367 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
2368 dap->da_pagedep = pagedep;
2369 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(offset)], dap,
2370 da_pdlist);
2371 /*
2372 * Link into its inodedep. Put it on the id_bufwait list if the inode
2373 * is not yet written. If it is written, do the post-inode write
2374 * processing to put it on the id_pendinghd list.
2375 */
2376 (void) inodedep_lookup(fs, newinum, DEPALLOC, &inodedep);
2377 if ((inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE)
2378 diradd_inode_written(dap, inodedep);
2379 else
2380 WORKLIST_INSERT(&inodedep->id_bufwait, &dap->da_list);
2381 FREE_LOCK(&lk);
2382}
2383
2384/*
2385 * This procedure is called to change the offset of a directory
2386 * entry when compacting a directory block which must be owned
2387 * exclusively by the caller. Note that the actual entry movement
2388 * must be done in this procedure to ensure that no I/O completions
2389 * occur while the move is in progress.
2390 */
2391void
2392softdep_change_directoryentry_offset(dp, base, oldloc, newloc, entrysize)
2393 struct inode *dp; /* inode for directory */
2394 caddr_t base; /* address of dp->i_offset */
2395 caddr_t oldloc; /* address of old directory location */
2396 caddr_t newloc; /* address of new directory location */
2397 int entrysize; /* size of directory entry */
2398{
2399 int offset, oldoffset, newoffset;
2400 struct pagedep *pagedep;
2401 struct diradd *dap;
2402 ufs_lbn_t lbn;
2403
2404 ACQUIRE_LOCK(&lk);
2405 lbn = lblkno(dp->i_fs, dp->i_offset);
2406 offset = blkoff(dp->i_fs, dp->i_offset);
2407 if (pagedep_lookup(dp, lbn, 0, &pagedep) == 0)
2408 goto done;
2409 oldoffset = offset + (oldloc - base);
2410 newoffset = offset + (newloc - base);
2411
2412 LIST_FOREACH(dap, &pagedep->pd_diraddhd[DIRADDHASH(oldoffset)], da_pdlist) {
2413 if (dap->da_offset != oldoffset)
2414 continue;
2415 dap->da_offset = newoffset;
2416 if (DIRADDHASH(newoffset) == DIRADDHASH(oldoffset))
2417 break;
2418 LIST_REMOVE(dap, da_pdlist);
2419 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(newoffset)],
2420 dap, da_pdlist);
2421 break;
2422 }
2423 if (dap == NULL) {
2424
2425 LIST_FOREACH(dap, &pagedep->pd_pendinghd, da_pdlist) {
2426 if (dap->da_offset == oldoffset) {
2427 dap->da_offset = newoffset;
2428 break;
2429 }
2430 }
2431 }
2432done:
2433 bcopy(oldloc, newloc, entrysize);
2434 FREE_LOCK(&lk);
2435}
2436
2437/*
2438 * Free a diradd dependency structure. This routine must be called
2439 * with splbio interrupts blocked.
2440 */
2441static void
2442free_diradd(dap)
2443 struct diradd *dap;
2444{
2445 struct dirrem *dirrem;
2446 struct pagedep *pagedep;
2447 struct inodedep *inodedep;
2448 struct mkdir *mkdir, *nextmd;
2449
2450#ifdef DEBUG
2451 if (lk.lkt_held == -1)
2452 panic("free_diradd: lock not held");
2453#endif
2454 WORKLIST_REMOVE(&dap->da_list);
2455 LIST_REMOVE(dap, da_pdlist);
2456 if ((dap->da_state & DIRCHG) == 0) {
2457 pagedep = dap->da_pagedep;
2458 } else {
2459 dirrem = dap->da_previous;
2460 pagedep = dirrem->dm_pagedep;
2461 dirrem->dm_dirinum = pagedep->pd_ino;
2462 add_to_worklist(&dirrem->dm_list);
2463 }
2464 if (inodedep_lookup(VFSTOUFS(pagedep->pd_mnt)->um_fs, dap->da_newinum,
2465 0, &inodedep) != 0)
2466 (void) free_inodedep(inodedep);
2467 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) != 0) {
2468 for (mkdir = LIST_FIRST(&mkdirlisthd); mkdir; mkdir = nextmd) {
2469 nextmd = LIST_NEXT(mkdir, md_mkdirs);
2470 if (mkdir->md_diradd != dap)
2471 continue;
2472 dap->da_state &= ~mkdir->md_state;
2473 WORKLIST_REMOVE(&mkdir->md_list);
2474 LIST_REMOVE(mkdir, md_mkdirs);
2475 WORKITEM_FREE(mkdir, D_MKDIR);
2476 }
2477 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) != 0) {
2478 FREE_LOCK(&lk);
2479 panic("free_diradd: unfound ref");
2480 }
2481 }
2482 WORKITEM_FREE(dap, D_DIRADD);
2483}
2484
2485/*
2486 * Directory entry removal dependencies.
2487 *
2488 * When removing a directory entry, the entry's inode pointer must be
2489 * zero'ed on disk before the corresponding inode's link count is decremented
2490 * (possibly freeing the inode for re-use). This dependency is handled by
2491 * updating the directory entry but delaying the inode count reduction until
2492 * after the directory block has been written to disk. After this point, the
2493 * inode count can be decremented whenever it is convenient.
2494 */
2495
2496/*
2497 * This routine should be called immediately after removing
2498 * a directory entry. The inode's link count should not be
2499 * decremented by the calling procedure -- the soft updates
2500 * code will do this task when it is safe.
2501 */
2502void
2503softdep_setup_remove(bp, dp, ip, isrmdir)
2504 struct buf *bp; /* buffer containing directory block */
2505 struct inode *dp; /* inode for the directory being modified */
2506 struct inode *ip; /* inode for directory entry being removed */
2507 int isrmdir; /* indicates if doing RMDIR */
2508{
2509 struct dirrem *dirrem, *prevdirrem;
2510
2511 /*
2512 * Allocate a new dirrem if appropriate and ACQUIRE_LOCK.
2513 */
2514 dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
2515
2516 /*
2517 * If the COMPLETE flag is clear, then there were no active
2518 * entries and we want to roll back to a zeroed entry until
2519 * the new inode is committed to disk. If the COMPLETE flag is
2520 * set then we have deleted an entry that never made it to
2521 * disk. If the entry we deleted resulted from a name change,
2522 * then the old name still resides on disk. We cannot delete
2523 * its inode (returned to us in prevdirrem) until the zeroed
2524 * directory entry gets to disk. The new inode has never been
2525 * referenced on the disk, so can be deleted immediately.
2526 */
2527 if ((dirrem->dm_state & COMPLETE) == 0) {
2528 LIST_INSERT_HEAD(&dirrem->dm_pagedep->pd_dirremhd, dirrem,
2529 dm_next);
2530 FREE_LOCK(&lk);
2531 } else {
2532 if (prevdirrem != NULL)
2533 LIST_INSERT_HEAD(&dirrem->dm_pagedep->pd_dirremhd,
2534 prevdirrem, dm_next);
2535 dirrem->dm_dirinum = dirrem->dm_pagedep->pd_ino;
2536 FREE_LOCK(&lk);
2537 handle_workitem_remove(dirrem);
2538 }
2539}
2540
2541/*
2542 * Allocate a new dirrem if appropriate and return it along with
2543 * its associated pagedep. Called without a lock, returns with lock.
2544 */
2545static long num_dirrem; /* number of dirrem allocated */
2546static struct dirrem *
2547newdirrem(bp, dp, ip, isrmdir, prevdirremp)
2548 struct buf *bp; /* buffer containing directory block */
2549 struct inode *dp; /* inode for the directory being modified */
2550 struct inode *ip; /* inode for directory entry being removed */
2551 int isrmdir; /* indicates if doing RMDIR */
2552 struct dirrem **prevdirremp; /* previously referenced inode, if any */
2553{
2554 int offset;
2555 ufs_lbn_t lbn;
2556 struct diradd *dap;
2557 struct dirrem *dirrem;
2558 struct pagedep *pagedep;
2559
2560 /*
2561 * Whiteouts have no deletion dependencies.
2562 */
2563 if (ip == NULL)
2564 panic("newdirrem: whiteout");
2565 /*
2566 * If we are over our limit, try to improve the situation.
2567 * Limiting the number of dirrem structures will also limit
2568 * the number of freefile and freeblks structures.
2569 */
2570 if (num_dirrem > max_softdeps / 2)
2571 (void) request_cleanup(FLUSH_REMOVE, 0);
2572 num_dirrem += 1;
2573 MALLOC(dirrem, struct dirrem *, sizeof(struct dirrem),
2574 M_DIRREM, M_SOFTDEP_FLAGS|M_ZERO);
2575 dirrem->dm_list.wk_type = D_DIRREM;
2576 dirrem->dm_state = isrmdir ? RMDIR : 0;
2577 dirrem->dm_mnt = ITOV(ip)->v_mount;
2578 dirrem->dm_oldinum = ip->i_number;
2579 *prevdirremp = NULL;
2580
2581 ACQUIRE_LOCK(&lk);
2582 lbn = lblkno(dp->i_fs, dp->i_offset);
2583 offset = blkoff(dp->i_fs, dp->i_offset);
2584 if (pagedep_lookup(dp, lbn, DEPALLOC, &pagedep) == 0)
2585 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
2586 dirrem->dm_pagedep = pagedep;
2587 /*
2588 * Check for a diradd dependency for the same directory entry.
2589 * If present, then both dependencies become obsolete and can
2590 * be de-allocated. Check for an entry on both the pd_dirraddhd
2591 * list and the pd_pendinghd list.
2592 */
2593
2594 LIST_FOREACH(dap, &pagedep->pd_diraddhd[DIRADDHASH(offset)], da_pdlist)
2595 if (dap->da_offset == offset)
2596 break;
2597 if (dap == NULL) {
2598
2599 LIST_FOREACH(dap, &pagedep->pd_pendinghd, da_pdlist)
2600 if (dap->da_offset == offset)
2601 break;
2602 if (dap == NULL)
2603 return (dirrem);
2604 }
2605 /*
2606 * Must be ATTACHED at this point.
2607 */
2608 if ((dap->da_state & ATTACHED) == 0) {
2609 FREE_LOCK(&lk);
2610 panic("newdirrem: not ATTACHED");
2611 }
2612 if (dap->da_newinum != ip->i_number) {
2613 FREE_LOCK(&lk);
2614 panic("newdirrem: inum %d should be %d",
2615 ip->i_number, dap->da_newinum);
2616 }
2617 /*
2618 * If we are deleting a changed name that never made it to disk,
2619 * then return the dirrem describing the previous inode (which
2620 * represents the inode currently referenced from this entry on disk).
2621 */
2622 if ((dap->da_state & DIRCHG) != 0) {
2623 *prevdirremp = dap->da_previous;
2624 dap->da_state &= ~DIRCHG;
2625 dap->da_pagedep = pagedep;
2626 }
2627 /*
2628 * We are deleting an entry that never made it to disk.
2629 * Mark it COMPLETE so we can delete its inode immediately.
2630 */
2631 dirrem->dm_state |= COMPLETE;
2632 free_diradd(dap);
2633 return (dirrem);
2634}
2635
2636/*
2637 * Directory entry change dependencies.
2638 *
2639 * Changing an existing directory entry requires that an add operation
2640 * be completed first followed by a deletion. The semantics for the addition
2641 * are identical to the description of adding a new entry above except
2642 * that the rollback is to the old inode number rather than zero. Once
2643 * the addition dependency is completed, the removal is done as described
2644 * in the removal routine above.
2645 */
2646
2647/*
2648 * This routine should be called immediately after changing
2649 * a directory entry. The inode's link count should not be
2650 * decremented by the calling procedure -- the soft updates
2651 * code will perform this task when it is safe.
2652 */
2653void
2654softdep_setup_directory_change(bp, dp, ip, newinum, isrmdir)
2655 struct buf *bp; /* buffer containing directory block */
2656 struct inode *dp; /* inode for the directory being modified */
2657 struct inode *ip; /* inode for directory entry being removed */
2658 long newinum; /* new inode number for changed entry */
2659 int isrmdir; /* indicates if doing RMDIR */
2660{
2661 int offset;
2662 struct diradd *dap = NULL;
2663 struct dirrem *dirrem, *prevdirrem;
2664 struct pagedep *pagedep;
2665 struct inodedep *inodedep;
2666
2667 offset = blkoff(dp->i_fs, dp->i_offset);
2668
2669 /*
2670 * Whiteouts do not need diradd dependencies.
2671 */
2672 if (newinum != WINO) {
2673 MALLOC(dap, struct diradd *, sizeof(struct diradd),
2674 M_DIRADD, M_SOFTDEP_FLAGS|M_ZERO);
2675 dap->da_list.wk_type = D_DIRADD;
2676 dap->da_state = DIRCHG | ATTACHED | DEPCOMPLETE;
2677 dap->da_offset = offset;
2678 dap->da_newinum = newinum;
2679 }
2680
2681 /*
2682 * Allocate a new dirrem and ACQUIRE_LOCK.
2683 */
2684 dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
2685 pagedep = dirrem->dm_pagedep;
2686 /*
2687 * The possible values for isrmdir:
2688 * 0 - non-directory file rename
2689 * 1 - directory rename within same directory
2690 * inum - directory rename to new directory of given inode number
2691 * When renaming to a new directory, we are both deleting and
2692 * creating a new directory entry, so the link count on the new
2693 * directory should not change. Thus we do not need the followup
2694 * dirrem which is usually done in handle_workitem_remove. We set
2695 * the DIRCHG flag to tell handle_workitem_remove to skip the
2696 * followup dirrem.
2697 */
2698 if (isrmdir > 1)
2699 dirrem->dm_state |= DIRCHG;
2700
2701 /*
2702 * Whiteouts have no additional dependencies,
2703 * so just put the dirrem on the correct list.
2704 */
2705 if (newinum == WINO) {
2706 if ((dirrem->dm_state & COMPLETE) == 0) {
2707 LIST_INSERT_HEAD(&pagedep->pd_dirremhd, dirrem,
2708 dm_next);
2709 } else {
2710 dirrem->dm_dirinum = pagedep->pd_ino;
2711 add_to_worklist(&dirrem->dm_list);
2712 }
2713 FREE_LOCK(&lk);
2714 return;
2715 }
2716
2717 /*
2718 * If the COMPLETE flag is clear, then there were no active
2719 * entries and we want to roll back to the previous inode until
2720 * the new inode is committed to disk. If the COMPLETE flag is
2721 * set, then we have deleted an entry that never made it to disk.
2722 * If the entry we deleted resulted from a name change, then the old
2723 * inode reference still resides on disk. Any rollback that we do
2724 * needs to be to that old inode (returned to us in prevdirrem). If
2725 * the entry we deleted resulted from a create, then there is
2726 * no entry on the disk, so we want to roll back to zero rather
2727 * than the uncommitted inode. In either of the COMPLETE cases we
2728 * want to immediately free the unwritten and unreferenced inode.
2729 */
2730 if ((dirrem->dm_state & COMPLETE) == 0) {
2731 dap->da_previous = dirrem;
2732 } else {
2733 if (prevdirrem != NULL) {
2734 dap->da_previous = prevdirrem;
2735 } else {
2736 dap->da_state &= ~DIRCHG;
2737 dap->da_pagedep = pagedep;
2738 }
2739 dirrem->dm_dirinum = pagedep->pd_ino;
2740 add_to_worklist(&dirrem->dm_list);
2741 }
2742 /*
2743 * Link into its inodedep. Put it on the id_bufwait list if the inode
2744 * is not yet written. If it is written, do the post-inode write
2745 * processing to put it on the id_pendinghd list.
2746 */
2747 if (inodedep_lookup(dp->i_fs, newinum, DEPALLOC, &inodedep) == 0 ||
2748 (inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE) {
2749 dap->da_state |= COMPLETE;
2750 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
2751 WORKLIST_INSERT(&inodedep->id_pendinghd, &dap->da_list);
2752 } else {
2753 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(offset)],
2754 dap, da_pdlist);
2755 WORKLIST_INSERT(&inodedep->id_bufwait, &dap->da_list);
2756 }
2757 FREE_LOCK(&lk);
2758}
2759
2760/*
2761 * Called whenever the link count on an inode is changed.
2762 * It creates an inode dependency so that the new reference(s)
2763 * to the inode cannot be committed to disk until the updated
2764 * inode has been written.
2765 */
2766void
2767softdep_change_linkcnt(ip)
2768 struct inode *ip; /* the inode with the increased link count */
2769{
2770 struct inodedep *inodedep;
2771
2772 ACQUIRE_LOCK(&lk);
2773 (void) inodedep_lookup(ip->i_fs, ip->i_number, DEPALLOC, &inodedep);
2774 if (ip->i_nlink < ip->i_effnlink) {
2775 FREE_LOCK(&lk);
2776 panic("softdep_change_linkcnt: bad delta");
2777 }
2778 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2779 FREE_LOCK(&lk);
2780}
2781
2782/*
| 2245 *countp += nblocks;
2246 }
2247 bp->b_flags |= B_INVAL | B_NOCACHE;
2248 brelse(bp);
2249 return (allerror);
2250}
2251
2252/*
2253 * Free an allocindir.
2254 * This routine must be called with splbio interrupts blocked.
2255 */
2256static void
2257free_allocindir(aip, inodedep)
2258 struct allocindir *aip;
2259 struct inodedep *inodedep;
2260{
2261 struct freefrag *freefrag;
2262
2263#ifdef DEBUG
2264 if (lk.lkt_held == -1)
2265 panic("free_allocindir: lock not held");
2266#endif
2267 if ((aip->ai_state & DEPCOMPLETE) == 0)
2268 LIST_REMOVE(aip, ai_deps);
2269 if (aip->ai_state & ONWORKLIST)
2270 WORKLIST_REMOVE(&aip->ai_list);
2271 LIST_REMOVE(aip, ai_next);
2272 if ((freefrag = aip->ai_freefrag) != NULL) {
2273 if (inodedep == NULL)
2274 add_to_worklist(&freefrag->ff_list);
2275 else
2276 WORKLIST_INSERT(&inodedep->id_bufwait,
2277 &freefrag->ff_list);
2278 }
2279 WORKITEM_FREE(aip, D_ALLOCINDIR);
2280}
2281
2282/*
2283 * Directory entry addition dependencies.
2284 *
2285 * When adding a new directory entry, the inode (with its incremented link
2286 * count) must be written to disk before the directory entry's pointer to it.
2287 * Also, if the inode is newly allocated, the corresponding freemap must be
2288 * updated (on disk) before the directory entry's pointer. These requirements
2289 * are met via undo/redo on the directory entry's pointer, which consists
2290 * simply of the inode number.
2291 *
2292 * As directory entries are added and deleted, the free space within a
2293 * directory block can become fragmented. The ufs file system will compact
2294 * a fragmented directory block to make space for a new entry. When this
2295 * occurs, the offsets of previously added entries change. Any "diradd"
2296 * dependency structures corresponding to these entries must be updated with
2297 * the new offsets.
2298 */
2299
2300/*
2301 * This routine is called after the in-memory inode's link
2302 * count has been incremented, but before the directory entry's
2303 * pointer to the inode has been set.
2304 */
2305void
2306softdep_setup_directory_add(bp, dp, diroffset, newinum, newdirbp)
2307 struct buf *bp; /* buffer containing directory block */
2308 struct inode *dp; /* inode for directory */
2309 off_t diroffset; /* offset of new entry in directory */
2310 long newinum; /* inode referenced by new directory entry */
2311 struct buf *newdirbp; /* non-NULL => contents of new mkdir */
2312{
2313 int offset; /* offset of new entry within directory block */
2314 ufs_lbn_t lbn; /* block in directory containing new entry */
2315 struct fs *fs;
2316 struct diradd *dap;
2317 struct pagedep *pagedep;
2318 struct inodedep *inodedep;
2319 struct mkdir *mkdir1, *mkdir2;
2320
2321 /*
2322 * Whiteouts have no dependencies.
2323 */
2324 if (newinum == WINO) {
2325 if (newdirbp != NULL)
2326 bdwrite(newdirbp);
2327 return;
2328 }
2329
2330 fs = dp->i_fs;
2331 lbn = lblkno(fs, diroffset);
2332 offset = blkoff(fs, diroffset);
2333 MALLOC(dap, struct diradd *, sizeof(struct diradd), M_DIRADD,
2334 M_SOFTDEP_FLAGS|M_ZERO);
2335 dap->da_list.wk_type = D_DIRADD;
2336 dap->da_offset = offset;
2337 dap->da_newinum = newinum;
2338 dap->da_state = ATTACHED;
2339 if (newdirbp == NULL) {
2340 dap->da_state |= DEPCOMPLETE;
2341 ACQUIRE_LOCK(&lk);
2342 } else {
2343 dap->da_state |= MKDIR_BODY | MKDIR_PARENT;
2344 MALLOC(mkdir1, struct mkdir *, sizeof(struct mkdir), M_MKDIR,
2345 M_SOFTDEP_FLAGS);
2346 mkdir1->md_list.wk_type = D_MKDIR;
2347 mkdir1->md_state = MKDIR_BODY;
2348 mkdir1->md_diradd = dap;
2349 MALLOC(mkdir2, struct mkdir *, sizeof(struct mkdir), M_MKDIR,
2350 M_SOFTDEP_FLAGS);
2351 mkdir2->md_list.wk_type = D_MKDIR;
2352 mkdir2->md_state = MKDIR_PARENT;
2353 mkdir2->md_diradd = dap;
2354 /*
2355 * Dependency on "." and ".." being written to disk.
2356 */
2357 mkdir1->md_buf = newdirbp;
2358 ACQUIRE_LOCK(&lk);
2359 LIST_INSERT_HEAD(&mkdirlisthd, mkdir1, md_mkdirs);
2360 WORKLIST_INSERT(&newdirbp->b_dep, &mkdir1->md_list);
2361 FREE_LOCK(&lk);
2362 bdwrite(newdirbp);
2363 /*
2364 * Dependency on link count increase for parent directory
2365 */
2366 ACQUIRE_LOCK(&lk);
2367 if (inodedep_lookup(dp->i_fs, dp->i_number, 0, &inodedep) == 0
2368 || (inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE) {
2369 dap->da_state &= ~MKDIR_PARENT;
2370 WORKITEM_FREE(mkdir2, D_MKDIR);
2371 } else {
2372 LIST_INSERT_HEAD(&mkdirlisthd, mkdir2, md_mkdirs);
2373 WORKLIST_INSERT(&inodedep->id_bufwait,&mkdir2->md_list);
2374 }
2375 }
2376 /*
2377 * Link into parent directory pagedep to await its being written.
2378 */
2379 if (pagedep_lookup(dp, lbn, DEPALLOC, &pagedep) == 0)
2380 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
2381 dap->da_pagedep = pagedep;
2382 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(offset)], dap,
2383 da_pdlist);
2384 /*
2385 * Link into its inodedep. Put it on the id_bufwait list if the inode
2386 * is not yet written. If it is written, do the post-inode write
2387 * processing to put it on the id_pendinghd list.
2388 */
2389 (void) inodedep_lookup(fs, newinum, DEPALLOC, &inodedep);
2390 if ((inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE)
2391 diradd_inode_written(dap, inodedep);
2392 else
2393 WORKLIST_INSERT(&inodedep->id_bufwait, &dap->da_list);
2394 FREE_LOCK(&lk);
2395}
2396
2397/*
2398 * This procedure is called to change the offset of a directory
2399 * entry when compacting a directory block which must be owned
2400 * exclusively by the caller. Note that the actual entry movement
2401 * must be done in this procedure to ensure that no I/O completions
2402 * occur while the move is in progress.
2403 */
2404void
2405softdep_change_directoryentry_offset(dp, base, oldloc, newloc, entrysize)
2406 struct inode *dp; /* inode for directory */
2407 caddr_t base; /* address of dp->i_offset */
2408 caddr_t oldloc; /* address of old directory location */
2409 caddr_t newloc; /* address of new directory location */
2410 int entrysize; /* size of directory entry */
2411{
2412 int offset, oldoffset, newoffset;
2413 struct pagedep *pagedep;
2414 struct diradd *dap;
2415 ufs_lbn_t lbn;
2416
2417 ACQUIRE_LOCK(&lk);
2418 lbn = lblkno(dp->i_fs, dp->i_offset);
2419 offset = blkoff(dp->i_fs, dp->i_offset);
2420 if (pagedep_lookup(dp, lbn, 0, &pagedep) == 0)
2421 goto done;
2422 oldoffset = offset + (oldloc - base);
2423 newoffset = offset + (newloc - base);
2424
2425 LIST_FOREACH(dap, &pagedep->pd_diraddhd[DIRADDHASH(oldoffset)], da_pdlist) {
2426 if (dap->da_offset != oldoffset)
2427 continue;
2428 dap->da_offset = newoffset;
2429 if (DIRADDHASH(newoffset) == DIRADDHASH(oldoffset))
2430 break;
2431 LIST_REMOVE(dap, da_pdlist);
2432 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(newoffset)],
2433 dap, da_pdlist);
2434 break;
2435 }
2436 if (dap == NULL) {
2437
2438 LIST_FOREACH(dap, &pagedep->pd_pendinghd, da_pdlist) {
2439 if (dap->da_offset == oldoffset) {
2440 dap->da_offset = newoffset;
2441 break;
2442 }
2443 }
2444 }
2445done:
2446 bcopy(oldloc, newloc, entrysize);
2447 FREE_LOCK(&lk);
2448}
2449
2450/*
2451 * Free a diradd dependency structure. This routine must be called
2452 * with splbio interrupts blocked.
2453 */
2454static void
2455free_diradd(dap)
2456 struct diradd *dap;
2457{
2458 struct dirrem *dirrem;
2459 struct pagedep *pagedep;
2460 struct inodedep *inodedep;
2461 struct mkdir *mkdir, *nextmd;
2462
2463#ifdef DEBUG
2464 if (lk.lkt_held == -1)
2465 panic("free_diradd: lock not held");
2466#endif
2467 WORKLIST_REMOVE(&dap->da_list);
2468 LIST_REMOVE(dap, da_pdlist);
2469 if ((dap->da_state & DIRCHG) == 0) {
2470 pagedep = dap->da_pagedep;
2471 } else {
2472 dirrem = dap->da_previous;
2473 pagedep = dirrem->dm_pagedep;
2474 dirrem->dm_dirinum = pagedep->pd_ino;
2475 add_to_worklist(&dirrem->dm_list);
2476 }
2477 if (inodedep_lookup(VFSTOUFS(pagedep->pd_mnt)->um_fs, dap->da_newinum,
2478 0, &inodedep) != 0)
2479 (void) free_inodedep(inodedep);
2480 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) != 0) {
2481 for (mkdir = LIST_FIRST(&mkdirlisthd); mkdir; mkdir = nextmd) {
2482 nextmd = LIST_NEXT(mkdir, md_mkdirs);
2483 if (mkdir->md_diradd != dap)
2484 continue;
2485 dap->da_state &= ~mkdir->md_state;
2486 WORKLIST_REMOVE(&mkdir->md_list);
2487 LIST_REMOVE(mkdir, md_mkdirs);
2488 WORKITEM_FREE(mkdir, D_MKDIR);
2489 }
2490 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) != 0) {
2491 FREE_LOCK(&lk);
2492 panic("free_diradd: unfound ref");
2493 }
2494 }
2495 WORKITEM_FREE(dap, D_DIRADD);
2496}
2497
2498/*
2499 * Directory entry removal dependencies.
2500 *
2501 * When removing a directory entry, the entry's inode pointer must be
2502 * zero'ed on disk before the corresponding inode's link count is decremented
2503 * (possibly freeing the inode for re-use). This dependency is handled by
2504 * updating the directory entry but delaying the inode count reduction until
2505 * after the directory block has been written to disk. After this point, the
2506 * inode count can be decremented whenever it is convenient.
2507 */
2508
2509/*
2510 * This routine should be called immediately after removing
2511 * a directory entry. The inode's link count should not be
2512 * decremented by the calling procedure -- the soft updates
2513 * code will do this task when it is safe.
2514 */
2515void
2516softdep_setup_remove(bp, dp, ip, isrmdir)
2517 struct buf *bp; /* buffer containing directory block */
2518 struct inode *dp; /* inode for the directory being modified */
2519 struct inode *ip; /* inode for directory entry being removed */
2520 int isrmdir; /* indicates if doing RMDIR */
2521{
2522 struct dirrem *dirrem, *prevdirrem;
2523
2524 /*
2525 * Allocate a new dirrem if appropriate and ACQUIRE_LOCK.
2526 */
2527 dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
2528
2529 /*
2530 * If the COMPLETE flag is clear, then there were no active
2531 * entries and we want to roll back to a zeroed entry until
2532 * the new inode is committed to disk. If the COMPLETE flag is
2533 * set then we have deleted an entry that never made it to
2534 * disk. If the entry we deleted resulted from a name change,
2535 * then the old name still resides on disk. We cannot delete
2536 * its inode (returned to us in prevdirrem) until the zeroed
2537 * directory entry gets to disk. The new inode has never been
2538 * referenced on the disk, so can be deleted immediately.
2539 */
2540 if ((dirrem->dm_state & COMPLETE) == 0) {
2541 LIST_INSERT_HEAD(&dirrem->dm_pagedep->pd_dirremhd, dirrem,
2542 dm_next);
2543 FREE_LOCK(&lk);
2544 } else {
2545 if (prevdirrem != NULL)
2546 LIST_INSERT_HEAD(&dirrem->dm_pagedep->pd_dirremhd,
2547 prevdirrem, dm_next);
2548 dirrem->dm_dirinum = dirrem->dm_pagedep->pd_ino;
2549 FREE_LOCK(&lk);
2550 handle_workitem_remove(dirrem);
2551 }
2552}
2553
2554/*
2555 * Allocate a new dirrem if appropriate and return it along with
2556 * its associated pagedep. Called without a lock, returns with lock.
2557 */
2558static long num_dirrem; /* number of dirrem allocated */
2559static struct dirrem *
2560newdirrem(bp, dp, ip, isrmdir, prevdirremp)
2561 struct buf *bp; /* buffer containing directory block */
2562 struct inode *dp; /* inode for the directory being modified */
2563 struct inode *ip; /* inode for directory entry being removed */
2564 int isrmdir; /* indicates if doing RMDIR */
2565 struct dirrem **prevdirremp; /* previously referenced inode, if any */
2566{
2567 int offset;
2568 ufs_lbn_t lbn;
2569 struct diradd *dap;
2570 struct dirrem *dirrem;
2571 struct pagedep *pagedep;
2572
2573 /*
2574 * Whiteouts have no deletion dependencies.
2575 */
2576 if (ip == NULL)
2577 panic("newdirrem: whiteout");
2578 /*
2579 * If we are over our limit, try to improve the situation.
2580 * Limiting the number of dirrem structures will also limit
2581 * the number of freefile and freeblks structures.
2582 */
2583 if (num_dirrem > max_softdeps / 2)
2584 (void) request_cleanup(FLUSH_REMOVE, 0);
2585 num_dirrem += 1;
2586 MALLOC(dirrem, struct dirrem *, sizeof(struct dirrem),
2587 M_DIRREM, M_SOFTDEP_FLAGS|M_ZERO);
2588 dirrem->dm_list.wk_type = D_DIRREM;
2589 dirrem->dm_state = isrmdir ? RMDIR : 0;
2590 dirrem->dm_mnt = ITOV(ip)->v_mount;
2591 dirrem->dm_oldinum = ip->i_number;
2592 *prevdirremp = NULL;
2593
2594 ACQUIRE_LOCK(&lk);
2595 lbn = lblkno(dp->i_fs, dp->i_offset);
2596 offset = blkoff(dp->i_fs, dp->i_offset);
2597 if (pagedep_lookup(dp, lbn, DEPALLOC, &pagedep) == 0)
2598 WORKLIST_INSERT(&bp->b_dep, &pagedep->pd_list);
2599 dirrem->dm_pagedep = pagedep;
2600 /*
2601 * Check for a diradd dependency for the same directory entry.
2602 * If present, then both dependencies become obsolete and can
2603 * be de-allocated. Check for an entry on both the pd_dirraddhd
2604 * list and the pd_pendinghd list.
2605 */
2606
2607 LIST_FOREACH(dap, &pagedep->pd_diraddhd[DIRADDHASH(offset)], da_pdlist)
2608 if (dap->da_offset == offset)
2609 break;
2610 if (dap == NULL) {
2611
2612 LIST_FOREACH(dap, &pagedep->pd_pendinghd, da_pdlist)
2613 if (dap->da_offset == offset)
2614 break;
2615 if (dap == NULL)
2616 return (dirrem);
2617 }
2618 /*
2619 * Must be ATTACHED at this point.
2620 */
2621 if ((dap->da_state & ATTACHED) == 0) {
2622 FREE_LOCK(&lk);
2623 panic("newdirrem: not ATTACHED");
2624 }
2625 if (dap->da_newinum != ip->i_number) {
2626 FREE_LOCK(&lk);
2627 panic("newdirrem: inum %d should be %d",
2628 ip->i_number, dap->da_newinum);
2629 }
2630 /*
2631 * If we are deleting a changed name that never made it to disk,
2632 * then return the dirrem describing the previous inode (which
2633 * represents the inode currently referenced from this entry on disk).
2634 */
2635 if ((dap->da_state & DIRCHG) != 0) {
2636 *prevdirremp = dap->da_previous;
2637 dap->da_state &= ~DIRCHG;
2638 dap->da_pagedep = pagedep;
2639 }
2640 /*
2641 * We are deleting an entry that never made it to disk.
2642 * Mark it COMPLETE so we can delete its inode immediately.
2643 */
2644 dirrem->dm_state |= COMPLETE;
2645 free_diradd(dap);
2646 return (dirrem);
2647}
2648
2649/*
2650 * Directory entry change dependencies.
2651 *
2652 * Changing an existing directory entry requires that an add operation
2653 * be completed first followed by a deletion. The semantics for the addition
2654 * are identical to the description of adding a new entry above except
2655 * that the rollback is to the old inode number rather than zero. Once
2656 * the addition dependency is completed, the removal is done as described
2657 * in the removal routine above.
2658 */
2659
2660/*
2661 * This routine should be called immediately after changing
2662 * a directory entry. The inode's link count should not be
2663 * decremented by the calling procedure -- the soft updates
2664 * code will perform this task when it is safe.
2665 */
2666void
2667softdep_setup_directory_change(bp, dp, ip, newinum, isrmdir)
2668 struct buf *bp; /* buffer containing directory block */
2669 struct inode *dp; /* inode for the directory being modified */
2670 struct inode *ip; /* inode for directory entry being removed */
2671 long newinum; /* new inode number for changed entry */
2672 int isrmdir; /* indicates if doing RMDIR */
2673{
2674 int offset;
2675 struct diradd *dap = NULL;
2676 struct dirrem *dirrem, *prevdirrem;
2677 struct pagedep *pagedep;
2678 struct inodedep *inodedep;
2679
2680 offset = blkoff(dp->i_fs, dp->i_offset);
2681
2682 /*
2683 * Whiteouts do not need diradd dependencies.
2684 */
2685 if (newinum != WINO) {
2686 MALLOC(dap, struct diradd *, sizeof(struct diradd),
2687 M_DIRADD, M_SOFTDEP_FLAGS|M_ZERO);
2688 dap->da_list.wk_type = D_DIRADD;
2689 dap->da_state = DIRCHG | ATTACHED | DEPCOMPLETE;
2690 dap->da_offset = offset;
2691 dap->da_newinum = newinum;
2692 }
2693
2694 /*
2695 * Allocate a new dirrem and ACQUIRE_LOCK.
2696 */
2697 dirrem = newdirrem(bp, dp, ip, isrmdir, &prevdirrem);
2698 pagedep = dirrem->dm_pagedep;
2699 /*
2700 * The possible values for isrmdir:
2701 * 0 - non-directory file rename
2702 * 1 - directory rename within same directory
2703 * inum - directory rename to new directory of given inode number
2704 * When renaming to a new directory, we are both deleting and
2705 * creating a new directory entry, so the link count on the new
2706 * directory should not change. Thus we do not need the followup
2707 * dirrem which is usually done in handle_workitem_remove. We set
2708 * the DIRCHG flag to tell handle_workitem_remove to skip the
2709 * followup dirrem.
2710 */
2711 if (isrmdir > 1)
2712 dirrem->dm_state |= DIRCHG;
2713
2714 /*
2715 * Whiteouts have no additional dependencies,
2716 * so just put the dirrem on the correct list.
2717 */
2718 if (newinum == WINO) {
2719 if ((dirrem->dm_state & COMPLETE) == 0) {
2720 LIST_INSERT_HEAD(&pagedep->pd_dirremhd, dirrem,
2721 dm_next);
2722 } else {
2723 dirrem->dm_dirinum = pagedep->pd_ino;
2724 add_to_worklist(&dirrem->dm_list);
2725 }
2726 FREE_LOCK(&lk);
2727 return;
2728 }
2729
2730 /*
2731 * If the COMPLETE flag is clear, then there were no active
2732 * entries and we want to roll back to the previous inode until
2733 * the new inode is committed to disk. If the COMPLETE flag is
2734 * set, then we have deleted an entry that never made it to disk.
2735 * If the entry we deleted resulted from a name change, then the old
2736 * inode reference still resides on disk. Any rollback that we do
2737 * needs to be to that old inode (returned to us in prevdirrem). If
2738 * the entry we deleted resulted from a create, then there is
2739 * no entry on the disk, so we want to roll back to zero rather
2740 * than the uncommitted inode. In either of the COMPLETE cases we
2741 * want to immediately free the unwritten and unreferenced inode.
2742 */
2743 if ((dirrem->dm_state & COMPLETE) == 0) {
2744 dap->da_previous = dirrem;
2745 } else {
2746 if (prevdirrem != NULL) {
2747 dap->da_previous = prevdirrem;
2748 } else {
2749 dap->da_state &= ~DIRCHG;
2750 dap->da_pagedep = pagedep;
2751 }
2752 dirrem->dm_dirinum = pagedep->pd_ino;
2753 add_to_worklist(&dirrem->dm_list);
2754 }
2755 /*
2756 * Link into its inodedep. Put it on the id_bufwait list if the inode
2757 * is not yet written. If it is written, do the post-inode write
2758 * processing to put it on the id_pendinghd list.
2759 */
2760 if (inodedep_lookup(dp->i_fs, newinum, DEPALLOC, &inodedep) == 0 ||
2761 (inodedep->id_state & ALLCOMPLETE) == ALLCOMPLETE) {
2762 dap->da_state |= COMPLETE;
2763 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
2764 WORKLIST_INSERT(&inodedep->id_pendinghd, &dap->da_list);
2765 } else {
2766 LIST_INSERT_HEAD(&pagedep->pd_diraddhd[DIRADDHASH(offset)],
2767 dap, da_pdlist);
2768 WORKLIST_INSERT(&inodedep->id_bufwait, &dap->da_list);
2769 }
2770 FREE_LOCK(&lk);
2771}
2772
2773/*
2774 * Called whenever the link count on an inode is changed.
2775 * It creates an inode dependency so that the new reference(s)
2776 * to the inode cannot be committed to disk until the updated
2777 * inode has been written.
2778 */
2779void
2780softdep_change_linkcnt(ip)
2781 struct inode *ip; /* the inode with the increased link count */
2782{
2783 struct inodedep *inodedep;
2784
2785 ACQUIRE_LOCK(&lk);
2786 (void) inodedep_lookup(ip->i_fs, ip->i_number, DEPALLOC, &inodedep);
2787 if (ip->i_nlink < ip->i_effnlink) {
2788 FREE_LOCK(&lk);
2789 panic("softdep_change_linkcnt: bad delta");
2790 }
2791 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2792 FREE_LOCK(&lk);
2793}
2794
2795/*
|
| 2796 * Called when the effective link count and the reference count
2797 * on an inode drops to zero. At this point there are no names
2798 * referencing the file in the filesystem and no active file
2799 * references. The space associated with the file will be freed
2800 * as soon as the necessary soft dependencies are cleared.
2801 */
2802void
2803softdep_releasefile(ip)
2804 struct inode *ip; /* inode with the zero effective link count */
2805{
2806 struct inodedep *inodedep;
2807
2808 if (ip->i_effnlink > 0)
2809 panic("softdep_filerelease: file still referenced");
2810 /*
2811 * We may be called several times as the real reference count
2812 * drops to zero. We only want to account for the space once.
2813 */
2814 if (ip->i_flag & IN_SPACECOUNTED)
2815 return;
2816 /*
2817 * We have to deactivate a snapshot otherwise copyonwrites may
2818 * add blocks and the cleanup may remove blocks after we have
2819 * tried to account for them.
2820 */
2821 if ((ip->i_flags & SF_SNAPSHOT) != 0)
2822 ffs_snapremove(ITOV(ip));
2823 /*
2824 * If we are tracking an nlinkdelta, we have to also remember
2825 * whether we accounted for the freed space yet.
2826 */
2827 ACQUIRE_LOCK(&lk);
2828 if ((inodedep_lookup(ip->i_fs, ip->i_number, 0, &inodedep)))
2829 inodedep->id_state |= SPACECOUNTED;
2830 FREE_LOCK(&lk);
2831 ip->i_fs->fs_pendingblocks += ip->i_blocks;
2832 ip->i_fs->fs_pendinginodes += 1;
2833 ip->i_flag |= IN_SPACECOUNTED;
2834}
2835
2836/*
|
2783 * This workitem decrements the inode's link count.
2784 * If the link count reaches zero, the file is removed.
2785 */
2786static void
2787handle_workitem_remove(dirrem)
2788 struct dirrem *dirrem;
2789{
2790 struct proc *p = CURPROC; /* XXX */
2791 struct inodedep *inodedep;
2792 struct vnode *vp;
2793 struct inode *ip;
2794 ino_t oldinum;
2795 int error;
2796
2797 if ((error = VFS_VGET(dirrem->dm_mnt, dirrem->dm_oldinum, &vp)) != 0) {
2798 softdep_error("handle_workitem_remove: vget", error);
2799 return;
2800 }
2801 ip = VTOI(vp);
2802 ACQUIRE_LOCK(&lk);
2803 if ((inodedep_lookup(ip->i_fs, dirrem->dm_oldinum, 0, &inodedep)) == 0){
2804 FREE_LOCK(&lk);
2805 panic("handle_workitem_remove: lost inodedep");
2806 }
2807 /*
2808 * Normal file deletion.
2809 */
2810 if ((dirrem->dm_state & RMDIR) == 0) {
2811 ip->i_nlink--;
2812 ip->i_flag |= IN_CHANGE;
2813 if (ip->i_nlink < ip->i_effnlink) {
2814 FREE_LOCK(&lk);
2815 panic("handle_workitem_remove: bad file delta");
2816 }
2817 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2818 FREE_LOCK(&lk);
2819 vput(vp);
2820 num_dirrem -= 1;
2821 WORKITEM_FREE(dirrem, D_DIRREM);
2822 return;
2823 }
2824 /*
2825 * Directory deletion. Decrement reference count for both the
2826 * just deleted parent directory entry and the reference for ".".
2827 * Next truncate the directory to length zero. When the
2828 * truncation completes, arrange to have the reference count on
2829 * the parent decremented to account for the loss of "..".
2830 */
2831 ip->i_nlink -= 2;
2832 ip->i_flag |= IN_CHANGE;
2833 if (ip->i_nlink < ip->i_effnlink) {
2834 FREE_LOCK(&lk);
2835 panic("handle_workitem_remove: bad dir delta");
2836 }
2837 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2838 FREE_LOCK(&lk);
2839 if ((error = UFS_TRUNCATE(vp, (off_t)0, 0, p->p_ucred, p)) != 0)
2840 softdep_error("handle_workitem_remove: truncate", error);
2841 /*
2842 * Rename a directory to a new parent. Since, we are both deleting
2843 * and creating a new directory entry, the link count on the new
2844 * directory should not change. Thus we skip the followup dirrem.
2845 */
2846 if (dirrem->dm_state & DIRCHG) {
2847 vput(vp);
2848 num_dirrem -= 1;
2849 WORKITEM_FREE(dirrem, D_DIRREM);
2850 return;
2851 }
2852 /*
2853 * If the inodedep does not exist, then the zero'ed inode has
2854 * been written to disk. If the allocated inode has never been
2855 * written to disk, then the on-disk inode is zero'ed. In either
2856 * case we can remove the file immediately.
2857 */
2858 ACQUIRE_LOCK(&lk);
2859 dirrem->dm_state = 0;
2860 oldinum = dirrem->dm_oldinum;
2861 dirrem->dm_oldinum = dirrem->dm_dirinum;
2862 if (inodedep_lookup(ip->i_fs, oldinum, 0, &inodedep) == 0 ||
2863 check_inode_unwritten(inodedep)) {
2864 FREE_LOCK(&lk);
2865 vput(vp);
2866 handle_workitem_remove(dirrem);
2867 return;
2868 }
2869 WORKLIST_INSERT(&inodedep->id_inowait, &dirrem->dm_list);
2870 FREE_LOCK(&lk);
2871 vput(vp);
2872}
2873
2874/*
2875 * Inode de-allocation dependencies.
2876 *
2877 * When an inode's link count is reduced to zero, it can be de-allocated. We
2878 * found it convenient to postpone de-allocation until after the inode is
2879 * written to disk with its new link count (zero). At this point, all of the
2880 * on-disk inode's block pointers are nullified and, with careful dependency
2881 * list ordering, all dependencies related to the inode will be satisfied and
2882 * the corresponding dependency structures de-allocated. So, if/when the
2883 * inode is reused, there will be no mixing of old dependencies with new
2884 * ones. This artificial dependency is set up by the block de-allocation
2885 * procedure above (softdep_setup_freeblocks) and completed by the
2886 * following procedure.
2887 */
2888static void
2889handle_workitem_freefile(freefile)
2890 struct freefile *freefile;
2891{
2892 struct fs *fs;
2893 struct inode tip;
2894 struct inodedep *idp;
2895 int error;
2896
2897 fs = VFSTOUFS(freefile->fx_mnt)->um_fs;
2898#ifdef DEBUG
2899 ACQUIRE_LOCK(&lk);
2900 error = inodedep_lookup(fs, freefile->fx_oldinum, 0, &idp);
2901 FREE_LOCK(&lk);
2902 if (error)
2903 panic("handle_workitem_freefile: inodedep survived");
2904#endif
2905 tip.i_devvp = freefile->fx_devvp;
2906 tip.i_dev = freefile->fx_devvp->v_rdev;
2907 tip.i_fs = fs;
| 2837 * This workitem decrements the inode's link count.
2838 * If the link count reaches zero, the file is removed.
2839 */
2840static void
2841handle_workitem_remove(dirrem)
2842 struct dirrem *dirrem;
2843{
2844 struct proc *p = CURPROC; /* XXX */
2845 struct inodedep *inodedep;
2846 struct vnode *vp;
2847 struct inode *ip;
2848 ino_t oldinum;
2849 int error;
2850
2851 if ((error = VFS_VGET(dirrem->dm_mnt, dirrem->dm_oldinum, &vp)) != 0) {
2852 softdep_error("handle_workitem_remove: vget", error);
2853 return;
2854 }
2855 ip = VTOI(vp);
2856 ACQUIRE_LOCK(&lk);
2857 if ((inodedep_lookup(ip->i_fs, dirrem->dm_oldinum, 0, &inodedep)) == 0){
2858 FREE_LOCK(&lk);
2859 panic("handle_workitem_remove: lost inodedep");
2860 }
2861 /*
2862 * Normal file deletion.
2863 */
2864 if ((dirrem->dm_state & RMDIR) == 0) {
2865 ip->i_nlink--;
2866 ip->i_flag |= IN_CHANGE;
2867 if (ip->i_nlink < ip->i_effnlink) {
2868 FREE_LOCK(&lk);
2869 panic("handle_workitem_remove: bad file delta");
2870 }
2871 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2872 FREE_LOCK(&lk);
2873 vput(vp);
2874 num_dirrem -= 1;
2875 WORKITEM_FREE(dirrem, D_DIRREM);
2876 return;
2877 }
2878 /*
2879 * Directory deletion. Decrement reference count for both the
2880 * just deleted parent directory entry and the reference for ".".
2881 * Next truncate the directory to length zero. When the
2882 * truncation completes, arrange to have the reference count on
2883 * the parent decremented to account for the loss of "..".
2884 */
2885 ip->i_nlink -= 2;
2886 ip->i_flag |= IN_CHANGE;
2887 if (ip->i_nlink < ip->i_effnlink) {
2888 FREE_LOCK(&lk);
2889 panic("handle_workitem_remove: bad dir delta");
2890 }
2891 inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink;
2892 FREE_LOCK(&lk);
2893 if ((error = UFS_TRUNCATE(vp, (off_t)0, 0, p->p_ucred, p)) != 0)
2894 softdep_error("handle_workitem_remove: truncate", error);
2895 /*
2896 * Rename a directory to a new parent. Since, we are both deleting
2897 * and creating a new directory entry, the link count on the new
2898 * directory should not change. Thus we skip the followup dirrem.
2899 */
2900 if (dirrem->dm_state & DIRCHG) {
2901 vput(vp);
2902 num_dirrem -= 1;
2903 WORKITEM_FREE(dirrem, D_DIRREM);
2904 return;
2905 }
2906 /*
2907 * If the inodedep does not exist, then the zero'ed inode has
2908 * been written to disk. If the allocated inode has never been
2909 * written to disk, then the on-disk inode is zero'ed. In either
2910 * case we can remove the file immediately.
2911 */
2912 ACQUIRE_LOCK(&lk);
2913 dirrem->dm_state = 0;
2914 oldinum = dirrem->dm_oldinum;
2915 dirrem->dm_oldinum = dirrem->dm_dirinum;
2916 if (inodedep_lookup(ip->i_fs, oldinum, 0, &inodedep) == 0 ||
2917 check_inode_unwritten(inodedep)) {
2918 FREE_LOCK(&lk);
2919 vput(vp);
2920 handle_workitem_remove(dirrem);
2921 return;
2922 }
2923 WORKLIST_INSERT(&inodedep->id_inowait, &dirrem->dm_list);
2924 FREE_LOCK(&lk);
2925 vput(vp);
2926}
2927
2928/*
2929 * Inode de-allocation dependencies.
2930 *
2931 * When an inode's link count is reduced to zero, it can be de-allocated. We
2932 * found it convenient to postpone de-allocation until after the inode is
2933 * written to disk with its new link count (zero). At this point, all of the
2934 * on-disk inode's block pointers are nullified and, with careful dependency
2935 * list ordering, all dependencies related to the inode will be satisfied and
2936 * the corresponding dependency structures de-allocated. So, if/when the
2937 * inode is reused, there will be no mixing of old dependencies with new
2938 * ones. This artificial dependency is set up by the block de-allocation
2939 * procedure above (softdep_setup_freeblocks) and completed by the
2940 * following procedure.
2941 */
2942static void
2943handle_workitem_freefile(freefile)
2944 struct freefile *freefile;
2945{
2946 struct fs *fs;
2947 struct inode tip;
2948 struct inodedep *idp;
2949 int error;
2950
2951 fs = VFSTOUFS(freefile->fx_mnt)->um_fs;
2952#ifdef DEBUG
2953 ACQUIRE_LOCK(&lk);
2954 error = inodedep_lookup(fs, freefile->fx_oldinum, 0, &idp);
2955 FREE_LOCK(&lk);
2956 if (error)
2957 panic("handle_workitem_freefile: inodedep survived");
2958#endif
2959 tip.i_devvp = freefile->fx_devvp;
2960 tip.i_dev = freefile->fx_devvp->v_rdev;
2961 tip.i_fs = fs;
|
| 2962 fs->fs_pendinginodes -= 1;
|
2908 if ((error = ffs_freefile(&tip, freefile->fx_oldinum, freefile->fx_mode)) != 0)
2909 softdep_error("handle_workitem_freefile", error);
2910 WORKITEM_FREE(freefile, D_FREEFILE);
2911}
2912
2913/*
2914 * Disk writes.
2915 *
2916 * The dependency structures constructed above are most actively used when file
2917 * system blocks are written to disk. No constraints are placed on when a
2918 * block can be written, but unsatisfied update dependencies are made safe by
2919 * modifying (or replacing) the source memory for the duration of the disk
2920 * write. When the disk write completes, the memory block is again brought
2921 * up-to-date.
2922 *
2923 * In-core inode structure reclamation.
2924 *
2925 * Because there are a finite number of "in-core" inode structures, they are
2926 * reused regularly. By transferring all inode-related dependencies to the
2927 * in-memory inode block and indexing them separately (via "inodedep"s), we
2928 * can allow "in-core" inode structures to be reused at any time and avoid
2929 * any increase in contention.
2930 *
2931 * Called just before entering the device driver to initiate a new disk I/O.
2932 * The buffer must be locked, thus, no I/O completion operations can occur
2933 * while we are manipulating its associated dependencies.
2934 */
2935static void
2936softdep_disk_io_initiation(bp)
2937 struct buf *bp; /* structure describing disk write to occur */
2938{
2939 struct worklist *wk, *nextwk;
2940 struct indirdep *indirdep;
2941
2942 /*
2943 * We only care about write operations. There should never
2944 * be dependencies for reads.
2945 */
2946 if (bp->b_iocmd == BIO_READ)
2947 panic("softdep_disk_io_initiation: read");
2948 /*
2949 * Do any necessary pre-I/O processing.
2950 */
2951 for (wk = LIST_FIRST(&bp->b_dep); wk; wk = nextwk) {
2952 nextwk = LIST_NEXT(wk, wk_list);
2953 switch (wk->wk_type) {
2954
2955 case D_PAGEDEP:
2956 initiate_write_filepage(WK_PAGEDEP(wk), bp);
2957 continue;
2958
2959 case D_INODEDEP:
2960 initiate_write_inodeblock(WK_INODEDEP(wk), bp);
2961 continue;
2962
2963 case D_INDIRDEP:
2964 indirdep = WK_INDIRDEP(wk);
2965 if (indirdep->ir_state & GOINGAWAY)
2966 panic("disk_io_initiation: indirdep gone");
2967 /*
2968 * If there are no remaining dependencies, this
2969 * will be writing the real pointers, so the
2970 * dependency can be freed.
2971 */
2972 if (LIST_FIRST(&indirdep->ir_deplisthd) == NULL) {
2973 indirdep->ir_savebp->b_flags |= B_INVAL | B_NOCACHE;
2974 brelse(indirdep->ir_savebp);
2975 /* inline expand WORKLIST_REMOVE(wk); */
2976 wk->wk_state &= ~ONWORKLIST;
2977 LIST_REMOVE(wk, wk_list);
2978 WORKITEM_FREE(indirdep, D_INDIRDEP);
2979 continue;
2980 }
2981 /*
2982 * Replace up-to-date version with safe version.
2983 */
2984 MALLOC(indirdep->ir_saveddata, caddr_t, bp->b_bcount,
2985 M_INDIRDEP, M_SOFTDEP_FLAGS);
2986 ACQUIRE_LOCK(&lk);
2987 indirdep->ir_state &= ~ATTACHED;
2988 indirdep->ir_state |= UNDONE;
2989 bcopy(bp->b_data, indirdep->ir_saveddata, bp->b_bcount);
2990 bcopy(indirdep->ir_savebp->b_data, bp->b_data,
2991 bp->b_bcount);
2992 FREE_LOCK(&lk);
2993 continue;
2994
2995 case D_MKDIR:
2996 case D_BMSAFEMAP:
2997 case D_ALLOCDIRECT:
2998 case D_ALLOCINDIR:
2999 continue;
3000
3001 default:
3002 panic("handle_disk_io_initiation: Unexpected type %s",
3003 TYPENAME(wk->wk_type));
3004 /* NOTREACHED */
3005 }
3006 }
3007}
3008
3009/*
3010 * Called from within the procedure above to deal with unsatisfied
3011 * allocation dependencies in a directory. The buffer must be locked,
3012 * thus, no I/O completion operations can occur while we are
3013 * manipulating its associated dependencies.
3014 */
3015static void
3016initiate_write_filepage(pagedep, bp)
3017 struct pagedep *pagedep;
3018 struct buf *bp;
3019{
3020 struct diradd *dap;
3021 struct direct *ep;
3022 int i;
3023
3024 if (pagedep->pd_state & IOSTARTED) {
3025 /*
3026 * This can only happen if there is a driver that does not
3027 * understand chaining. Here biodone will reissue the call
3028 * to strategy for the incomplete buffers.
3029 */
3030 printf("initiate_write_filepage: already started\n");
3031 return;
3032 }
3033 pagedep->pd_state |= IOSTARTED;
3034 ACQUIRE_LOCK(&lk);
3035 for (i = 0; i < DAHASHSZ; i++) {
3036 LIST_FOREACH(dap, &pagedep->pd_diraddhd[i], da_pdlist) {
3037 ep = (struct direct *)
3038 ((char *)bp->b_data + dap->da_offset);
3039 if (ep->d_ino != dap->da_newinum) {
3040 FREE_LOCK(&lk);
3041 panic("%s: dir inum %d != new %d",
3042 "initiate_write_filepage",
3043 ep->d_ino, dap->da_newinum);
3044 }
3045 if (dap->da_state & DIRCHG)
3046 ep->d_ino = dap->da_previous->dm_oldinum;
3047 else
3048 ep->d_ino = 0;
3049 dap->da_state &= ~ATTACHED;
3050 dap->da_state |= UNDONE;
3051 }
3052 }
3053 FREE_LOCK(&lk);
3054}
3055
3056/*
3057 * Called from within the procedure above to deal with unsatisfied
3058 * allocation dependencies in an inodeblock. The buffer must be
3059 * locked, thus, no I/O completion operations can occur while we
3060 * are manipulating its associated dependencies.
3061 */
3062static void
3063initiate_write_inodeblock(inodedep, bp)
3064 struct inodedep *inodedep;
3065 struct buf *bp; /* The inode block */
3066{
3067 struct allocdirect *adp, *lastadp;
3068 struct dinode *dp;
3069 struct fs *fs;
3070 ufs_lbn_t prevlbn = 0;
3071 int i, deplist;
3072
3073 if (inodedep->id_state & IOSTARTED)
3074 panic("initiate_write_inodeblock: already started");
3075 inodedep->id_state |= IOSTARTED;
3076 fs = inodedep->id_fs;
3077 dp = (struct dinode *)bp->b_data +
3078 ino_to_fsbo(fs, inodedep->id_ino);
3079 /*
3080 * If the bitmap is not yet written, then the allocated
3081 * inode cannot be written to disk.
3082 */
3083 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
3084 if (inodedep->id_savedino != NULL)
3085 panic("initiate_write_inodeblock: already doing I/O");
3086 MALLOC(inodedep->id_savedino, struct dinode *,
3087 sizeof(struct dinode), M_INODEDEP, M_SOFTDEP_FLAGS);
3088 *inodedep->id_savedino = *dp;
3089 bzero((caddr_t)dp, sizeof(struct dinode));
3090 return;
3091 }
3092 /*
3093 * If no dependencies, then there is nothing to roll back.
3094 */
3095 inodedep->id_savedsize = dp->di_size;
3096 if (TAILQ_FIRST(&inodedep->id_inoupdt) == NULL)
3097 return;
3098 /*
3099 * Set the dependencies to busy.
3100 */
3101 ACQUIRE_LOCK(&lk);
3102 for (deplist = 0, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
3103 adp = TAILQ_NEXT(adp, ad_next)) {
3104#ifdef DIAGNOSTIC
3105 if (deplist != 0 && prevlbn >= adp->ad_lbn) {
3106 FREE_LOCK(&lk);
3107 panic("softdep_write_inodeblock: lbn order");
3108 }
3109 prevlbn = adp->ad_lbn;
3110 if (adp->ad_lbn < NDADDR &&
3111 dp->di_db[adp->ad_lbn] != adp->ad_newblkno) {
3112 FREE_LOCK(&lk);
3113 panic("%s: direct pointer #%ld mismatch %d != %d",
3114 "softdep_write_inodeblock", adp->ad_lbn,
3115 dp->di_db[adp->ad_lbn], adp->ad_newblkno);
3116 }
3117 if (adp->ad_lbn >= NDADDR &&
3118 dp->di_ib[adp->ad_lbn - NDADDR] != adp->ad_newblkno) {
3119 FREE_LOCK(&lk);
3120 panic("%s: indirect pointer #%ld mismatch %d != %d",
3121 "softdep_write_inodeblock", adp->ad_lbn - NDADDR,
3122 dp->di_ib[adp->ad_lbn - NDADDR], adp->ad_newblkno);
3123 }
3124 deplist |= 1 << adp->ad_lbn;
3125 if ((adp->ad_state & ATTACHED) == 0) {
3126 FREE_LOCK(&lk);
3127 panic("softdep_write_inodeblock: Unknown state 0x%x",
3128 adp->ad_state);
3129 }
3130#endif /* DIAGNOSTIC */
3131 adp->ad_state &= ~ATTACHED;
3132 adp->ad_state |= UNDONE;
3133 }
3134 /*
3135 * The on-disk inode cannot claim to be any larger than the last
3136 * fragment that has been written. Otherwise, the on-disk inode
3137 * might have fragments that were not the last block in the file
3138 * which would corrupt the filesystem.
3139 */
3140 for (lastadp = NULL, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
3141 lastadp = adp, adp = TAILQ_NEXT(adp, ad_next)) {
3142 if (adp->ad_lbn >= NDADDR)
3143 break;
3144 dp->di_db[adp->ad_lbn] = adp->ad_oldblkno;
3145 /* keep going until hitting a rollback to a frag */
3146 if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)
3147 continue;
3148 dp->di_size = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;
3149 for (i = adp->ad_lbn + 1; i < NDADDR; i++) {
3150#ifdef DIAGNOSTIC
3151 if (dp->di_db[i] != 0 && (deplist & (1 << i)) == 0) {
3152 FREE_LOCK(&lk);
3153 panic("softdep_write_inodeblock: lost dep1");
3154 }
3155#endif /* DIAGNOSTIC */
3156 dp->di_db[i] = 0;
3157 }
3158 for (i = 0; i < NIADDR; i++) {
3159#ifdef DIAGNOSTIC
3160 if (dp->di_ib[i] != 0 &&
3161 (deplist & ((1 << NDADDR) << i)) == 0) {
3162 FREE_LOCK(&lk);
3163 panic("softdep_write_inodeblock: lost dep2");
3164 }
3165#endif /* DIAGNOSTIC */
3166 dp->di_ib[i] = 0;
3167 }
3168 FREE_LOCK(&lk);
3169 return;
3170 }
3171 /*
3172 * If we have zero'ed out the last allocated block of the file,
3173 * roll back the size to the last currently allocated block.
3174 * We know that this last allocated block is a full-sized as
3175 * we already checked for fragments in the loop above.
3176 */
3177 if (lastadp != NULL &&
3178 dp->di_size <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {
3179 for (i = lastadp->ad_lbn; i >= 0; i--)
3180 if (dp->di_db[i] != 0)
3181 break;
3182 dp->di_size = (i + 1) * fs->fs_bsize;
3183 }
3184 /*
3185 * The only dependencies are for indirect blocks.
3186 *
3187 * The file size for indirect block additions is not guaranteed.
3188 * Such a guarantee would be non-trivial to achieve. The conventional
3189 * synchronous write implementation also does not make this guarantee.
3190 * Fsck should catch and fix discrepancies. Arguably, the file size
3191 * can be over-estimated without destroying integrity when the file
3192 * moves into the indirect blocks (i.e., is large). If we want to
3193 * postpone fsck, we are stuck with this argument.
3194 */
3195 for (; adp; adp = TAILQ_NEXT(adp, ad_next))
3196 dp->di_ib[adp->ad_lbn - NDADDR] = 0;
3197 FREE_LOCK(&lk);
3198}
3199
3200/*
3201 * This routine is called during the completion interrupt
3202 * service routine for a disk write (from the procedure called
3203 * by the device driver to inform the file system caches of
3204 * a request completion). It should be called early in this
3205 * procedure, before the block is made available to other
3206 * processes or other routines are called.
3207 */
3208static void
3209softdep_disk_write_complete(bp)
3210 struct buf *bp; /* describes the completed disk write */
3211{
3212 struct worklist *wk;
3213 struct workhead reattach;
3214 struct newblk *newblk;
3215 struct allocindir *aip;
3216 struct allocdirect *adp;
3217 struct indirdep *indirdep;
3218 struct inodedep *inodedep;
3219 struct bmsafemap *bmsafemap;
3220
3221#ifdef DEBUG
3222 if (lk.lkt_held != -1)
3223 panic("softdep_disk_write_complete: lock is held");
3224 lk.lkt_held = -2;
3225#endif
3226 LIST_INIT(&reattach);
3227 while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
3228 WORKLIST_REMOVE(wk);
3229 switch (wk->wk_type) {
3230
3231 case D_PAGEDEP:
3232 if (handle_written_filepage(WK_PAGEDEP(wk), bp))
3233 WORKLIST_INSERT(&reattach, wk);
3234 continue;
3235
3236 case D_INODEDEP:
3237 if (handle_written_inodeblock(WK_INODEDEP(wk), bp))
3238 WORKLIST_INSERT(&reattach, wk);
3239 continue;
3240
3241 case D_BMSAFEMAP:
3242 bmsafemap = WK_BMSAFEMAP(wk);
3243 while ((newblk = LIST_FIRST(&bmsafemap->sm_newblkhd))) {
3244 newblk->nb_state |= DEPCOMPLETE;
3245 newblk->nb_bmsafemap = NULL;
3246 LIST_REMOVE(newblk, nb_deps);
3247 }
3248 while ((adp =
3249 LIST_FIRST(&bmsafemap->sm_allocdirecthd))) {
3250 adp->ad_state |= DEPCOMPLETE;
3251 adp->ad_buf = NULL;
3252 LIST_REMOVE(adp, ad_deps);
3253 handle_allocdirect_partdone(adp);
3254 }
3255 while ((aip =
3256 LIST_FIRST(&bmsafemap->sm_allocindirhd))) {
3257 aip->ai_state |= DEPCOMPLETE;
3258 aip->ai_buf = NULL;
3259 LIST_REMOVE(aip, ai_deps);
3260 handle_allocindir_partdone(aip);
3261 }
3262 while ((inodedep =
3263 LIST_FIRST(&bmsafemap->sm_inodedephd)) != NULL) {
3264 inodedep->id_state |= DEPCOMPLETE;
3265 LIST_REMOVE(inodedep, id_deps);
3266 inodedep->id_buf = NULL;
3267 }
3268 WORKITEM_FREE(bmsafemap, D_BMSAFEMAP);
3269 continue;
3270
3271 case D_MKDIR:
3272 handle_written_mkdir(WK_MKDIR(wk), MKDIR_BODY);
3273 continue;
3274
3275 case D_ALLOCDIRECT:
3276 adp = WK_ALLOCDIRECT(wk);
3277 adp->ad_state |= COMPLETE;
3278 handle_allocdirect_partdone(adp);
3279 continue;
3280
3281 case D_ALLOCINDIR:
3282 aip = WK_ALLOCINDIR(wk);
3283 aip->ai_state |= COMPLETE;
3284 handle_allocindir_partdone(aip);
3285 continue;
3286
3287 case D_INDIRDEP:
3288 indirdep = WK_INDIRDEP(wk);
3289 if (indirdep->ir_state & GOINGAWAY) {
3290 lk.lkt_held = -1;
3291 panic("disk_write_complete: indirdep gone");
3292 }
3293 bcopy(indirdep->ir_saveddata, bp->b_data, bp->b_bcount);
3294 FREE(indirdep->ir_saveddata, M_INDIRDEP);
3295 indirdep->ir_saveddata = 0;
3296 indirdep->ir_state &= ~UNDONE;
3297 indirdep->ir_state |= ATTACHED;
3298 while ((aip = LIST_FIRST(&indirdep->ir_donehd)) != 0) {
3299 handle_allocindir_partdone(aip);
3300 if (aip == LIST_FIRST(&indirdep->ir_donehd)) {
3301 lk.lkt_held = -1;
3302 panic("disk_write_complete: not gone");
3303 }
3304 }
3305 WORKLIST_INSERT(&reattach, wk);
3306 if ((bp->b_flags & B_DELWRI) == 0)
3307 stat_indir_blk_ptrs++;
3308 bdirty(bp);
3309 continue;
3310
3311 default:
3312 lk.lkt_held = -1;
3313 panic("handle_disk_write_complete: Unknown type %s",
3314 TYPENAME(wk->wk_type));
3315 /* NOTREACHED */
3316 }
3317 }
3318 /*
3319 * Reattach any requests that must be redone.
3320 */
3321 while ((wk = LIST_FIRST(&reattach)) != NULL) {
3322 WORKLIST_REMOVE(wk);
3323 WORKLIST_INSERT(&bp->b_dep, wk);
3324 }
3325#ifdef DEBUG
3326 if (lk.lkt_held != -2)
3327 panic("softdep_disk_write_complete: lock lost");
3328 lk.lkt_held = -1;
3329#endif
3330}
3331
3332/*
3333 * Called from within softdep_disk_write_complete above. Note that
3334 * this routine is always called from interrupt level with further
3335 * splbio interrupts blocked.
3336 */
3337static void
3338handle_allocdirect_partdone(adp)
3339 struct allocdirect *adp; /* the completed allocdirect */
3340{
3341 struct allocdirect *listadp;
3342 struct inodedep *inodedep;
3343 long bsize, delay;
3344
3345 if ((adp->ad_state & ALLCOMPLETE) != ALLCOMPLETE)
3346 return;
3347 if (adp->ad_buf != NULL) {
3348 lk.lkt_held = -1;
3349 panic("handle_allocdirect_partdone: dangling dep");
3350 }
3351 /*
3352 * The on-disk inode cannot claim to be any larger than the last
3353 * fragment that has been written. Otherwise, the on-disk inode
3354 * might have fragments that were not the last block in the file
3355 * which would corrupt the filesystem. Thus, we cannot free any
3356 * allocdirects after one whose ad_oldblkno claims a fragment as
3357 * these blocks must be rolled back to zero before writing the inode.
3358 * We check the currently active set of allocdirects in id_inoupdt.
3359 */
3360 inodedep = adp->ad_inodedep;
3361 bsize = inodedep->id_fs->fs_bsize;
3362 TAILQ_FOREACH(listadp, &inodedep->id_inoupdt, ad_next) {
3363 /* found our block */
3364 if (listadp == adp)
3365 break;
3366 /* continue if ad_oldlbn is not a fragment */
3367 if (listadp->ad_oldsize == 0 ||
3368 listadp->ad_oldsize == bsize)
3369 continue;
3370 /* hit a fragment */
3371 return;
3372 }
3373 /*
3374 * If we have reached the end of the current list without
3375 * finding the just finished dependency, then it must be
3376 * on the future dependency list. Future dependencies cannot
3377 * be freed until they are moved to the current list.
3378 */
3379 if (listadp == NULL) {
3380#ifdef DEBUG
3381 TAILQ_FOREACH(listadp, &inodedep->id_newinoupdt, ad_next)
3382 /* found our block */
3383 if (listadp == adp)
3384 break;
3385 if (listadp == NULL) {
3386 lk.lkt_held = -1;
3387 panic("handle_allocdirect_partdone: lost dep");
3388 }
3389#endif /* DEBUG */
3390 return;
3391 }
3392 /*
3393 * If we have found the just finished dependency, then free
3394 * it along with anything that follows it that is complete.
3395 * If the inode still has a bitmap dependency, then it has
3396 * never been written to disk, hence the on-disk inode cannot
3397 * reference the old fragment so we can free it without delay.
3398 */
3399 delay = (inodedep->id_state & DEPCOMPLETE);
3400 for (; adp; adp = listadp) {
3401 listadp = TAILQ_NEXT(adp, ad_next);
3402 if ((adp->ad_state & ALLCOMPLETE) != ALLCOMPLETE)
3403 return;
3404 free_allocdirect(&inodedep->id_inoupdt, adp, delay);
3405 }
3406}
3407
3408/*
3409 * Called from within softdep_disk_write_complete above. Note that
3410 * this routine is always called from interrupt level with further
3411 * splbio interrupts blocked.
3412 */
3413static void
3414handle_allocindir_partdone(aip)
3415 struct allocindir *aip; /* the completed allocindir */
3416{
3417 struct indirdep *indirdep;
3418
3419 if ((aip->ai_state & ALLCOMPLETE) != ALLCOMPLETE)
3420 return;
3421 if (aip->ai_buf != NULL) {
3422 lk.lkt_held = -1;
3423 panic("handle_allocindir_partdone: dangling dependency");
3424 }
3425 indirdep = aip->ai_indirdep;
3426 if (indirdep->ir_state & UNDONE) {
3427 LIST_REMOVE(aip, ai_next);
3428 LIST_INSERT_HEAD(&indirdep->ir_donehd, aip, ai_next);
3429 return;
3430 }
3431 ((ufs_daddr_t *)indirdep->ir_savebp->b_data)[aip->ai_offset] =
3432 aip->ai_newblkno;
3433 LIST_REMOVE(aip, ai_next);
3434 if (aip->ai_freefrag != NULL)
3435 add_to_worklist(&aip->ai_freefrag->ff_list);
3436 WORKITEM_FREE(aip, D_ALLOCINDIR);
3437}
3438
3439/*
3440 * Called from within softdep_disk_write_complete above to restore
3441 * in-memory inode block contents to their most up-to-date state. Note
3442 * that this routine is always called from interrupt level with further
3443 * splbio interrupts blocked.
3444 */
3445static int
3446handle_written_inodeblock(inodedep, bp)
3447 struct inodedep *inodedep;
3448 struct buf *bp; /* buffer containing the inode block */
3449{
3450 struct worklist *wk, *filefree;
3451 struct allocdirect *adp, *nextadp;
3452 struct dinode *dp;
3453 int hadchanges;
3454
3455 if ((inodedep->id_state & IOSTARTED) == 0) {
3456 lk.lkt_held = -1;
3457 panic("handle_written_inodeblock: not started");
3458 }
3459 inodedep->id_state &= ~IOSTARTED;
3460 inodedep->id_state |= COMPLETE;
3461 dp = (struct dinode *)bp->b_data +
3462 ino_to_fsbo(inodedep->id_fs, inodedep->id_ino);
3463 /*
3464 * If we had to rollback the inode allocation because of
3465 * bitmaps being incomplete, then simply restore it.
3466 * Keep the block dirty so that it will not be reclaimed until
3467 * all associated dependencies have been cleared and the
3468 * corresponding updates written to disk.
3469 */
3470 if (inodedep->id_savedino != NULL) {
3471 *dp = *inodedep->id_savedino;
3472 FREE(inodedep->id_savedino, M_INODEDEP);
3473 inodedep->id_savedino = NULL;
3474 if ((bp->b_flags & B_DELWRI) == 0)
3475 stat_inode_bitmap++;
3476 bdirty(bp);
3477 return (1);
3478 }
3479 /*
3480 * Roll forward anything that had to be rolled back before
3481 * the inode could be updated.
3482 */
3483 hadchanges = 0;
3484 for (adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp; adp = nextadp) {
3485 nextadp = TAILQ_NEXT(adp, ad_next);
3486 if (adp->ad_state & ATTACHED) {
3487 lk.lkt_held = -1;
3488 panic("handle_written_inodeblock: new entry");
3489 }
3490 if (adp->ad_lbn < NDADDR) {
3491 if (dp->di_db[adp->ad_lbn] != adp->ad_oldblkno) {
3492 lk.lkt_held = -1;
3493 panic("%s: %s #%ld mismatch %d != %d",
3494 "handle_written_inodeblock",
3495 "direct pointer", adp->ad_lbn,
3496 dp->di_db[adp->ad_lbn], adp->ad_oldblkno);
3497 }
3498 dp->di_db[adp->ad_lbn] = adp->ad_newblkno;
3499 } else {
3500 if (dp->di_ib[adp->ad_lbn - NDADDR] != 0) {
3501 lk.lkt_held = -1;
3502 panic("%s: %s #%ld allocated as %d",
3503 "handle_written_inodeblock",
3504 "indirect pointer", adp->ad_lbn - NDADDR,
3505 dp->di_ib[adp->ad_lbn - NDADDR]);
3506 }
3507 dp->di_ib[adp->ad_lbn - NDADDR] = adp->ad_newblkno;
3508 }
3509 adp->ad_state &= ~UNDONE;
3510 adp->ad_state |= ATTACHED;
3511 hadchanges = 1;
3512 }
3513 if (hadchanges && (bp->b_flags & B_DELWRI) == 0)
3514 stat_direct_blk_ptrs++;
3515 /*
3516 * Reset the file size to its most up-to-date value.
3517 */
3518 if (inodedep->id_savedsize == -1) {
3519 lk.lkt_held = -1;
3520 panic("handle_written_inodeblock: bad size");
3521 }
3522 if (dp->di_size != inodedep->id_savedsize) {
3523 dp->di_size = inodedep->id_savedsize;
3524 hadchanges = 1;
3525 }
3526 inodedep->id_savedsize = -1;
3527 /*
3528 * If there were any rollbacks in the inode block, then it must be
3529 * marked dirty so that its will eventually get written back in
3530 * its correct form.
3531 */
3532 if (hadchanges)
3533 bdirty(bp);
3534 /*
3535 * Process any allocdirects that completed during the update.
3536 */
3537 if ((adp = TAILQ_FIRST(&inodedep->id_inoupdt)) != NULL)
3538 handle_allocdirect_partdone(adp);
3539 /*
3540 * Process deallocations that were held pending until the
3541 * inode had been written to disk. Freeing of the inode
3542 * is delayed until after all blocks have been freed to
3543 * avoid creation of new <vfsid, inum, lbn> triples
3544 * before the old ones have been deleted.
3545 */
3546 filefree = NULL;
3547 while ((wk = LIST_FIRST(&inodedep->id_bufwait)) != NULL) {
3548 WORKLIST_REMOVE(wk);
3549 switch (wk->wk_type) {
3550
3551 case D_FREEFILE:
3552 /*
3553 * We defer adding filefree to the worklist until
3554 * all other additions have been made to ensure
3555 * that it will be done after all the old blocks
3556 * have been freed.
3557 */
3558 if (filefree != NULL) {
3559 lk.lkt_held = -1;
3560 panic("handle_written_inodeblock: filefree");
3561 }
3562 filefree = wk;
3563 continue;
3564
3565 case D_MKDIR:
3566 handle_written_mkdir(WK_MKDIR(wk), MKDIR_PARENT);
3567 continue;
3568
3569 case D_DIRADD:
3570 diradd_inode_written(WK_DIRADD(wk), inodedep);
3571 continue;
3572
3573 case D_FREEBLKS:
3574 case D_FREEFRAG:
3575 case D_DIRREM:
3576 add_to_worklist(wk);
3577 continue;
3578
3579 default:
3580 lk.lkt_held = -1;
3581 panic("handle_written_inodeblock: Unknown type %s",
3582 TYPENAME(wk->wk_type));
3583 /* NOTREACHED */
3584 }
3585 }
3586 if (filefree != NULL) {
3587 if (free_inodedep(inodedep) == 0) {
3588 lk.lkt_held = -1;
3589 panic("handle_written_inodeblock: live inodedep");
3590 }
3591 add_to_worklist(filefree);
3592 return (0);
3593 }
3594
3595 /*
3596 * If no outstanding dependencies, free it.
3597 */
3598 if (free_inodedep(inodedep) || TAILQ_FIRST(&inodedep->id_inoupdt) == 0)
3599 return (0);
3600 return (hadchanges);
3601}
3602
3603/*
3604 * Process a diradd entry after its dependent inode has been written.
3605 * This routine must be called with splbio interrupts blocked.
3606 */
3607static void
3608diradd_inode_written(dap, inodedep)
3609 struct diradd *dap;
3610 struct inodedep *inodedep;
3611{
3612 struct pagedep *pagedep;
3613
3614 dap->da_state |= COMPLETE;
3615 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3616 if (dap->da_state & DIRCHG)
3617 pagedep = dap->da_previous->dm_pagedep;
3618 else
3619 pagedep = dap->da_pagedep;
3620 LIST_REMOVE(dap, da_pdlist);
3621 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
3622 }
3623 WORKLIST_INSERT(&inodedep->id_pendinghd, &dap->da_list);
3624}
3625
3626/*
3627 * Handle the completion of a mkdir dependency.
3628 */
3629static void
3630handle_written_mkdir(mkdir, type)
3631 struct mkdir *mkdir;
3632 int type;
3633{
3634 struct diradd *dap;
3635 struct pagedep *pagedep;
3636
3637 if (mkdir->md_state != type) {
3638 lk.lkt_held = -1;
3639 panic("handle_written_mkdir: bad type");
3640 }
3641 dap = mkdir->md_diradd;
3642 dap->da_state &= ~type;
3643 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) == 0)
3644 dap->da_state |= DEPCOMPLETE;
3645 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3646 if (dap->da_state & DIRCHG)
3647 pagedep = dap->da_previous->dm_pagedep;
3648 else
3649 pagedep = dap->da_pagedep;
3650 LIST_REMOVE(dap, da_pdlist);
3651 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
3652 }
3653 LIST_REMOVE(mkdir, md_mkdirs);
3654 WORKITEM_FREE(mkdir, D_MKDIR);
3655}
3656
3657/*
3658 * Called from within softdep_disk_write_complete above.
3659 * A write operation was just completed. Removed inodes can
3660 * now be freed and associated block pointers may be committed.
3661 * Note that this routine is always called from interrupt level
3662 * with further splbio interrupts blocked.
3663 */
3664static int
3665handle_written_filepage(pagedep, bp)
3666 struct pagedep *pagedep;
3667 struct buf *bp; /* buffer containing the written page */
3668{
3669 struct dirrem *dirrem;
3670 struct diradd *dap, *nextdap;
3671 struct direct *ep;
3672 int i, chgs;
3673
3674 if ((pagedep->pd_state & IOSTARTED) == 0) {
3675 lk.lkt_held = -1;
3676 panic("handle_written_filepage: not started");
3677 }
3678 pagedep->pd_state &= ~IOSTARTED;
3679 /*
3680 * Process any directory removals that have been committed.
3681 */
3682 while ((dirrem = LIST_FIRST(&pagedep->pd_dirremhd)) != NULL) {
3683 LIST_REMOVE(dirrem, dm_next);
3684 dirrem->dm_dirinum = pagedep->pd_ino;
3685 add_to_worklist(&dirrem->dm_list);
3686 }
3687 /*
3688 * Free any directory additions that have been committed.
3689 */
3690 while ((dap = LIST_FIRST(&pagedep->pd_pendinghd)) != NULL)
3691 free_diradd(dap);
3692 /*
3693 * Uncommitted directory entries must be restored.
3694 */
3695 for (chgs = 0, i = 0; i < DAHASHSZ; i++) {
3696 for (dap = LIST_FIRST(&pagedep->pd_diraddhd[i]); dap;
3697 dap = nextdap) {
3698 nextdap = LIST_NEXT(dap, da_pdlist);
3699 if (dap->da_state & ATTACHED) {
3700 lk.lkt_held = -1;
3701 panic("handle_written_filepage: attached");
3702 }
3703 ep = (struct direct *)
3704 ((char *)bp->b_data + dap->da_offset);
3705 ep->d_ino = dap->da_newinum;
3706 dap->da_state &= ~UNDONE;
3707 dap->da_state |= ATTACHED;
3708 chgs = 1;
3709 /*
3710 * If the inode referenced by the directory has
3711 * been written out, then the dependency can be
3712 * moved to the pending list.
3713 */
3714 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3715 LIST_REMOVE(dap, da_pdlist);
3716 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap,
3717 da_pdlist);
3718 }
3719 }
3720 }
3721 /*
3722 * If there were any rollbacks in the directory, then it must be
3723 * marked dirty so that its will eventually get written back in
3724 * its correct form.
3725 */
3726 if (chgs) {
3727 if ((bp->b_flags & B_DELWRI) == 0)
3728 stat_dir_entry++;
3729 bdirty(bp);
3730 }
3731 /*
3732 * If no dependencies remain, the pagedep will be freed.
3733 * Otherwise it will remain to update the page before it
3734 * is written back to disk.
3735 */
3736 if (LIST_FIRST(&pagedep->pd_pendinghd) == 0) {
3737 for (i = 0; i < DAHASHSZ; i++)
3738 if (LIST_FIRST(&pagedep->pd_diraddhd[i]) != NULL)
3739 break;
3740 if (i == DAHASHSZ) {
3741 LIST_REMOVE(pagedep, pd_hash);
3742 WORKITEM_FREE(pagedep, D_PAGEDEP);
3743 return (0);
3744 }
3745 }
3746 return (1);
3747}
3748
3749/*
3750 * Writing back in-core inode structures.
3751 *
3752 * The file system only accesses an inode's contents when it occupies an
3753 * "in-core" inode structure. These "in-core" structures are separate from
3754 * the page frames used to cache inode blocks. Only the latter are
3755 * transferred to/from the disk. So, when the updated contents of the
3756 * "in-core" inode structure are copied to the corresponding in-memory inode
3757 * block, the dependencies are also transferred. The following procedure is
3758 * called when copying a dirty "in-core" inode to a cached inode block.
3759 */
3760
3761/*
3762 * Called when an inode is loaded from disk. If the effective link count
3763 * differed from the actual link count when it was last flushed, then we
3764 * need to ensure that the correct effective link count is put back.
3765 */
3766void
3767softdep_load_inodeblock(ip)
3768 struct inode *ip; /* the "in_core" copy of the inode */
3769{
3770 struct inodedep *inodedep;
3771
3772 /*
3773 * Check for alternate nlink count.
3774 */
3775 ip->i_effnlink = ip->i_nlink;
3776 ACQUIRE_LOCK(&lk);
3777 if (inodedep_lookup(ip->i_fs, ip->i_number, 0, &inodedep) == 0) {
3778 FREE_LOCK(&lk);
3779 return;
3780 }
3781 ip->i_effnlink -= inodedep->id_nlinkdelta;
| 2963 if ((error = ffs_freefile(&tip, freefile->fx_oldinum, freefile->fx_mode)) != 0)
2964 softdep_error("handle_workitem_freefile", error);
2965 WORKITEM_FREE(freefile, D_FREEFILE);
2966}
2967
2968/*
2969 * Disk writes.
2970 *
2971 * The dependency structures constructed above are most actively used when file
2972 * system blocks are written to disk. No constraints are placed on when a
2973 * block can be written, but unsatisfied update dependencies are made safe by
2974 * modifying (or replacing) the source memory for the duration of the disk
2975 * write. When the disk write completes, the memory block is again brought
2976 * up-to-date.
2977 *
2978 * In-core inode structure reclamation.
2979 *
2980 * Because there are a finite number of "in-core" inode structures, they are
2981 * reused regularly. By transferring all inode-related dependencies to the
2982 * in-memory inode block and indexing them separately (via "inodedep"s), we
2983 * can allow "in-core" inode structures to be reused at any time and avoid
2984 * any increase in contention.
2985 *
2986 * Called just before entering the device driver to initiate a new disk I/O.
2987 * The buffer must be locked, thus, no I/O completion operations can occur
2988 * while we are manipulating its associated dependencies.
2989 */
2990static void
2991softdep_disk_io_initiation(bp)
2992 struct buf *bp; /* structure describing disk write to occur */
2993{
2994 struct worklist *wk, *nextwk;
2995 struct indirdep *indirdep;
2996
2997 /*
2998 * We only care about write operations. There should never
2999 * be dependencies for reads.
3000 */
3001 if (bp->b_iocmd == BIO_READ)
3002 panic("softdep_disk_io_initiation: read");
3003 /*
3004 * Do any necessary pre-I/O processing.
3005 */
3006 for (wk = LIST_FIRST(&bp->b_dep); wk; wk = nextwk) {
3007 nextwk = LIST_NEXT(wk, wk_list);
3008 switch (wk->wk_type) {
3009
3010 case D_PAGEDEP:
3011 initiate_write_filepage(WK_PAGEDEP(wk), bp);
3012 continue;
3013
3014 case D_INODEDEP:
3015 initiate_write_inodeblock(WK_INODEDEP(wk), bp);
3016 continue;
3017
3018 case D_INDIRDEP:
3019 indirdep = WK_INDIRDEP(wk);
3020 if (indirdep->ir_state & GOINGAWAY)
3021 panic("disk_io_initiation: indirdep gone");
3022 /*
3023 * If there are no remaining dependencies, this
3024 * will be writing the real pointers, so the
3025 * dependency can be freed.
3026 */
3027 if (LIST_FIRST(&indirdep->ir_deplisthd) == NULL) {
3028 indirdep->ir_savebp->b_flags |= B_INVAL | B_NOCACHE;
3029 brelse(indirdep->ir_savebp);
3030 /* inline expand WORKLIST_REMOVE(wk); */
3031 wk->wk_state &= ~ONWORKLIST;
3032 LIST_REMOVE(wk, wk_list);
3033 WORKITEM_FREE(indirdep, D_INDIRDEP);
3034 continue;
3035 }
3036 /*
3037 * Replace up-to-date version with safe version.
3038 */
3039 MALLOC(indirdep->ir_saveddata, caddr_t, bp->b_bcount,
3040 M_INDIRDEP, M_SOFTDEP_FLAGS);
3041 ACQUIRE_LOCK(&lk);
3042 indirdep->ir_state &= ~ATTACHED;
3043 indirdep->ir_state |= UNDONE;
3044 bcopy(bp->b_data, indirdep->ir_saveddata, bp->b_bcount);
3045 bcopy(indirdep->ir_savebp->b_data, bp->b_data,
3046 bp->b_bcount);
3047 FREE_LOCK(&lk);
3048 continue;
3049
3050 case D_MKDIR:
3051 case D_BMSAFEMAP:
3052 case D_ALLOCDIRECT:
3053 case D_ALLOCINDIR:
3054 continue;
3055
3056 default:
3057 panic("handle_disk_io_initiation: Unexpected type %s",
3058 TYPENAME(wk->wk_type));
3059 /* NOTREACHED */
3060 }
3061 }
3062}
3063
3064/*
3065 * Called from within the procedure above to deal with unsatisfied
3066 * allocation dependencies in a directory. The buffer must be locked,
3067 * thus, no I/O completion operations can occur while we are
3068 * manipulating its associated dependencies.
3069 */
3070static void
3071initiate_write_filepage(pagedep, bp)
3072 struct pagedep *pagedep;
3073 struct buf *bp;
3074{
3075 struct diradd *dap;
3076 struct direct *ep;
3077 int i;
3078
3079 if (pagedep->pd_state & IOSTARTED) {
3080 /*
3081 * This can only happen if there is a driver that does not
3082 * understand chaining. Here biodone will reissue the call
3083 * to strategy for the incomplete buffers.
3084 */
3085 printf("initiate_write_filepage: already started\n");
3086 return;
3087 }
3088 pagedep->pd_state |= IOSTARTED;
3089 ACQUIRE_LOCK(&lk);
3090 for (i = 0; i < DAHASHSZ; i++) {
3091 LIST_FOREACH(dap, &pagedep->pd_diraddhd[i], da_pdlist) {
3092 ep = (struct direct *)
3093 ((char *)bp->b_data + dap->da_offset);
3094 if (ep->d_ino != dap->da_newinum) {
3095 FREE_LOCK(&lk);
3096 panic("%s: dir inum %d != new %d",
3097 "initiate_write_filepage",
3098 ep->d_ino, dap->da_newinum);
3099 }
3100 if (dap->da_state & DIRCHG)
3101 ep->d_ino = dap->da_previous->dm_oldinum;
3102 else
3103 ep->d_ino = 0;
3104 dap->da_state &= ~ATTACHED;
3105 dap->da_state |= UNDONE;
3106 }
3107 }
3108 FREE_LOCK(&lk);
3109}
3110
3111/*
3112 * Called from within the procedure above to deal with unsatisfied
3113 * allocation dependencies in an inodeblock. The buffer must be
3114 * locked, thus, no I/O completion operations can occur while we
3115 * are manipulating its associated dependencies.
3116 */
3117static void
3118initiate_write_inodeblock(inodedep, bp)
3119 struct inodedep *inodedep;
3120 struct buf *bp; /* The inode block */
3121{
3122 struct allocdirect *adp, *lastadp;
3123 struct dinode *dp;
3124 struct fs *fs;
3125 ufs_lbn_t prevlbn = 0;
3126 int i, deplist;
3127
3128 if (inodedep->id_state & IOSTARTED)
3129 panic("initiate_write_inodeblock: already started");
3130 inodedep->id_state |= IOSTARTED;
3131 fs = inodedep->id_fs;
3132 dp = (struct dinode *)bp->b_data +
3133 ino_to_fsbo(fs, inodedep->id_ino);
3134 /*
3135 * If the bitmap is not yet written, then the allocated
3136 * inode cannot be written to disk.
3137 */
3138 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
3139 if (inodedep->id_savedino != NULL)
3140 panic("initiate_write_inodeblock: already doing I/O");
3141 MALLOC(inodedep->id_savedino, struct dinode *,
3142 sizeof(struct dinode), M_INODEDEP, M_SOFTDEP_FLAGS);
3143 *inodedep->id_savedino = *dp;
3144 bzero((caddr_t)dp, sizeof(struct dinode));
3145 return;
3146 }
3147 /*
3148 * If no dependencies, then there is nothing to roll back.
3149 */
3150 inodedep->id_savedsize = dp->di_size;
3151 if (TAILQ_FIRST(&inodedep->id_inoupdt) == NULL)
3152 return;
3153 /*
3154 * Set the dependencies to busy.
3155 */
3156 ACQUIRE_LOCK(&lk);
3157 for (deplist = 0, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
3158 adp = TAILQ_NEXT(adp, ad_next)) {
3159#ifdef DIAGNOSTIC
3160 if (deplist != 0 && prevlbn >= adp->ad_lbn) {
3161 FREE_LOCK(&lk);
3162 panic("softdep_write_inodeblock: lbn order");
3163 }
3164 prevlbn = adp->ad_lbn;
3165 if (adp->ad_lbn < NDADDR &&
3166 dp->di_db[adp->ad_lbn] != adp->ad_newblkno) {
3167 FREE_LOCK(&lk);
3168 panic("%s: direct pointer #%ld mismatch %d != %d",
3169 "softdep_write_inodeblock", adp->ad_lbn,
3170 dp->di_db[adp->ad_lbn], adp->ad_newblkno);
3171 }
3172 if (adp->ad_lbn >= NDADDR &&
3173 dp->di_ib[adp->ad_lbn - NDADDR] != adp->ad_newblkno) {
3174 FREE_LOCK(&lk);
3175 panic("%s: indirect pointer #%ld mismatch %d != %d",
3176 "softdep_write_inodeblock", adp->ad_lbn - NDADDR,
3177 dp->di_ib[adp->ad_lbn - NDADDR], adp->ad_newblkno);
3178 }
3179 deplist |= 1 << adp->ad_lbn;
3180 if ((adp->ad_state & ATTACHED) == 0) {
3181 FREE_LOCK(&lk);
3182 panic("softdep_write_inodeblock: Unknown state 0x%x",
3183 adp->ad_state);
3184 }
3185#endif /* DIAGNOSTIC */
3186 adp->ad_state &= ~ATTACHED;
3187 adp->ad_state |= UNDONE;
3188 }
3189 /*
3190 * The on-disk inode cannot claim to be any larger than the last
3191 * fragment that has been written. Otherwise, the on-disk inode
3192 * might have fragments that were not the last block in the file
3193 * which would corrupt the filesystem.
3194 */
3195 for (lastadp = NULL, adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp;
3196 lastadp = adp, adp = TAILQ_NEXT(adp, ad_next)) {
3197 if (adp->ad_lbn >= NDADDR)
3198 break;
3199 dp->di_db[adp->ad_lbn] = adp->ad_oldblkno;
3200 /* keep going until hitting a rollback to a frag */
3201 if (adp->ad_oldsize == 0 || adp->ad_oldsize == fs->fs_bsize)
3202 continue;
3203 dp->di_size = fs->fs_bsize * adp->ad_lbn + adp->ad_oldsize;
3204 for (i = adp->ad_lbn + 1; i < NDADDR; i++) {
3205#ifdef DIAGNOSTIC
3206 if (dp->di_db[i] != 0 && (deplist & (1 << i)) == 0) {
3207 FREE_LOCK(&lk);
3208 panic("softdep_write_inodeblock: lost dep1");
3209 }
3210#endif /* DIAGNOSTIC */
3211 dp->di_db[i] = 0;
3212 }
3213 for (i = 0; i < NIADDR; i++) {
3214#ifdef DIAGNOSTIC
3215 if (dp->di_ib[i] != 0 &&
3216 (deplist & ((1 << NDADDR) << i)) == 0) {
3217 FREE_LOCK(&lk);
3218 panic("softdep_write_inodeblock: lost dep2");
3219 }
3220#endif /* DIAGNOSTIC */
3221 dp->di_ib[i] = 0;
3222 }
3223 FREE_LOCK(&lk);
3224 return;
3225 }
3226 /*
3227 * If we have zero'ed out the last allocated block of the file,
3228 * roll back the size to the last currently allocated block.
3229 * We know that this last allocated block is a full-sized as
3230 * we already checked for fragments in the loop above.
3231 */
3232 if (lastadp != NULL &&
3233 dp->di_size <= (lastadp->ad_lbn + 1) * fs->fs_bsize) {
3234 for (i = lastadp->ad_lbn; i >= 0; i--)
3235 if (dp->di_db[i] != 0)
3236 break;
3237 dp->di_size = (i + 1) * fs->fs_bsize;
3238 }
3239 /*
3240 * The only dependencies are for indirect blocks.
3241 *
3242 * The file size for indirect block additions is not guaranteed.
3243 * Such a guarantee would be non-trivial to achieve. The conventional
3244 * synchronous write implementation also does not make this guarantee.
3245 * Fsck should catch and fix discrepancies. Arguably, the file size
3246 * can be over-estimated without destroying integrity when the file
3247 * moves into the indirect blocks (i.e., is large). If we want to
3248 * postpone fsck, we are stuck with this argument.
3249 */
3250 for (; adp; adp = TAILQ_NEXT(adp, ad_next))
3251 dp->di_ib[adp->ad_lbn - NDADDR] = 0;
3252 FREE_LOCK(&lk);
3253}
3254
3255/*
3256 * This routine is called during the completion interrupt
3257 * service routine for a disk write (from the procedure called
3258 * by the device driver to inform the file system caches of
3259 * a request completion). It should be called early in this
3260 * procedure, before the block is made available to other
3261 * processes or other routines are called.
3262 */
3263static void
3264softdep_disk_write_complete(bp)
3265 struct buf *bp; /* describes the completed disk write */
3266{
3267 struct worklist *wk;
3268 struct workhead reattach;
3269 struct newblk *newblk;
3270 struct allocindir *aip;
3271 struct allocdirect *adp;
3272 struct indirdep *indirdep;
3273 struct inodedep *inodedep;
3274 struct bmsafemap *bmsafemap;
3275
3276#ifdef DEBUG
3277 if (lk.lkt_held != -1)
3278 panic("softdep_disk_write_complete: lock is held");
3279 lk.lkt_held = -2;
3280#endif
3281 LIST_INIT(&reattach);
3282 while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) {
3283 WORKLIST_REMOVE(wk);
3284 switch (wk->wk_type) {
3285
3286 case D_PAGEDEP:
3287 if (handle_written_filepage(WK_PAGEDEP(wk), bp))
3288 WORKLIST_INSERT(&reattach, wk);
3289 continue;
3290
3291 case D_INODEDEP:
3292 if (handle_written_inodeblock(WK_INODEDEP(wk), bp))
3293 WORKLIST_INSERT(&reattach, wk);
3294 continue;
3295
3296 case D_BMSAFEMAP:
3297 bmsafemap = WK_BMSAFEMAP(wk);
3298 while ((newblk = LIST_FIRST(&bmsafemap->sm_newblkhd))) {
3299 newblk->nb_state |= DEPCOMPLETE;
3300 newblk->nb_bmsafemap = NULL;
3301 LIST_REMOVE(newblk, nb_deps);
3302 }
3303 while ((adp =
3304 LIST_FIRST(&bmsafemap->sm_allocdirecthd))) {
3305 adp->ad_state |= DEPCOMPLETE;
3306 adp->ad_buf = NULL;
3307 LIST_REMOVE(adp, ad_deps);
3308 handle_allocdirect_partdone(adp);
3309 }
3310 while ((aip =
3311 LIST_FIRST(&bmsafemap->sm_allocindirhd))) {
3312 aip->ai_state |= DEPCOMPLETE;
3313 aip->ai_buf = NULL;
3314 LIST_REMOVE(aip, ai_deps);
3315 handle_allocindir_partdone(aip);
3316 }
3317 while ((inodedep =
3318 LIST_FIRST(&bmsafemap->sm_inodedephd)) != NULL) {
3319 inodedep->id_state |= DEPCOMPLETE;
3320 LIST_REMOVE(inodedep, id_deps);
3321 inodedep->id_buf = NULL;
3322 }
3323 WORKITEM_FREE(bmsafemap, D_BMSAFEMAP);
3324 continue;
3325
3326 case D_MKDIR:
3327 handle_written_mkdir(WK_MKDIR(wk), MKDIR_BODY);
3328 continue;
3329
3330 case D_ALLOCDIRECT:
3331 adp = WK_ALLOCDIRECT(wk);
3332 adp->ad_state |= COMPLETE;
3333 handle_allocdirect_partdone(adp);
3334 continue;
3335
3336 case D_ALLOCINDIR:
3337 aip = WK_ALLOCINDIR(wk);
3338 aip->ai_state |= COMPLETE;
3339 handle_allocindir_partdone(aip);
3340 continue;
3341
3342 case D_INDIRDEP:
3343 indirdep = WK_INDIRDEP(wk);
3344 if (indirdep->ir_state & GOINGAWAY) {
3345 lk.lkt_held = -1;
3346 panic("disk_write_complete: indirdep gone");
3347 }
3348 bcopy(indirdep->ir_saveddata, bp->b_data, bp->b_bcount);
3349 FREE(indirdep->ir_saveddata, M_INDIRDEP);
3350 indirdep->ir_saveddata = 0;
3351 indirdep->ir_state &= ~UNDONE;
3352 indirdep->ir_state |= ATTACHED;
3353 while ((aip = LIST_FIRST(&indirdep->ir_donehd)) != 0) {
3354 handle_allocindir_partdone(aip);
3355 if (aip == LIST_FIRST(&indirdep->ir_donehd)) {
3356 lk.lkt_held = -1;
3357 panic("disk_write_complete: not gone");
3358 }
3359 }
3360 WORKLIST_INSERT(&reattach, wk);
3361 if ((bp->b_flags & B_DELWRI) == 0)
3362 stat_indir_blk_ptrs++;
3363 bdirty(bp);
3364 continue;
3365
3366 default:
3367 lk.lkt_held = -1;
3368 panic("handle_disk_write_complete: Unknown type %s",
3369 TYPENAME(wk->wk_type));
3370 /* NOTREACHED */
3371 }
3372 }
3373 /*
3374 * Reattach any requests that must be redone.
3375 */
3376 while ((wk = LIST_FIRST(&reattach)) != NULL) {
3377 WORKLIST_REMOVE(wk);
3378 WORKLIST_INSERT(&bp->b_dep, wk);
3379 }
3380#ifdef DEBUG
3381 if (lk.lkt_held != -2)
3382 panic("softdep_disk_write_complete: lock lost");
3383 lk.lkt_held = -1;
3384#endif
3385}
3386
3387/*
3388 * Called from within softdep_disk_write_complete above. Note that
3389 * this routine is always called from interrupt level with further
3390 * splbio interrupts blocked.
3391 */
3392static void
3393handle_allocdirect_partdone(adp)
3394 struct allocdirect *adp; /* the completed allocdirect */
3395{
3396 struct allocdirect *listadp;
3397 struct inodedep *inodedep;
3398 long bsize, delay;
3399
3400 if ((adp->ad_state & ALLCOMPLETE) != ALLCOMPLETE)
3401 return;
3402 if (adp->ad_buf != NULL) {
3403 lk.lkt_held = -1;
3404 panic("handle_allocdirect_partdone: dangling dep");
3405 }
3406 /*
3407 * The on-disk inode cannot claim to be any larger than the last
3408 * fragment that has been written. Otherwise, the on-disk inode
3409 * might have fragments that were not the last block in the file
3410 * which would corrupt the filesystem. Thus, we cannot free any
3411 * allocdirects after one whose ad_oldblkno claims a fragment as
3412 * these blocks must be rolled back to zero before writing the inode.
3413 * We check the currently active set of allocdirects in id_inoupdt.
3414 */
3415 inodedep = adp->ad_inodedep;
3416 bsize = inodedep->id_fs->fs_bsize;
3417 TAILQ_FOREACH(listadp, &inodedep->id_inoupdt, ad_next) {
3418 /* found our block */
3419 if (listadp == adp)
3420 break;
3421 /* continue if ad_oldlbn is not a fragment */
3422 if (listadp->ad_oldsize == 0 ||
3423 listadp->ad_oldsize == bsize)
3424 continue;
3425 /* hit a fragment */
3426 return;
3427 }
3428 /*
3429 * If we have reached the end of the current list without
3430 * finding the just finished dependency, then it must be
3431 * on the future dependency list. Future dependencies cannot
3432 * be freed until they are moved to the current list.
3433 */
3434 if (listadp == NULL) {
3435#ifdef DEBUG
3436 TAILQ_FOREACH(listadp, &inodedep->id_newinoupdt, ad_next)
3437 /* found our block */
3438 if (listadp == adp)
3439 break;
3440 if (listadp == NULL) {
3441 lk.lkt_held = -1;
3442 panic("handle_allocdirect_partdone: lost dep");
3443 }
3444#endif /* DEBUG */
3445 return;
3446 }
3447 /*
3448 * If we have found the just finished dependency, then free
3449 * it along with anything that follows it that is complete.
3450 * If the inode still has a bitmap dependency, then it has
3451 * never been written to disk, hence the on-disk inode cannot
3452 * reference the old fragment so we can free it without delay.
3453 */
3454 delay = (inodedep->id_state & DEPCOMPLETE);
3455 for (; adp; adp = listadp) {
3456 listadp = TAILQ_NEXT(adp, ad_next);
3457 if ((adp->ad_state & ALLCOMPLETE) != ALLCOMPLETE)
3458 return;
3459 free_allocdirect(&inodedep->id_inoupdt, adp, delay);
3460 }
3461}
3462
3463/*
3464 * Called from within softdep_disk_write_complete above. Note that
3465 * this routine is always called from interrupt level with further
3466 * splbio interrupts blocked.
3467 */
3468static void
3469handle_allocindir_partdone(aip)
3470 struct allocindir *aip; /* the completed allocindir */
3471{
3472 struct indirdep *indirdep;
3473
3474 if ((aip->ai_state & ALLCOMPLETE) != ALLCOMPLETE)
3475 return;
3476 if (aip->ai_buf != NULL) {
3477 lk.lkt_held = -1;
3478 panic("handle_allocindir_partdone: dangling dependency");
3479 }
3480 indirdep = aip->ai_indirdep;
3481 if (indirdep->ir_state & UNDONE) {
3482 LIST_REMOVE(aip, ai_next);
3483 LIST_INSERT_HEAD(&indirdep->ir_donehd, aip, ai_next);
3484 return;
3485 }
3486 ((ufs_daddr_t *)indirdep->ir_savebp->b_data)[aip->ai_offset] =
3487 aip->ai_newblkno;
3488 LIST_REMOVE(aip, ai_next);
3489 if (aip->ai_freefrag != NULL)
3490 add_to_worklist(&aip->ai_freefrag->ff_list);
3491 WORKITEM_FREE(aip, D_ALLOCINDIR);
3492}
3493
3494/*
3495 * Called from within softdep_disk_write_complete above to restore
3496 * in-memory inode block contents to their most up-to-date state. Note
3497 * that this routine is always called from interrupt level with further
3498 * splbio interrupts blocked.
3499 */
3500static int
3501handle_written_inodeblock(inodedep, bp)
3502 struct inodedep *inodedep;
3503 struct buf *bp; /* buffer containing the inode block */
3504{
3505 struct worklist *wk, *filefree;
3506 struct allocdirect *adp, *nextadp;
3507 struct dinode *dp;
3508 int hadchanges;
3509
3510 if ((inodedep->id_state & IOSTARTED) == 0) {
3511 lk.lkt_held = -1;
3512 panic("handle_written_inodeblock: not started");
3513 }
3514 inodedep->id_state &= ~IOSTARTED;
3515 inodedep->id_state |= COMPLETE;
3516 dp = (struct dinode *)bp->b_data +
3517 ino_to_fsbo(inodedep->id_fs, inodedep->id_ino);
3518 /*
3519 * If we had to rollback the inode allocation because of
3520 * bitmaps being incomplete, then simply restore it.
3521 * Keep the block dirty so that it will not be reclaimed until
3522 * all associated dependencies have been cleared and the
3523 * corresponding updates written to disk.
3524 */
3525 if (inodedep->id_savedino != NULL) {
3526 *dp = *inodedep->id_savedino;
3527 FREE(inodedep->id_savedino, M_INODEDEP);
3528 inodedep->id_savedino = NULL;
3529 if ((bp->b_flags & B_DELWRI) == 0)
3530 stat_inode_bitmap++;
3531 bdirty(bp);
3532 return (1);
3533 }
3534 /*
3535 * Roll forward anything that had to be rolled back before
3536 * the inode could be updated.
3537 */
3538 hadchanges = 0;
3539 for (adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp; adp = nextadp) {
3540 nextadp = TAILQ_NEXT(adp, ad_next);
3541 if (adp->ad_state & ATTACHED) {
3542 lk.lkt_held = -1;
3543 panic("handle_written_inodeblock: new entry");
3544 }
3545 if (adp->ad_lbn < NDADDR) {
3546 if (dp->di_db[adp->ad_lbn] != adp->ad_oldblkno) {
3547 lk.lkt_held = -1;
3548 panic("%s: %s #%ld mismatch %d != %d",
3549 "handle_written_inodeblock",
3550 "direct pointer", adp->ad_lbn,
3551 dp->di_db[adp->ad_lbn], adp->ad_oldblkno);
3552 }
3553 dp->di_db[adp->ad_lbn] = adp->ad_newblkno;
3554 } else {
3555 if (dp->di_ib[adp->ad_lbn - NDADDR] != 0) {
3556 lk.lkt_held = -1;
3557 panic("%s: %s #%ld allocated as %d",
3558 "handle_written_inodeblock",
3559 "indirect pointer", adp->ad_lbn - NDADDR,
3560 dp->di_ib[adp->ad_lbn - NDADDR]);
3561 }
3562 dp->di_ib[adp->ad_lbn - NDADDR] = adp->ad_newblkno;
3563 }
3564 adp->ad_state &= ~UNDONE;
3565 adp->ad_state |= ATTACHED;
3566 hadchanges = 1;
3567 }
3568 if (hadchanges && (bp->b_flags & B_DELWRI) == 0)
3569 stat_direct_blk_ptrs++;
3570 /*
3571 * Reset the file size to its most up-to-date value.
3572 */
3573 if (inodedep->id_savedsize == -1) {
3574 lk.lkt_held = -1;
3575 panic("handle_written_inodeblock: bad size");
3576 }
3577 if (dp->di_size != inodedep->id_savedsize) {
3578 dp->di_size = inodedep->id_savedsize;
3579 hadchanges = 1;
3580 }
3581 inodedep->id_savedsize = -1;
3582 /*
3583 * If there were any rollbacks in the inode block, then it must be
3584 * marked dirty so that its will eventually get written back in
3585 * its correct form.
3586 */
3587 if (hadchanges)
3588 bdirty(bp);
3589 /*
3590 * Process any allocdirects that completed during the update.
3591 */
3592 if ((adp = TAILQ_FIRST(&inodedep->id_inoupdt)) != NULL)
3593 handle_allocdirect_partdone(adp);
3594 /*
3595 * Process deallocations that were held pending until the
3596 * inode had been written to disk. Freeing of the inode
3597 * is delayed until after all blocks have been freed to
3598 * avoid creation of new <vfsid, inum, lbn> triples
3599 * before the old ones have been deleted.
3600 */
3601 filefree = NULL;
3602 while ((wk = LIST_FIRST(&inodedep->id_bufwait)) != NULL) {
3603 WORKLIST_REMOVE(wk);
3604 switch (wk->wk_type) {
3605
3606 case D_FREEFILE:
3607 /*
3608 * We defer adding filefree to the worklist until
3609 * all other additions have been made to ensure
3610 * that it will be done after all the old blocks
3611 * have been freed.
3612 */
3613 if (filefree != NULL) {
3614 lk.lkt_held = -1;
3615 panic("handle_written_inodeblock: filefree");
3616 }
3617 filefree = wk;
3618 continue;
3619
3620 case D_MKDIR:
3621 handle_written_mkdir(WK_MKDIR(wk), MKDIR_PARENT);
3622 continue;
3623
3624 case D_DIRADD:
3625 diradd_inode_written(WK_DIRADD(wk), inodedep);
3626 continue;
3627
3628 case D_FREEBLKS:
3629 case D_FREEFRAG:
3630 case D_DIRREM:
3631 add_to_worklist(wk);
3632 continue;
3633
3634 default:
3635 lk.lkt_held = -1;
3636 panic("handle_written_inodeblock: Unknown type %s",
3637 TYPENAME(wk->wk_type));
3638 /* NOTREACHED */
3639 }
3640 }
3641 if (filefree != NULL) {
3642 if (free_inodedep(inodedep) == 0) {
3643 lk.lkt_held = -1;
3644 panic("handle_written_inodeblock: live inodedep");
3645 }
3646 add_to_worklist(filefree);
3647 return (0);
3648 }
3649
3650 /*
3651 * If no outstanding dependencies, free it.
3652 */
3653 if (free_inodedep(inodedep) || TAILQ_FIRST(&inodedep->id_inoupdt) == 0)
3654 return (0);
3655 return (hadchanges);
3656}
3657
3658/*
3659 * Process a diradd entry after its dependent inode has been written.
3660 * This routine must be called with splbio interrupts blocked.
3661 */
3662static void
3663diradd_inode_written(dap, inodedep)
3664 struct diradd *dap;
3665 struct inodedep *inodedep;
3666{
3667 struct pagedep *pagedep;
3668
3669 dap->da_state |= COMPLETE;
3670 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3671 if (dap->da_state & DIRCHG)
3672 pagedep = dap->da_previous->dm_pagedep;
3673 else
3674 pagedep = dap->da_pagedep;
3675 LIST_REMOVE(dap, da_pdlist);
3676 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
3677 }
3678 WORKLIST_INSERT(&inodedep->id_pendinghd, &dap->da_list);
3679}
3680
3681/*
3682 * Handle the completion of a mkdir dependency.
3683 */
3684static void
3685handle_written_mkdir(mkdir, type)
3686 struct mkdir *mkdir;
3687 int type;
3688{
3689 struct diradd *dap;
3690 struct pagedep *pagedep;
3691
3692 if (mkdir->md_state != type) {
3693 lk.lkt_held = -1;
3694 panic("handle_written_mkdir: bad type");
3695 }
3696 dap = mkdir->md_diradd;
3697 dap->da_state &= ~type;
3698 if ((dap->da_state & (MKDIR_PARENT | MKDIR_BODY)) == 0)
3699 dap->da_state |= DEPCOMPLETE;
3700 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3701 if (dap->da_state & DIRCHG)
3702 pagedep = dap->da_previous->dm_pagedep;
3703 else
3704 pagedep = dap->da_pagedep;
3705 LIST_REMOVE(dap, da_pdlist);
3706 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap, da_pdlist);
3707 }
3708 LIST_REMOVE(mkdir, md_mkdirs);
3709 WORKITEM_FREE(mkdir, D_MKDIR);
3710}
3711
3712/*
3713 * Called from within softdep_disk_write_complete above.
3714 * A write operation was just completed. Removed inodes can
3715 * now be freed and associated block pointers may be committed.
3716 * Note that this routine is always called from interrupt level
3717 * with further splbio interrupts blocked.
3718 */
3719static int
3720handle_written_filepage(pagedep, bp)
3721 struct pagedep *pagedep;
3722 struct buf *bp; /* buffer containing the written page */
3723{
3724 struct dirrem *dirrem;
3725 struct diradd *dap, *nextdap;
3726 struct direct *ep;
3727 int i, chgs;
3728
3729 if ((pagedep->pd_state & IOSTARTED) == 0) {
3730 lk.lkt_held = -1;
3731 panic("handle_written_filepage: not started");
3732 }
3733 pagedep->pd_state &= ~IOSTARTED;
3734 /*
3735 * Process any directory removals that have been committed.
3736 */
3737 while ((dirrem = LIST_FIRST(&pagedep->pd_dirremhd)) != NULL) {
3738 LIST_REMOVE(dirrem, dm_next);
3739 dirrem->dm_dirinum = pagedep->pd_ino;
3740 add_to_worklist(&dirrem->dm_list);
3741 }
3742 /*
3743 * Free any directory additions that have been committed.
3744 */
3745 while ((dap = LIST_FIRST(&pagedep->pd_pendinghd)) != NULL)
3746 free_diradd(dap);
3747 /*
3748 * Uncommitted directory entries must be restored.
3749 */
3750 for (chgs = 0, i = 0; i < DAHASHSZ; i++) {
3751 for (dap = LIST_FIRST(&pagedep->pd_diraddhd[i]); dap;
3752 dap = nextdap) {
3753 nextdap = LIST_NEXT(dap, da_pdlist);
3754 if (dap->da_state & ATTACHED) {
3755 lk.lkt_held = -1;
3756 panic("handle_written_filepage: attached");
3757 }
3758 ep = (struct direct *)
3759 ((char *)bp->b_data + dap->da_offset);
3760 ep->d_ino = dap->da_newinum;
3761 dap->da_state &= ~UNDONE;
3762 dap->da_state |= ATTACHED;
3763 chgs = 1;
3764 /*
3765 * If the inode referenced by the directory has
3766 * been written out, then the dependency can be
3767 * moved to the pending list.
3768 */
3769 if ((dap->da_state & ALLCOMPLETE) == ALLCOMPLETE) {
3770 LIST_REMOVE(dap, da_pdlist);
3771 LIST_INSERT_HEAD(&pagedep->pd_pendinghd, dap,
3772 da_pdlist);
3773 }
3774 }
3775 }
3776 /*
3777 * If there were any rollbacks in the directory, then it must be
3778 * marked dirty so that its will eventually get written back in
3779 * its correct form.
3780 */
3781 if (chgs) {
3782 if ((bp->b_flags & B_DELWRI) == 0)
3783 stat_dir_entry++;
3784 bdirty(bp);
3785 }
3786 /*
3787 * If no dependencies remain, the pagedep will be freed.
3788 * Otherwise it will remain to update the page before it
3789 * is written back to disk.
3790 */
3791 if (LIST_FIRST(&pagedep->pd_pendinghd) == 0) {
3792 for (i = 0; i < DAHASHSZ; i++)
3793 if (LIST_FIRST(&pagedep->pd_diraddhd[i]) != NULL)
3794 break;
3795 if (i == DAHASHSZ) {
3796 LIST_REMOVE(pagedep, pd_hash);
3797 WORKITEM_FREE(pagedep, D_PAGEDEP);
3798 return (0);
3799 }
3800 }
3801 return (1);
3802}
3803
3804/*
3805 * Writing back in-core inode structures.
3806 *
3807 * The file system only accesses an inode's contents when it occupies an
3808 * "in-core" inode structure. These "in-core" structures are separate from
3809 * the page frames used to cache inode blocks. Only the latter are
3810 * transferred to/from the disk. So, when the updated contents of the
3811 * "in-core" inode structure are copied to the corresponding in-memory inode
3812 * block, the dependencies are also transferred. The following procedure is
3813 * called when copying a dirty "in-core" inode to a cached inode block.
3814 */
3815
3816/*
3817 * Called when an inode is loaded from disk. If the effective link count
3818 * differed from the actual link count when it was last flushed, then we
3819 * need to ensure that the correct effective link count is put back.
3820 */
3821void
3822softdep_load_inodeblock(ip)
3823 struct inode *ip; /* the "in_core" copy of the inode */
3824{
3825 struct inodedep *inodedep;
3826
3827 /*
3828 * Check for alternate nlink count.
3829 */
3830 ip->i_effnlink = ip->i_nlink;
3831 ACQUIRE_LOCK(&lk);
3832 if (inodedep_lookup(ip->i_fs, ip->i_number, 0, &inodedep) == 0) {
3833 FREE_LOCK(&lk);
3834 return;
3835 }
3836 ip->i_effnlink -= inodedep->id_nlinkdelta;
|
| 3837 if (inodedep->id_state & SPACECOUNTED)
3838 ip->i_flag |= IN_SPACECOUNTED;
|
3782 FREE_LOCK(&lk);
3783}
3784
3785/*
3786 * This routine is called just before the "in-core" inode
3787 * information is to be copied to the in-memory inode block.
3788 * Recall that an inode block contains several inodes. If
3789 * the force flag is set, then the dependencies will be
3790 * cleared so that the update can always be made. Note that
3791 * the buffer is locked when this routine is called, so we
3792 * will never be in the middle of writing the inode block
3793 * to disk.
3794 */
3795void
3796softdep_update_inodeblock(ip, bp, waitfor)
3797 struct inode *ip; /* the "in_core" copy of the inode */
3798 struct buf *bp; /* the buffer containing the inode block */
3799 int waitfor; /* nonzero => update must be allowed */
3800{
3801 struct inodedep *inodedep;
3802 struct worklist *wk;
3803 int error, gotit;
3804
3805 /*
3806 * If the effective link count is not equal to the actual link
3807 * count, then we must track the difference in an inodedep while
3808 * the inode is (potentially) tossed out of the cache. Otherwise,
3809 * if there is no existing inodedep, then there are no dependencies
3810 * to track.
3811 */
3812 ACQUIRE_LOCK(&lk);
3813 if (inodedep_lookup(ip->i_fs, ip->i_number, 0, &inodedep) == 0) {
3814 FREE_LOCK(&lk);
3815 if (ip->i_effnlink != ip->i_nlink)
3816 panic("softdep_update_inodeblock: bad link count");
3817 return;
3818 }
3819 if (inodedep->id_nlinkdelta != ip->i_nlink - ip->i_effnlink) {
3820 FREE_LOCK(&lk);
3821 panic("softdep_update_inodeblock: bad delta");
3822 }
3823 /*
3824 * Changes have been initiated. Anything depending on these
3825 * changes cannot occur until this inode has been written.
3826 */
3827 inodedep->id_state &= ~COMPLETE;
3828 if ((inodedep->id_state & ONWORKLIST) == 0)
3829 WORKLIST_INSERT(&bp->b_dep, &inodedep->id_list);
3830 /*
3831 * Any new dependencies associated with the incore inode must
3832 * now be moved to the list associated with the buffer holding
3833 * the in-memory copy of the inode. Once merged process any
3834 * allocdirects that are completed by the merger.
3835 */
3836 merge_inode_lists(inodedep);
3837 if (TAILQ_FIRST(&inodedep->id_inoupdt) != NULL)
3838 handle_allocdirect_partdone(TAILQ_FIRST(&inodedep->id_inoupdt));
3839 /*
3840 * Now that the inode has been pushed into the buffer, the
3841 * operations dependent on the inode being written to disk
3842 * can be moved to the id_bufwait so that they will be
3843 * processed when the buffer I/O completes.
3844 */
3845 while ((wk = LIST_FIRST(&inodedep->id_inowait)) != NULL) {
3846 WORKLIST_REMOVE(wk);
3847 WORKLIST_INSERT(&inodedep->id_bufwait, wk);
3848 }
3849 /*
3850 * Newly allocated inodes cannot be written until the bitmap
3851 * that allocates them have been written (indicated by
3852 * DEPCOMPLETE being set in id_state). If we are doing a
3853 * forced sync (e.g., an fsync on a file), we force the bitmap
3854 * to be written so that the update can be done.
3855 */
3856 if ((inodedep->id_state & DEPCOMPLETE) != 0 || waitfor == 0) {
3857 FREE_LOCK(&lk);
3858 return;
3859 }
3860 gotit = getdirtybuf(&inodedep->id_buf, MNT_WAIT);
3861 FREE_LOCK(&lk);
3862 if (gotit &&
3863 (error = BUF_WRITE(inodedep->id_buf)) != 0)
3864 softdep_error("softdep_update_inodeblock: bwrite", error);
3865 if ((inodedep->id_state & DEPCOMPLETE) == 0)
3866 panic("softdep_update_inodeblock: update failed");
3867}
3868
3869/*
3870 * Merge the new inode dependency list (id_newinoupdt) into the old
3871 * inode dependency list (id_inoupdt). This routine must be called
3872 * with splbio interrupts blocked.
3873 */
3874static void
3875merge_inode_lists(inodedep)
3876 struct inodedep *inodedep;
3877{
3878 struct allocdirect *listadp, *newadp;
3879
3880 newadp = TAILQ_FIRST(&inodedep->id_newinoupdt);
3881 for (listadp = TAILQ_FIRST(&inodedep->id_inoupdt); listadp && newadp;) {
3882 if (listadp->ad_lbn < newadp->ad_lbn) {
3883 listadp = TAILQ_NEXT(listadp, ad_next);
3884 continue;
3885 }
3886 TAILQ_REMOVE(&inodedep->id_newinoupdt, newadp, ad_next);
3887 TAILQ_INSERT_BEFORE(listadp, newadp, ad_next);
3888 if (listadp->ad_lbn == newadp->ad_lbn) {
3889 allocdirect_merge(&inodedep->id_inoupdt, newadp,
3890 listadp);
3891 listadp = newadp;
3892 }
3893 newadp = TAILQ_FIRST(&inodedep->id_newinoupdt);
3894 }
3895 while ((newadp = TAILQ_FIRST(&inodedep->id_newinoupdt)) != NULL) {
3896 TAILQ_REMOVE(&inodedep->id_newinoupdt, newadp, ad_next);
3897 TAILQ_INSERT_TAIL(&inodedep->id_inoupdt, newadp, ad_next);
3898 }
3899}
3900
3901/*
3902 * If we are doing an fsync, then we must ensure that any directory
3903 * entries for the inode have been written after the inode gets to disk.
3904 */
3905int
3906softdep_fsync(vp)
3907 struct vnode *vp; /* the "in_core" copy of the inode */
3908{
3909 struct inodedep *inodedep;
3910 struct pagedep *pagedep;
3911 struct worklist *wk;
3912 struct diradd *dap;
3913 struct mount *mnt;
3914 struct vnode *pvp;
3915 struct inode *ip;
3916 struct buf *bp;
3917 struct fs *fs;
3918 struct proc *p = CURPROC; /* XXX */
3919 int error, flushparent;
3920 ino_t parentino;
3921 ufs_lbn_t lbn;
3922
3923 ip = VTOI(vp);
3924 fs = ip->i_fs;
3925 ACQUIRE_LOCK(&lk);
3926 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0) {
3927 FREE_LOCK(&lk);
3928 return (0);
3929 }
3930 if (LIST_FIRST(&inodedep->id_inowait) != NULL ||
3931 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
3932 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
3933 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL) {
3934 FREE_LOCK(&lk);
3935 panic("softdep_fsync: pending ops");
3936 }
3937 for (error = 0, flushparent = 0; ; ) {
3938 if ((wk = LIST_FIRST(&inodedep->id_pendinghd)) == NULL)
3939 break;
3940 if (wk->wk_type != D_DIRADD) {
3941 FREE_LOCK(&lk);
3942 panic("softdep_fsync: Unexpected type %s",
3943 TYPENAME(wk->wk_type));
3944 }
3945 dap = WK_DIRADD(wk);
3946 /*
3947 * Flush our parent if this directory entry
3948 * has a MKDIR_PARENT dependency.
3949 */
3950 if (dap->da_state & DIRCHG)
3951 pagedep = dap->da_previous->dm_pagedep;
3952 else
3953 pagedep = dap->da_pagedep;
3954 mnt = pagedep->pd_mnt;
3955 parentino = pagedep->pd_ino;
3956 lbn = pagedep->pd_lbn;
3957 if ((dap->da_state & (MKDIR_BODY | COMPLETE)) != COMPLETE) {
3958 FREE_LOCK(&lk);
3959 panic("softdep_fsync: dirty");
3960 }
3961 flushparent = dap->da_state & MKDIR_PARENT;
3962 /*
3963 * If we are being fsync'ed as part of vgone'ing this vnode,
3964 * then we will not be able to release and recover the
3965 * vnode below, so we just have to give up on writing its
3966 * directory entry out. It will eventually be written, just
3967 * not now, but then the user was not asking to have it
3968 * written, so we are not breaking any promises.
3969 */
3970 if (vp->v_flag & VXLOCK)
3971 break;
3972 /*
3973 * We prevent deadlock by always fetching inodes from the
3974 * root, moving down the directory tree. Thus, when fetching
3975 * our parent directory, we must unlock ourselves before
3976 * requesting the lock on our parent. See the comment in
3977 * ufs_lookup for details on possible races.
3978 */
3979 FREE_LOCK(&lk);
3980 VOP_UNLOCK(vp, 0, p);
3981 error = VFS_VGET(mnt, parentino, &pvp);
3982 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
3983 if (error != 0)
3984 return (error);
3985 if (flushparent) {
3986 if ((error = UFS_UPDATE(pvp, 1)) != 0) {
3987 vput(pvp);
3988 return (error);
3989 }
3990 }
3991 /*
3992 * Flush directory page containing the inode's name.
3993 */
3994 error = bread(pvp, lbn, blksize(fs, VTOI(pvp), lbn), p->p_ucred,
3995 &bp);
3996 if (error == 0)
3997 error = BUF_WRITE(bp);
3998 vput(pvp);
3999 if (error != 0)
4000 return (error);
4001 ACQUIRE_LOCK(&lk);
4002 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0)
4003 break;
4004 }
4005 FREE_LOCK(&lk);
4006 return (0);
4007}
4008
4009/*
4010 * Flush all the dirty bitmaps associated with the block device
4011 * before flushing the rest of the dirty blocks so as to reduce
4012 * the number of dependencies that will have to be rolled back.
4013 */
4014void
4015softdep_fsync_mountdev(vp)
4016 struct vnode *vp;
4017{
4018 struct buf *bp, *nbp;
4019 struct worklist *wk;
4020
4021 if (!vn_isdisk(vp, NULL))
4022 panic("softdep_fsync_mountdev: vnode not a disk");
4023 ACQUIRE_LOCK(&lk);
4024 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
4025 nbp = TAILQ_NEXT(bp, b_vnbufs);
4026 /*
4027 * If it is already scheduled, skip to the next buffer.
4028 */
4029 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
4030 continue;
4031 if ((bp->b_flags & B_DELWRI) == 0) {
4032 FREE_LOCK(&lk);
4033 panic("softdep_fsync_mountdev: not dirty");
4034 }
4035 /*
4036 * We are only interested in bitmaps with outstanding
4037 * dependencies.
4038 */
4039 if ((wk = LIST_FIRST(&bp->b_dep)) == NULL ||
4040 wk->wk_type != D_BMSAFEMAP ||
4041 (bp->b_xflags & BX_BKGRDINPROG)) {
4042 BUF_UNLOCK(bp);
4043 continue;
4044 }
4045 bremfree(bp);
4046 FREE_LOCK(&lk);
4047 (void) bawrite(bp);
4048 ACQUIRE_LOCK(&lk);
4049 /*
4050 * Since we may have slept during the I/O, we need
4051 * to start from a known point.
4052 */
4053 nbp = TAILQ_FIRST(&vp->v_dirtyblkhd);
4054 }
4055 drain_output(vp, 1);
4056 FREE_LOCK(&lk);
4057}
4058
4059/*
4060 * This routine is called when we are trying to synchronously flush a
4061 * file. This routine must eliminate any filesystem metadata dependencies
4062 * so that the syncing routine can succeed by pushing the dirty blocks
4063 * associated with the file. If any I/O errors occur, they are returned.
4064 */
4065int
4066softdep_sync_metadata(ap)
4067 struct vop_fsync_args /* {
4068 struct vnode *a_vp;
4069 struct ucred *a_cred;
4070 int a_waitfor;
4071 struct proc *a_p;
4072 } */ *ap;
4073{
4074 struct vnode *vp = ap->a_vp;
4075 struct pagedep *pagedep;
4076 struct allocdirect *adp;
4077 struct allocindir *aip;
4078 struct buf *bp, *nbp;
4079 struct worklist *wk;
4080 int i, error, waitfor;
4081
4082 /*
4083 * Check whether this vnode is involved in a filesystem
4084 * that is doing soft dependency processing.
4085 */
4086 if (!vn_isdisk(vp, NULL)) {
4087 if (!DOINGSOFTDEP(vp))
4088 return (0);
4089 } else
4090 if (vp->v_rdev->si_mountpoint == NULL ||
4091 (vp->v_rdev->si_mountpoint->mnt_flag & MNT_SOFTDEP) == 0)
4092 return (0);
4093 /*
4094 * Ensure that any direct block dependencies have been cleared.
4095 */
4096 ACQUIRE_LOCK(&lk);
4097 if ((error = flush_inodedep_deps(VTOI(vp)->i_fs, VTOI(vp)->i_number))) {
4098 FREE_LOCK(&lk);
4099 return (error);
4100 }
4101 /*
4102 * For most files, the only metadata dependencies are the
4103 * cylinder group maps that allocate their inode or blocks.
4104 * The block allocation dependencies can be found by traversing
4105 * the dependency lists for any buffers that remain on their
4106 * dirty buffer list. The inode allocation dependency will
4107 * be resolved when the inode is updated with MNT_WAIT.
4108 * This work is done in two passes. The first pass grabs most
4109 * of the buffers and begins asynchronously writing them. The
4110 * only way to wait for these asynchronous writes is to sleep
4111 * on the filesystem vnode which may stay busy for a long time
4112 * if the filesystem is active. So, instead, we make a second
4113 * pass over the dependencies blocking on each write. In the
4114 * usual case we will be blocking against a write that we
4115 * initiated, so when it is done the dependency will have been
4116 * resolved. Thus the second pass is expected to end quickly.
4117 */
4118 waitfor = MNT_NOWAIT;
4119top:
4120 if (getdirtybuf(&TAILQ_FIRST(&vp->v_dirtyblkhd), MNT_WAIT) == 0) {
4121 FREE_LOCK(&lk);
4122 return (0);
4123 }
4124 bp = TAILQ_FIRST(&vp->v_dirtyblkhd);
4125 /* While syncing snapshots, we must allow recursive lookups */
4126 bp->b_lock.lk_flags |= LK_CANRECURSE;
4127loop:
4128 /*
4129 * As we hold the buffer locked, none of its dependencies
4130 * will disappear.
4131 */
4132 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
4133 switch (wk->wk_type) {
4134
4135 case D_ALLOCDIRECT:
4136 adp = WK_ALLOCDIRECT(wk);
4137 if (adp->ad_state & DEPCOMPLETE)
4138 continue;
4139 nbp = adp->ad_buf;
4140 if (getdirtybuf(&nbp, waitfor) == 0)
4141 continue;
4142 FREE_LOCK(&lk);
4143 if (waitfor == MNT_NOWAIT) {
4144 bawrite(nbp);
4145 } else if ((error = BUF_WRITE(nbp)) != 0) {
4146 break;
4147 }
4148 ACQUIRE_LOCK(&lk);
4149 continue;
4150
4151 case D_ALLOCINDIR:
4152 aip = WK_ALLOCINDIR(wk);
4153 if (aip->ai_state & DEPCOMPLETE)
4154 continue;
4155 nbp = aip->ai_buf;
4156 if (getdirtybuf(&nbp, waitfor) == 0)
4157 continue;
4158 FREE_LOCK(&lk);
4159 if (waitfor == MNT_NOWAIT) {
4160 bawrite(nbp);
4161 } else if ((error = BUF_WRITE(nbp)) != 0) {
4162 break;
4163 }
4164 ACQUIRE_LOCK(&lk);
4165 continue;
4166
4167 case D_INDIRDEP:
4168 restart:
4169
4170 LIST_FOREACH(aip, &WK_INDIRDEP(wk)->ir_deplisthd, ai_next) {
4171 if (aip->ai_state & DEPCOMPLETE)
4172 continue;
4173 nbp = aip->ai_buf;
4174 if (getdirtybuf(&nbp, MNT_WAIT) == 0)
4175 goto restart;
4176 FREE_LOCK(&lk);
4177 if ((error = BUF_WRITE(nbp)) != 0) {
4178 break;
4179 }
4180 ACQUIRE_LOCK(&lk);
4181 goto restart;
4182 }
4183 continue;
4184
4185 case D_INODEDEP:
4186 if ((error = flush_inodedep_deps(WK_INODEDEP(wk)->id_fs,
4187 WK_INODEDEP(wk)->id_ino)) != 0) {
4188 FREE_LOCK(&lk);
4189 break;
4190 }
4191 continue;
4192
4193 case D_PAGEDEP:
4194 /*
4195 * We are trying to sync a directory that may
4196 * have dependencies on both its own metadata
4197 * and/or dependencies on the inodes of any
4198 * recently allocated files. We walk its diradd
4199 * lists pushing out the associated inode.
4200 */
4201 pagedep = WK_PAGEDEP(wk);
4202 for (i = 0; i < DAHASHSZ; i++) {
4203 if (LIST_FIRST(&pagedep->pd_diraddhd[i]) == 0)
4204 continue;
4205 if ((error =
4206 flush_pagedep_deps(vp, pagedep->pd_mnt,
4207 &pagedep->pd_diraddhd[i]))) {
4208 FREE_LOCK(&lk);
4209 break;
4210 }
4211 }
4212 continue;
4213
4214 case D_MKDIR:
4215 /*
4216 * This case should never happen if the vnode has
4217 * been properly sync'ed. However, if this function
4218 * is used at a place where the vnode has not yet
4219 * been sync'ed, this dependency can show up. So,
4220 * rather than panic, just flush it.
4221 */
4222 nbp = WK_MKDIR(wk)->md_buf;
4223 if (getdirtybuf(&nbp, waitfor) == 0)
4224 continue;
4225 FREE_LOCK(&lk);
4226 if (waitfor == MNT_NOWAIT) {
4227 bawrite(nbp);
4228 } else if ((error = BUF_WRITE(nbp)) != 0) {
4229 break;
4230 }
4231 ACQUIRE_LOCK(&lk);
4232 continue;
4233
4234 case D_BMSAFEMAP:
4235 /*
4236 * This case should never happen if the vnode has
4237 * been properly sync'ed. However, if this function
4238 * is used at a place where the vnode has not yet
4239 * been sync'ed, this dependency can show up. So,
4240 * rather than panic, just flush it.
4241 */
4242 nbp = WK_BMSAFEMAP(wk)->sm_buf;
4243 if (getdirtybuf(&nbp, waitfor) == 0)
4244 continue;
4245 FREE_LOCK(&lk);
4246 if (waitfor == MNT_NOWAIT) {
4247 bawrite(nbp);
4248 } else if ((error = BUF_WRITE(nbp)) != 0) {
4249 break;
4250 }
4251 ACQUIRE_LOCK(&lk);
4252 continue;
4253
4254 default:
4255 FREE_LOCK(&lk);
4256 panic("softdep_sync_metadata: Unknown type %s",
4257 TYPENAME(wk->wk_type));
4258 /* NOTREACHED */
4259 }
4260 /* We reach here only in error and unlocked */
4261 if (error == 0)
4262 panic("softdep_sync_metadata: zero error");
4263 bp->b_lock.lk_flags &= ~LK_CANRECURSE;
4264 bawrite(bp);
4265 return (error);
4266 }
4267 (void) getdirtybuf(&TAILQ_NEXT(bp, b_vnbufs), MNT_WAIT);
4268 nbp = TAILQ_NEXT(bp, b_vnbufs);
4269 FREE_LOCK(&lk);
4270 bp->b_lock.lk_flags &= ~LK_CANRECURSE;
4271 bawrite(bp);
4272 ACQUIRE_LOCK(&lk);
4273 if (nbp != NULL) {
4274 bp = nbp;
4275 goto loop;
4276 }
4277 /*
4278 * We must wait for any I/O in progress to finish so that
4279 * all potential buffers on the dirty list will be visible.
4280 * Once they are all there, proceed with the second pass
4281 * which will wait for the I/O as per above.
4282 */
4283 drain_output(vp, 1);
4284 /*
4285 * The brief unlock is to allow any pent up dependency
4286 * processing to be done.
4287 */
4288 if (waitfor == MNT_NOWAIT) {
4289 waitfor = MNT_WAIT;
4290 FREE_LOCK(&lk);
4291 ACQUIRE_LOCK(&lk);
4292 goto top;
4293 }
4294
4295 /*
4296 * If we have managed to get rid of all the dirty buffers,
4297 * then we are done. For certain directories and block
4298 * devices, we may need to do further work.
4299 */
4300 if (TAILQ_FIRST(&vp->v_dirtyblkhd) == NULL) {
4301 FREE_LOCK(&lk);
4302 return (0);
4303 }
4304
4305 FREE_LOCK(&lk);
4306 /*
4307 * If we are trying to sync a block device, some of its buffers may
4308 * contain metadata that cannot be written until the contents of some
4309 * partially written files have been written to disk. The only easy
4310 * way to accomplish this is to sync the entire filesystem (luckily
4311 * this happens rarely).
4312 */
4313 if (vn_isdisk(vp, NULL) &&
4314 vp->v_rdev->si_mountpoint && !VOP_ISLOCKED(vp, NULL) &&
4315 (error = VFS_SYNC(vp->v_rdev->si_mountpoint, MNT_WAIT, ap->a_cred,
4316 ap->a_p)) != 0)
4317 return (error);
4318 return (0);
4319}
4320
4321/*
4322 * Flush the dependencies associated with an inodedep.
4323 * Called with splbio blocked.
4324 */
4325static int
4326flush_inodedep_deps(fs, ino)
4327 struct fs *fs;
4328 ino_t ino;
4329{
4330 struct inodedep *inodedep;
4331 struct allocdirect *adp;
4332 int error, waitfor;
4333 struct buf *bp;
4334
4335 /*
4336 * This work is done in two passes. The first pass grabs most
4337 * of the buffers and begins asynchronously writing them. The
4338 * only way to wait for these asynchronous writes is to sleep
4339 * on the filesystem vnode which may stay busy for a long time
4340 * if the filesystem is active. So, instead, we make a second
4341 * pass over the dependencies blocking on each write. In the
4342 * usual case we will be blocking against a write that we
4343 * initiated, so when it is done the dependency will have been
4344 * resolved. Thus the second pass is expected to end quickly.
4345 * We give a brief window at the top of the loop to allow
4346 * any pending I/O to complete.
4347 */
4348 for (waitfor = MNT_NOWAIT; ; ) {
4349 FREE_LOCK(&lk);
4350 ACQUIRE_LOCK(&lk);
4351 if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
4352 return (0);
4353 TAILQ_FOREACH(adp, &inodedep->id_inoupdt, ad_next) {
4354 if (adp->ad_state & DEPCOMPLETE)
4355 continue;
4356 bp = adp->ad_buf;
4357 if (getdirtybuf(&bp, waitfor) == 0) {
4358 if (waitfor == MNT_NOWAIT)
4359 continue;
4360 break;
4361 }
4362 FREE_LOCK(&lk);
4363 if (waitfor == MNT_NOWAIT) {
4364 bawrite(bp);
4365 } else if ((error = BUF_WRITE(bp)) != 0) {
4366 ACQUIRE_LOCK(&lk);
4367 return (error);
4368 }
4369 ACQUIRE_LOCK(&lk);
4370 break;
4371 }
4372 if (adp != NULL)
4373 continue;
4374 TAILQ_FOREACH(adp, &inodedep->id_newinoupdt, ad_next) {
4375 if (adp->ad_state & DEPCOMPLETE)
4376 continue;
4377 bp = adp->ad_buf;
4378 if (getdirtybuf(&bp, waitfor) == 0) {
4379 if (waitfor == MNT_NOWAIT)
4380 continue;
4381 break;
4382 }
4383 FREE_LOCK(&lk);
4384 if (waitfor == MNT_NOWAIT) {
4385 bawrite(bp);
4386 } else if ((error = BUF_WRITE(bp)) != 0) {
4387 ACQUIRE_LOCK(&lk);
4388 return (error);
4389 }
4390 ACQUIRE_LOCK(&lk);
4391 break;
4392 }
4393 if (adp != NULL)
4394 continue;
4395 /*
4396 * If pass2, we are done, otherwise do pass 2.
4397 */
4398 if (waitfor == MNT_WAIT)
4399 break;
4400 waitfor = MNT_WAIT;
4401 }
4402 /*
4403 * Try freeing inodedep in case all dependencies have been removed.
4404 */
4405 if (inodedep_lookup(fs, ino, 0, &inodedep) != 0)
4406 (void) free_inodedep(inodedep);
4407 return (0);
4408}
4409
4410/*
4411 * Eliminate a pagedep dependency by flushing out all its diradd dependencies.
4412 * Called with splbio blocked.
4413 */
4414static int
4415flush_pagedep_deps(pvp, mp, diraddhdp)
4416 struct vnode *pvp;
4417 struct mount *mp;
4418 struct diraddhd *diraddhdp;
4419{
4420 struct proc *p = CURPROC; /* XXX */
4421 struct inodedep *inodedep;
4422 struct ufsmount *ump;
4423 struct diradd *dap;
4424 struct vnode *vp;
4425 int gotit, error = 0;
4426 struct buf *bp;
4427 ino_t inum;
4428
4429 ump = VFSTOUFS(mp);
4430 while ((dap = LIST_FIRST(diraddhdp)) != NULL) {
4431 /*
4432 * Flush ourselves if this directory entry
4433 * has a MKDIR_PARENT dependency.
4434 */
4435 if (dap->da_state & MKDIR_PARENT) {
4436 FREE_LOCK(&lk);
4437 if ((error = UFS_UPDATE(pvp, 1)) != 0)
4438 break;
4439 ACQUIRE_LOCK(&lk);
4440 /*
4441 * If that cleared dependencies, go on to next.
4442 */
4443 if (dap != LIST_FIRST(diraddhdp))
4444 continue;
4445 if (dap->da_state & MKDIR_PARENT) {
4446 FREE_LOCK(&lk);
4447 panic("flush_pagedep_deps: MKDIR_PARENT");
4448 }
4449 }
4450 /*
4451 * A newly allocated directory must have its "." and
4452 * ".." entries written out before its name can be
4453 * committed in its parent. We do not want or need
4454 * the full semantics of a synchronous VOP_FSYNC as
4455 * that may end up here again, once for each directory
4456 * level in the filesystem. Instead, we push the blocks
4457 * and wait for them to clear. We have to fsync twice
4458 * because the first call may choose to defer blocks
4459 * that still have dependencies, but deferral will
4460 * happen at most once.
4461 */
4462 inum = dap->da_newinum;
4463 if (dap->da_state & MKDIR_BODY) {
4464 FREE_LOCK(&lk);
4465 if ((error = VFS_VGET(mp, inum, &vp)) != 0)
4466 break;
4467 if ((error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)) ||
4468 (error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p))) {
4469 vput(vp);
4470 break;
4471 }
4472 drain_output(vp, 0);
4473 vput(vp);
4474 ACQUIRE_LOCK(&lk);
4475 /*
4476 * If that cleared dependencies, go on to next.
4477 */
4478 if (dap != LIST_FIRST(diraddhdp))
4479 continue;
4480 if (dap->da_state & MKDIR_BODY) {
4481 FREE_LOCK(&lk);
4482 panic("flush_pagedep_deps: MKDIR_BODY");
4483 }
4484 }
4485 /*
4486 * Flush the inode on which the directory entry depends.
4487 * Having accounted for MKDIR_PARENT and MKDIR_BODY above,
4488 * the only remaining dependency is that the updated inode
4489 * count must get pushed to disk. The inode has already
4490 * been pushed into its inode buffer (via VOP_UPDATE) at
4491 * the time of the reference count change. So we need only
4492 * locate that buffer, ensure that there will be no rollback
4493 * caused by a bitmap dependency, then write the inode buffer.
4494 */
4495 if (inodedep_lookup(ump->um_fs, inum, 0, &inodedep) == 0) {
4496 FREE_LOCK(&lk);
4497 panic("flush_pagedep_deps: lost inode");
4498 }
4499 /*
4500 * If the inode still has bitmap dependencies,
4501 * push them to disk.
4502 */
4503 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
4504 gotit = getdirtybuf(&inodedep->id_buf, MNT_WAIT);
4505 FREE_LOCK(&lk);
4506 if (gotit &&
4507 (error = BUF_WRITE(inodedep->id_buf)) != 0)
4508 break;
4509 ACQUIRE_LOCK(&lk);
4510 if (dap != LIST_FIRST(diraddhdp))
4511 continue;
4512 }
4513 /*
4514 * If the inode is still sitting in a buffer waiting
4515 * to be written, push it to disk.
4516 */
4517 FREE_LOCK(&lk);
4518 if ((error = bread(ump->um_devvp,
4519 fsbtodb(ump->um_fs, ino_to_fsba(ump->um_fs, inum)),
4520 (int)ump->um_fs->fs_bsize, NOCRED, &bp)) != 0)
4521 break;
4522 if ((error = BUF_WRITE(bp)) != 0)
4523 break;
4524 ACQUIRE_LOCK(&lk);
4525 /*
4526 * If we have failed to get rid of all the dependencies
4527 * then something is seriously wrong.
4528 */
4529 if (dap == LIST_FIRST(diraddhdp)) {
4530 FREE_LOCK(&lk);
4531 panic("flush_pagedep_deps: flush failed");
4532 }
4533 }
4534 if (error)
4535 ACQUIRE_LOCK(&lk);
4536 return (error);
4537}
4538
4539/*
4540 * A large burst of file addition or deletion activity can drive the
4541 * memory load excessively high. First attempt to slow things down
4542 * using the techniques below. If that fails, this routine requests
4543 * the offending operations to fall back to running synchronously
4544 * until the memory load returns to a reasonable level.
4545 */
4546int
4547softdep_slowdown(vp)
4548 struct vnode *vp;
4549{
4550 int max_softdeps_hard;
4551
4552 max_softdeps_hard = max_softdeps * 11 / 10;
4553 if (num_dirrem < max_softdeps_hard / 2 &&
4554 num_inodedep < max_softdeps_hard)
4555 return (0);
4556 stat_sync_limit_hit += 1;
4557 return (1);
4558}
4559
4560/*
4561 * If memory utilization has gotten too high, deliberately slow things
4562 * down and speed up the I/O processing.
4563 */
4564static int
4565request_cleanup(resource, islocked)
4566 int resource;
4567 int islocked;
4568{
4569 struct proc *p = CURPROC;
4570
4571 /*
4572 * We never hold up the filesystem syncer process.
4573 */
4574 if (p == filesys_syncer)
4575 return (0);
4576 /*
4577 * First check to see if the work list has gotten backlogged.
4578 * If it has, co-opt this process to help clean up two entries.
4579 * Because this process may hold inodes locked, we cannot
4580 * handle any remove requests that might block on a locked
4581 * inode as that could lead to deadlock.
4582 */
4583 if (num_on_worklist > max_softdeps / 10) {
4584 if (islocked)
4585 FREE_LOCK(&lk);
4586 process_worklist_item(NULL, LK_NOWAIT);
4587 process_worklist_item(NULL, LK_NOWAIT);
4588 stat_worklist_push += 2;
4589 if (islocked)
4590 ACQUIRE_LOCK(&lk);
4591 return(1);
4592 }
4593 /*
4594 * Next, we attempt to speed up the syncer process. If that
4595 * is successful, then we allow the process to continue.
4596 */
4597 if (speedup_syncer())
4598 return(0);
4599 /*
4600 * If we are resource constrained on inode dependencies, try
4601 * flushing some dirty inodes. Otherwise, we are constrained
4602 * by file deletions, so try accelerating flushes of directories
4603 * with removal dependencies. We would like to do the cleanup
4604 * here, but we probably hold an inode locked at this point and
4605 * that might deadlock against one that we try to clean. So,
4606 * the best that we can do is request the syncer daemon to do
4607 * the cleanup for us.
4608 */
4609 switch (resource) {
4610
4611 case FLUSH_INODES:
4612 stat_ino_limit_push += 1;
4613 req_clear_inodedeps += 1;
4614 stat_countp = &stat_ino_limit_hit;
4615 break;
4616
4617 case FLUSH_REMOVE:
4618 stat_blk_limit_push += 1;
4619 req_clear_remove += 1;
4620 stat_countp = &stat_blk_limit_hit;
4621 break;
4622
4623 default:
4624 if (islocked)
4625 FREE_LOCK(&lk);
4626 panic("request_cleanup: unknown type");
4627 }
4628 /*
4629 * Hopefully the syncer daemon will catch up and awaken us.
4630 * We wait at most tickdelay before proceeding in any case.
4631 */
4632 if (islocked == 0)
4633 ACQUIRE_LOCK(&lk);
4634 proc_waiting += 1;
4635 if (handle.callout == NULL)
4636 handle = timeout(pause_timer, 0, tickdelay > 2 ? tickdelay : 2);
4637 FREE_LOCK_INTERLOCKED(&lk);
4638 (void) tsleep((caddr_t)&proc_waiting, PPAUSE, "softupdate", 0);
4639 ACQUIRE_LOCK_INTERLOCKED(&lk);
4640 proc_waiting -= 1;
4641 if (islocked == 0)
4642 FREE_LOCK(&lk);
4643 return (1);
4644}
4645
4646/*
4647 * Awaken processes pausing in request_cleanup and clear proc_waiting
4648 * to indicate that there is no longer a timer running.
4649 */
4650void
4651pause_timer(arg)
4652 void *arg;
4653{
4654
4655 *stat_countp += 1;
4656 wakeup_one(&proc_waiting);
4657 if (proc_waiting > 0)
4658 handle = timeout(pause_timer, 0, tickdelay > 2 ? tickdelay : 2);
4659 else
4660 handle.callout = NULL;
4661}
4662
4663/*
4664 * Flush out a directory with at least one removal dependency in an effort to
4665 * reduce the number of dirrem, freefile, and freeblks dependency structures.
4666 */
4667static void
4668clear_remove(p)
4669 struct proc *p;
4670{
4671 struct pagedep_hashhead *pagedephd;
4672 struct pagedep *pagedep;
4673 static int next = 0;
4674 struct mount *mp;
4675 struct vnode *vp;
4676 int error, cnt;
4677 ino_t ino;
4678
4679 ACQUIRE_LOCK(&lk);
4680 for (cnt = 0; cnt < pagedep_hash; cnt++) {
4681 pagedephd = &pagedep_hashtbl[next++];
4682 if (next >= pagedep_hash)
4683 next = 0;
4684 LIST_FOREACH(pagedep, pagedephd, pd_hash) {
4685 if (LIST_FIRST(&pagedep->pd_dirremhd) == NULL)
4686 continue;
4687 mp = pagedep->pd_mnt;
4688 ino = pagedep->pd_ino;
4689 FREE_LOCK(&lk);
4690 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0)
4691 continue;
4692 if ((error = VFS_VGET(mp, ino, &vp)) != 0) {
4693 softdep_error("clear_remove: vget", error);
4694 vn_finished_write(mp);
4695 return;
4696 }
4697 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)))
4698 softdep_error("clear_remove: fsync", error);
4699 drain_output(vp, 0);
4700 vput(vp);
4701 vn_finished_write(mp);
4702 return;
4703 }
4704 }
4705 FREE_LOCK(&lk);
4706}
4707
4708/*
4709 * Clear out a block of dirty inodes in an effort to reduce
4710 * the number of inodedep dependency structures.
4711 */
4712static void
4713clear_inodedeps(p)
4714 struct proc *p;
4715{
4716 struct inodedep_hashhead *inodedephd;
4717 struct inodedep *inodedep;
4718 static int next = 0;
4719 struct mount *mp;
4720 struct vnode *vp;
4721 struct fs *fs;
4722 int error, cnt;
4723 ino_t firstino, lastino, ino;
4724
4725 ACQUIRE_LOCK(&lk);
4726 /*
4727 * Pick a random inode dependency to be cleared.
4728 * We will then gather up all the inodes in its block
4729 * that have dependencies and flush them out.
4730 */
4731 for (cnt = 0; cnt < inodedep_hash; cnt++) {
4732 inodedephd = &inodedep_hashtbl[next++];
4733 if (next >= inodedep_hash)
4734 next = 0;
4735 if ((inodedep = LIST_FIRST(inodedephd)) != NULL)
4736 break;
4737 }
4738 if (inodedep == NULL)
4739 return;
4740 /*
4741 * Ugly code to find mount point given pointer to superblock.
4742 */
4743 fs = inodedep->id_fs;
4744 TAILQ_FOREACH(mp, &mountlist, mnt_list)
4745 if ((mp->mnt_flag & MNT_SOFTDEP) && fs == VFSTOUFS(mp)->um_fs)
4746 break;
4747 /*
4748 * Find the last inode in the block with dependencies.
4749 */
4750 firstino = inodedep->id_ino & ~(INOPB(fs) - 1);
4751 for (lastino = firstino + INOPB(fs) - 1; lastino > firstino; lastino--)
4752 if (inodedep_lookup(fs, lastino, 0, &inodedep) != 0)
4753 break;
4754 /*
4755 * Asynchronously push all but the last inode with dependencies.
4756 * Synchronously push the last inode with dependencies to ensure
4757 * that the inode block gets written to free up the inodedeps.
4758 */
4759 for (ino = firstino; ino <= lastino; ino++) {
4760 if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
4761 continue;
4762 FREE_LOCK(&lk);
4763 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0)
4764 continue;
4765 if ((error = VFS_VGET(mp, ino, &vp)) != 0) {
4766 softdep_error("clear_inodedeps: vget", error);
4767 vn_finished_write(mp);
4768 return;
4769 }
4770 if (ino == lastino) {
4771 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p)))
4772 softdep_error("clear_inodedeps: fsync1", error);
4773 } else {
4774 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)))
4775 softdep_error("clear_inodedeps: fsync2", error);
4776 drain_output(vp, 0);
4777 }
4778 vput(vp);
4779 vn_finished_write(mp);
4780 ACQUIRE_LOCK(&lk);
4781 }
4782 FREE_LOCK(&lk);
4783}
4784
4785/*
4786 * Function to determine if the buffer has outstanding dependencies
4787 * that will cause a roll-back if the buffer is written. If wantcount
4788 * is set, return number of dependencies, otherwise just yes or no.
4789 */
4790static int
4791softdep_count_dependencies(bp, wantcount)
4792 struct buf *bp;
4793 int wantcount;
4794{
4795 struct worklist *wk;
4796 struct inodedep *inodedep;
4797 struct indirdep *indirdep;
4798 struct allocindir *aip;
4799 struct pagedep *pagedep;
4800 struct diradd *dap;
4801 int i, retval;
4802
4803 retval = 0;
4804 ACQUIRE_LOCK(&lk);
4805 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
4806 switch (wk->wk_type) {
4807
4808 case D_INODEDEP:
4809 inodedep = WK_INODEDEP(wk);
4810 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
4811 /* bitmap allocation dependency */
4812 retval += 1;
4813 if (!wantcount)
4814 goto out;
4815 }
4816 if (TAILQ_FIRST(&inodedep->id_inoupdt)) {
4817 /* direct block pointer dependency */
4818 retval += 1;
4819 if (!wantcount)
4820 goto out;
4821 }
4822 continue;
4823
4824 case D_INDIRDEP:
4825 indirdep = WK_INDIRDEP(wk);
4826
4827 LIST_FOREACH(aip, &indirdep->ir_deplisthd, ai_next) {
4828 /* indirect block pointer dependency */
4829 retval += 1;
4830 if (!wantcount)
4831 goto out;
4832 }
4833 continue;
4834
4835 case D_PAGEDEP:
4836 pagedep = WK_PAGEDEP(wk);
4837 for (i = 0; i < DAHASHSZ; i++) {
4838
4839 LIST_FOREACH(dap, &pagedep->pd_diraddhd[i], da_pdlist) {
4840 /* directory entry dependency */
4841 retval += 1;
4842 if (!wantcount)
4843 goto out;
4844 }
4845 }
4846 continue;
4847
4848 case D_BMSAFEMAP:
4849 case D_ALLOCDIRECT:
4850 case D_ALLOCINDIR:
4851 case D_MKDIR:
4852 /* never a dependency on these blocks */
4853 continue;
4854
4855 default:
4856 FREE_LOCK(&lk);
4857 panic("softdep_check_for_rollback: Unexpected type %s",
4858 TYPENAME(wk->wk_type));
4859 /* NOTREACHED */
4860 }
4861 }
4862out:
4863 FREE_LOCK(&lk);
4864 return retval;
4865}
4866
4867/*
4868 * Acquire exclusive access to a buffer.
4869 * Must be called with splbio blocked.
4870 * Return 1 if buffer was acquired.
4871 */
4872static int
4873getdirtybuf(bpp, waitfor)
4874 struct buf **bpp;
4875 int waitfor;
4876{
4877 struct buf *bp;
4878
4879 for (;;) {
4880 if ((bp = *bpp) == NULL)
4881 return (0);
4882 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT) == 0) {
4883 if ((bp->b_xflags & BX_BKGRDINPROG) == 0)
4884 break;
4885 BUF_UNLOCK(bp);
4886 if (waitfor != MNT_WAIT)
4887 return (0);
4888 bp->b_xflags |= BX_BKGRDWAIT;
4889 FREE_LOCK_INTERLOCKED(&lk);
4890 tsleep(&bp->b_xflags, PRIBIO, "getbuf", 0);
4891 ACQUIRE_LOCK_INTERLOCKED(&lk);
4892 continue;
4893 }
4894 if (waitfor != MNT_WAIT)
4895 return (0);
4896 FREE_LOCK_INTERLOCKED(&lk);
4897 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL) != ENOLCK)
4898 panic("getdirtybuf: inconsistent lock");
4899 ACQUIRE_LOCK_INTERLOCKED(&lk);
4900 }
4901 if ((bp->b_flags & B_DELWRI) == 0) {
4902 BUF_UNLOCK(bp);
4903 return (0);
4904 }
4905 bremfree(bp);
4906 return (1);
4907}
4908
4909/*
4910 * Wait for pending output on a vnode to complete.
4911 * Must be called with vnode locked.
4912 */
4913static void
4914drain_output(vp, islocked)
4915 struct vnode *vp;
4916 int islocked;
4917{
4918
4919 if (!islocked)
4920 ACQUIRE_LOCK(&lk);
4921 while (vp->v_numoutput) {
4922 vp->v_flag |= VBWAIT;
4923 FREE_LOCK_INTERLOCKED(&lk);
4924 tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "drainvp", 0);
4925 ACQUIRE_LOCK_INTERLOCKED(&lk);
4926 }
4927 if (!islocked)
4928 FREE_LOCK(&lk);
4929}
4930
4931/*
4932 * Called whenever a buffer that is being invalidated or reallocated
4933 * contains dependencies. This should only happen if an I/O error has
4934 * occurred. The routine is called with the buffer locked.
4935 */
4936static void
4937softdep_deallocate_dependencies(bp)
4938 struct buf *bp;
4939{
4940
4941 if ((bp->b_ioflags & BIO_ERROR) == 0)
4942 panic("softdep_deallocate_dependencies: dangling deps");
4943 softdep_error(bp->b_vp->v_mount->mnt_stat.f_mntonname, bp->b_error);
4944 panic("softdep_deallocate_dependencies: unrecovered I/O error");
4945}
4946
4947/*
4948 * Function to handle asynchronous write errors in the filesystem.
4949 */
4950void
4951softdep_error(func, error)
4952 char *func;
4953 int error;
4954{
4955
4956 /* XXX should do something better! */
4957 printf("%s: got error %d while accessing filesystem\n", func, error);
4958}
| 3839 FREE_LOCK(&lk);
3840}
3841
3842/*
3843 * This routine is called just before the "in-core" inode
3844 * information is to be copied to the in-memory inode block.
3845 * Recall that an inode block contains several inodes. If
3846 * the force flag is set, then the dependencies will be
3847 * cleared so that the update can always be made. Note that
3848 * the buffer is locked when this routine is called, so we
3849 * will never be in the middle of writing the inode block
3850 * to disk.
3851 */
3852void
3853softdep_update_inodeblock(ip, bp, waitfor)
3854 struct inode *ip; /* the "in_core" copy of the inode */
3855 struct buf *bp; /* the buffer containing the inode block */
3856 int waitfor; /* nonzero => update must be allowed */
3857{
3858 struct inodedep *inodedep;
3859 struct worklist *wk;
3860 int error, gotit;
3861
3862 /*
3863 * If the effective link count is not equal to the actual link
3864 * count, then we must track the difference in an inodedep while
3865 * the inode is (potentially) tossed out of the cache. Otherwise,
3866 * if there is no existing inodedep, then there are no dependencies
3867 * to track.
3868 */
3869 ACQUIRE_LOCK(&lk);
3870 if (inodedep_lookup(ip->i_fs, ip->i_number, 0, &inodedep) == 0) {
3871 FREE_LOCK(&lk);
3872 if (ip->i_effnlink != ip->i_nlink)
3873 panic("softdep_update_inodeblock: bad link count");
3874 return;
3875 }
3876 if (inodedep->id_nlinkdelta != ip->i_nlink - ip->i_effnlink) {
3877 FREE_LOCK(&lk);
3878 panic("softdep_update_inodeblock: bad delta");
3879 }
3880 /*
3881 * Changes have been initiated. Anything depending on these
3882 * changes cannot occur until this inode has been written.
3883 */
3884 inodedep->id_state &= ~COMPLETE;
3885 if ((inodedep->id_state & ONWORKLIST) == 0)
3886 WORKLIST_INSERT(&bp->b_dep, &inodedep->id_list);
3887 /*
3888 * Any new dependencies associated with the incore inode must
3889 * now be moved to the list associated with the buffer holding
3890 * the in-memory copy of the inode. Once merged process any
3891 * allocdirects that are completed by the merger.
3892 */
3893 merge_inode_lists(inodedep);
3894 if (TAILQ_FIRST(&inodedep->id_inoupdt) != NULL)
3895 handle_allocdirect_partdone(TAILQ_FIRST(&inodedep->id_inoupdt));
3896 /*
3897 * Now that the inode has been pushed into the buffer, the
3898 * operations dependent on the inode being written to disk
3899 * can be moved to the id_bufwait so that they will be
3900 * processed when the buffer I/O completes.
3901 */
3902 while ((wk = LIST_FIRST(&inodedep->id_inowait)) != NULL) {
3903 WORKLIST_REMOVE(wk);
3904 WORKLIST_INSERT(&inodedep->id_bufwait, wk);
3905 }
3906 /*
3907 * Newly allocated inodes cannot be written until the bitmap
3908 * that allocates them have been written (indicated by
3909 * DEPCOMPLETE being set in id_state). If we are doing a
3910 * forced sync (e.g., an fsync on a file), we force the bitmap
3911 * to be written so that the update can be done.
3912 */
3913 if ((inodedep->id_state & DEPCOMPLETE) != 0 || waitfor == 0) {
3914 FREE_LOCK(&lk);
3915 return;
3916 }
3917 gotit = getdirtybuf(&inodedep->id_buf, MNT_WAIT);
3918 FREE_LOCK(&lk);
3919 if (gotit &&
3920 (error = BUF_WRITE(inodedep->id_buf)) != 0)
3921 softdep_error("softdep_update_inodeblock: bwrite", error);
3922 if ((inodedep->id_state & DEPCOMPLETE) == 0)
3923 panic("softdep_update_inodeblock: update failed");
3924}
3925
3926/*
3927 * Merge the new inode dependency list (id_newinoupdt) into the old
3928 * inode dependency list (id_inoupdt). This routine must be called
3929 * with splbio interrupts blocked.
3930 */
3931static void
3932merge_inode_lists(inodedep)
3933 struct inodedep *inodedep;
3934{
3935 struct allocdirect *listadp, *newadp;
3936
3937 newadp = TAILQ_FIRST(&inodedep->id_newinoupdt);
3938 for (listadp = TAILQ_FIRST(&inodedep->id_inoupdt); listadp && newadp;) {
3939 if (listadp->ad_lbn < newadp->ad_lbn) {
3940 listadp = TAILQ_NEXT(listadp, ad_next);
3941 continue;
3942 }
3943 TAILQ_REMOVE(&inodedep->id_newinoupdt, newadp, ad_next);
3944 TAILQ_INSERT_BEFORE(listadp, newadp, ad_next);
3945 if (listadp->ad_lbn == newadp->ad_lbn) {
3946 allocdirect_merge(&inodedep->id_inoupdt, newadp,
3947 listadp);
3948 listadp = newadp;
3949 }
3950 newadp = TAILQ_FIRST(&inodedep->id_newinoupdt);
3951 }
3952 while ((newadp = TAILQ_FIRST(&inodedep->id_newinoupdt)) != NULL) {
3953 TAILQ_REMOVE(&inodedep->id_newinoupdt, newadp, ad_next);
3954 TAILQ_INSERT_TAIL(&inodedep->id_inoupdt, newadp, ad_next);
3955 }
3956}
3957
3958/*
3959 * If we are doing an fsync, then we must ensure that any directory
3960 * entries for the inode have been written after the inode gets to disk.
3961 */
3962int
3963softdep_fsync(vp)
3964 struct vnode *vp; /* the "in_core" copy of the inode */
3965{
3966 struct inodedep *inodedep;
3967 struct pagedep *pagedep;
3968 struct worklist *wk;
3969 struct diradd *dap;
3970 struct mount *mnt;
3971 struct vnode *pvp;
3972 struct inode *ip;
3973 struct buf *bp;
3974 struct fs *fs;
3975 struct proc *p = CURPROC; /* XXX */
3976 int error, flushparent;
3977 ino_t parentino;
3978 ufs_lbn_t lbn;
3979
3980 ip = VTOI(vp);
3981 fs = ip->i_fs;
3982 ACQUIRE_LOCK(&lk);
3983 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0) {
3984 FREE_LOCK(&lk);
3985 return (0);
3986 }
3987 if (LIST_FIRST(&inodedep->id_inowait) != NULL ||
3988 LIST_FIRST(&inodedep->id_bufwait) != NULL ||
3989 TAILQ_FIRST(&inodedep->id_inoupdt) != NULL ||
3990 TAILQ_FIRST(&inodedep->id_newinoupdt) != NULL) {
3991 FREE_LOCK(&lk);
3992 panic("softdep_fsync: pending ops");
3993 }
3994 for (error = 0, flushparent = 0; ; ) {
3995 if ((wk = LIST_FIRST(&inodedep->id_pendinghd)) == NULL)
3996 break;
3997 if (wk->wk_type != D_DIRADD) {
3998 FREE_LOCK(&lk);
3999 panic("softdep_fsync: Unexpected type %s",
4000 TYPENAME(wk->wk_type));
4001 }
4002 dap = WK_DIRADD(wk);
4003 /*
4004 * Flush our parent if this directory entry
4005 * has a MKDIR_PARENT dependency.
4006 */
4007 if (dap->da_state & DIRCHG)
4008 pagedep = dap->da_previous->dm_pagedep;
4009 else
4010 pagedep = dap->da_pagedep;
4011 mnt = pagedep->pd_mnt;
4012 parentino = pagedep->pd_ino;
4013 lbn = pagedep->pd_lbn;
4014 if ((dap->da_state & (MKDIR_BODY | COMPLETE)) != COMPLETE) {
4015 FREE_LOCK(&lk);
4016 panic("softdep_fsync: dirty");
4017 }
4018 flushparent = dap->da_state & MKDIR_PARENT;
4019 /*
4020 * If we are being fsync'ed as part of vgone'ing this vnode,
4021 * then we will not be able to release and recover the
4022 * vnode below, so we just have to give up on writing its
4023 * directory entry out. It will eventually be written, just
4024 * not now, but then the user was not asking to have it
4025 * written, so we are not breaking any promises.
4026 */
4027 if (vp->v_flag & VXLOCK)
4028 break;
4029 /*
4030 * We prevent deadlock by always fetching inodes from the
4031 * root, moving down the directory tree. Thus, when fetching
4032 * our parent directory, we must unlock ourselves before
4033 * requesting the lock on our parent. See the comment in
4034 * ufs_lookup for details on possible races.
4035 */
4036 FREE_LOCK(&lk);
4037 VOP_UNLOCK(vp, 0, p);
4038 error = VFS_VGET(mnt, parentino, &pvp);
4039 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
4040 if (error != 0)
4041 return (error);
4042 if (flushparent) {
4043 if ((error = UFS_UPDATE(pvp, 1)) != 0) {
4044 vput(pvp);
4045 return (error);
4046 }
4047 }
4048 /*
4049 * Flush directory page containing the inode's name.
4050 */
4051 error = bread(pvp, lbn, blksize(fs, VTOI(pvp), lbn), p->p_ucred,
4052 &bp);
4053 if (error == 0)
4054 error = BUF_WRITE(bp);
4055 vput(pvp);
4056 if (error != 0)
4057 return (error);
4058 ACQUIRE_LOCK(&lk);
4059 if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) == 0)
4060 break;
4061 }
4062 FREE_LOCK(&lk);
4063 return (0);
4064}
4065
4066/*
4067 * Flush all the dirty bitmaps associated with the block device
4068 * before flushing the rest of the dirty blocks so as to reduce
4069 * the number of dependencies that will have to be rolled back.
4070 */
4071void
4072softdep_fsync_mountdev(vp)
4073 struct vnode *vp;
4074{
4075 struct buf *bp, *nbp;
4076 struct worklist *wk;
4077
4078 if (!vn_isdisk(vp, NULL))
4079 panic("softdep_fsync_mountdev: vnode not a disk");
4080 ACQUIRE_LOCK(&lk);
4081 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
4082 nbp = TAILQ_NEXT(bp, b_vnbufs);
4083 /*
4084 * If it is already scheduled, skip to the next buffer.
4085 */
4086 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
4087 continue;
4088 if ((bp->b_flags & B_DELWRI) == 0) {
4089 FREE_LOCK(&lk);
4090 panic("softdep_fsync_mountdev: not dirty");
4091 }
4092 /*
4093 * We are only interested in bitmaps with outstanding
4094 * dependencies.
4095 */
4096 if ((wk = LIST_FIRST(&bp->b_dep)) == NULL ||
4097 wk->wk_type != D_BMSAFEMAP ||
4098 (bp->b_xflags & BX_BKGRDINPROG)) {
4099 BUF_UNLOCK(bp);
4100 continue;
4101 }
4102 bremfree(bp);
4103 FREE_LOCK(&lk);
4104 (void) bawrite(bp);
4105 ACQUIRE_LOCK(&lk);
4106 /*
4107 * Since we may have slept during the I/O, we need
4108 * to start from a known point.
4109 */
4110 nbp = TAILQ_FIRST(&vp->v_dirtyblkhd);
4111 }
4112 drain_output(vp, 1);
4113 FREE_LOCK(&lk);
4114}
4115
4116/*
4117 * This routine is called when we are trying to synchronously flush a
4118 * file. This routine must eliminate any filesystem metadata dependencies
4119 * so that the syncing routine can succeed by pushing the dirty blocks
4120 * associated with the file. If any I/O errors occur, they are returned.
4121 */
4122int
4123softdep_sync_metadata(ap)
4124 struct vop_fsync_args /* {
4125 struct vnode *a_vp;
4126 struct ucred *a_cred;
4127 int a_waitfor;
4128 struct proc *a_p;
4129 } */ *ap;
4130{
4131 struct vnode *vp = ap->a_vp;
4132 struct pagedep *pagedep;
4133 struct allocdirect *adp;
4134 struct allocindir *aip;
4135 struct buf *bp, *nbp;
4136 struct worklist *wk;
4137 int i, error, waitfor;
4138
4139 /*
4140 * Check whether this vnode is involved in a filesystem
4141 * that is doing soft dependency processing.
4142 */
4143 if (!vn_isdisk(vp, NULL)) {
4144 if (!DOINGSOFTDEP(vp))
4145 return (0);
4146 } else
4147 if (vp->v_rdev->si_mountpoint == NULL ||
4148 (vp->v_rdev->si_mountpoint->mnt_flag & MNT_SOFTDEP) == 0)
4149 return (0);
4150 /*
4151 * Ensure that any direct block dependencies have been cleared.
4152 */
4153 ACQUIRE_LOCK(&lk);
4154 if ((error = flush_inodedep_deps(VTOI(vp)->i_fs, VTOI(vp)->i_number))) {
4155 FREE_LOCK(&lk);
4156 return (error);
4157 }
4158 /*
4159 * For most files, the only metadata dependencies are the
4160 * cylinder group maps that allocate their inode or blocks.
4161 * The block allocation dependencies can be found by traversing
4162 * the dependency lists for any buffers that remain on their
4163 * dirty buffer list. The inode allocation dependency will
4164 * be resolved when the inode is updated with MNT_WAIT.
4165 * This work is done in two passes. The first pass grabs most
4166 * of the buffers and begins asynchronously writing them. The
4167 * only way to wait for these asynchronous writes is to sleep
4168 * on the filesystem vnode which may stay busy for a long time
4169 * if the filesystem is active. So, instead, we make a second
4170 * pass over the dependencies blocking on each write. In the
4171 * usual case we will be blocking against a write that we
4172 * initiated, so when it is done the dependency will have been
4173 * resolved. Thus the second pass is expected to end quickly.
4174 */
4175 waitfor = MNT_NOWAIT;
4176top:
4177 if (getdirtybuf(&TAILQ_FIRST(&vp->v_dirtyblkhd), MNT_WAIT) == 0) {
4178 FREE_LOCK(&lk);
4179 return (0);
4180 }
4181 bp = TAILQ_FIRST(&vp->v_dirtyblkhd);
4182 /* While syncing snapshots, we must allow recursive lookups */
4183 bp->b_lock.lk_flags |= LK_CANRECURSE;
4184loop:
4185 /*
4186 * As we hold the buffer locked, none of its dependencies
4187 * will disappear.
4188 */
4189 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
4190 switch (wk->wk_type) {
4191
4192 case D_ALLOCDIRECT:
4193 adp = WK_ALLOCDIRECT(wk);
4194 if (adp->ad_state & DEPCOMPLETE)
4195 continue;
4196 nbp = adp->ad_buf;
4197 if (getdirtybuf(&nbp, waitfor) == 0)
4198 continue;
4199 FREE_LOCK(&lk);
4200 if (waitfor == MNT_NOWAIT) {
4201 bawrite(nbp);
4202 } else if ((error = BUF_WRITE(nbp)) != 0) {
4203 break;
4204 }
4205 ACQUIRE_LOCK(&lk);
4206 continue;
4207
4208 case D_ALLOCINDIR:
4209 aip = WK_ALLOCINDIR(wk);
4210 if (aip->ai_state & DEPCOMPLETE)
4211 continue;
4212 nbp = aip->ai_buf;
4213 if (getdirtybuf(&nbp, waitfor) == 0)
4214 continue;
4215 FREE_LOCK(&lk);
4216 if (waitfor == MNT_NOWAIT) {
4217 bawrite(nbp);
4218 } else if ((error = BUF_WRITE(nbp)) != 0) {
4219 break;
4220 }
4221 ACQUIRE_LOCK(&lk);
4222 continue;
4223
4224 case D_INDIRDEP:
4225 restart:
4226
4227 LIST_FOREACH(aip, &WK_INDIRDEP(wk)->ir_deplisthd, ai_next) {
4228 if (aip->ai_state & DEPCOMPLETE)
4229 continue;
4230 nbp = aip->ai_buf;
4231 if (getdirtybuf(&nbp, MNT_WAIT) == 0)
4232 goto restart;
4233 FREE_LOCK(&lk);
4234 if ((error = BUF_WRITE(nbp)) != 0) {
4235 break;
4236 }
4237 ACQUIRE_LOCK(&lk);
4238 goto restart;
4239 }
4240 continue;
4241
4242 case D_INODEDEP:
4243 if ((error = flush_inodedep_deps(WK_INODEDEP(wk)->id_fs,
4244 WK_INODEDEP(wk)->id_ino)) != 0) {
4245 FREE_LOCK(&lk);
4246 break;
4247 }
4248 continue;
4249
4250 case D_PAGEDEP:
4251 /*
4252 * We are trying to sync a directory that may
4253 * have dependencies on both its own metadata
4254 * and/or dependencies on the inodes of any
4255 * recently allocated files. We walk its diradd
4256 * lists pushing out the associated inode.
4257 */
4258 pagedep = WK_PAGEDEP(wk);
4259 for (i = 0; i < DAHASHSZ; i++) {
4260 if (LIST_FIRST(&pagedep->pd_diraddhd[i]) == 0)
4261 continue;
4262 if ((error =
4263 flush_pagedep_deps(vp, pagedep->pd_mnt,
4264 &pagedep->pd_diraddhd[i]))) {
4265 FREE_LOCK(&lk);
4266 break;
4267 }
4268 }
4269 continue;
4270
4271 case D_MKDIR:
4272 /*
4273 * This case should never happen if the vnode has
4274 * been properly sync'ed. However, if this function
4275 * is used at a place where the vnode has not yet
4276 * been sync'ed, this dependency can show up. So,
4277 * rather than panic, just flush it.
4278 */
4279 nbp = WK_MKDIR(wk)->md_buf;
4280 if (getdirtybuf(&nbp, waitfor) == 0)
4281 continue;
4282 FREE_LOCK(&lk);
4283 if (waitfor == MNT_NOWAIT) {
4284 bawrite(nbp);
4285 } else if ((error = BUF_WRITE(nbp)) != 0) {
4286 break;
4287 }
4288 ACQUIRE_LOCK(&lk);
4289 continue;
4290
4291 case D_BMSAFEMAP:
4292 /*
4293 * This case should never happen if the vnode has
4294 * been properly sync'ed. However, if this function
4295 * is used at a place where the vnode has not yet
4296 * been sync'ed, this dependency can show up. So,
4297 * rather than panic, just flush it.
4298 */
4299 nbp = WK_BMSAFEMAP(wk)->sm_buf;
4300 if (getdirtybuf(&nbp, waitfor) == 0)
4301 continue;
4302 FREE_LOCK(&lk);
4303 if (waitfor == MNT_NOWAIT) {
4304 bawrite(nbp);
4305 } else if ((error = BUF_WRITE(nbp)) != 0) {
4306 break;
4307 }
4308 ACQUIRE_LOCK(&lk);
4309 continue;
4310
4311 default:
4312 FREE_LOCK(&lk);
4313 panic("softdep_sync_metadata: Unknown type %s",
4314 TYPENAME(wk->wk_type));
4315 /* NOTREACHED */
4316 }
4317 /* We reach here only in error and unlocked */
4318 if (error == 0)
4319 panic("softdep_sync_metadata: zero error");
4320 bp->b_lock.lk_flags &= ~LK_CANRECURSE;
4321 bawrite(bp);
4322 return (error);
4323 }
4324 (void) getdirtybuf(&TAILQ_NEXT(bp, b_vnbufs), MNT_WAIT);
4325 nbp = TAILQ_NEXT(bp, b_vnbufs);
4326 FREE_LOCK(&lk);
4327 bp->b_lock.lk_flags &= ~LK_CANRECURSE;
4328 bawrite(bp);
4329 ACQUIRE_LOCK(&lk);
4330 if (nbp != NULL) {
4331 bp = nbp;
4332 goto loop;
4333 }
4334 /*
4335 * We must wait for any I/O in progress to finish so that
4336 * all potential buffers on the dirty list will be visible.
4337 * Once they are all there, proceed with the second pass
4338 * which will wait for the I/O as per above.
4339 */
4340 drain_output(vp, 1);
4341 /*
4342 * The brief unlock is to allow any pent up dependency
4343 * processing to be done.
4344 */
4345 if (waitfor == MNT_NOWAIT) {
4346 waitfor = MNT_WAIT;
4347 FREE_LOCK(&lk);
4348 ACQUIRE_LOCK(&lk);
4349 goto top;
4350 }
4351
4352 /*
4353 * If we have managed to get rid of all the dirty buffers,
4354 * then we are done. For certain directories and block
4355 * devices, we may need to do further work.
4356 */
4357 if (TAILQ_FIRST(&vp->v_dirtyblkhd) == NULL) {
4358 FREE_LOCK(&lk);
4359 return (0);
4360 }
4361
4362 FREE_LOCK(&lk);
4363 /*
4364 * If we are trying to sync a block device, some of its buffers may
4365 * contain metadata that cannot be written until the contents of some
4366 * partially written files have been written to disk. The only easy
4367 * way to accomplish this is to sync the entire filesystem (luckily
4368 * this happens rarely).
4369 */
4370 if (vn_isdisk(vp, NULL) &&
4371 vp->v_rdev->si_mountpoint && !VOP_ISLOCKED(vp, NULL) &&
4372 (error = VFS_SYNC(vp->v_rdev->si_mountpoint, MNT_WAIT, ap->a_cred,
4373 ap->a_p)) != 0)
4374 return (error);
4375 return (0);
4376}
4377
4378/*
4379 * Flush the dependencies associated with an inodedep.
4380 * Called with splbio blocked.
4381 */
4382static int
4383flush_inodedep_deps(fs, ino)
4384 struct fs *fs;
4385 ino_t ino;
4386{
4387 struct inodedep *inodedep;
4388 struct allocdirect *adp;
4389 int error, waitfor;
4390 struct buf *bp;
4391
4392 /*
4393 * This work is done in two passes. The first pass grabs most
4394 * of the buffers and begins asynchronously writing them. The
4395 * only way to wait for these asynchronous writes is to sleep
4396 * on the filesystem vnode which may stay busy for a long time
4397 * if the filesystem is active. So, instead, we make a second
4398 * pass over the dependencies blocking on each write. In the
4399 * usual case we will be blocking against a write that we
4400 * initiated, so when it is done the dependency will have been
4401 * resolved. Thus the second pass is expected to end quickly.
4402 * We give a brief window at the top of the loop to allow
4403 * any pending I/O to complete.
4404 */
4405 for (waitfor = MNT_NOWAIT; ; ) {
4406 FREE_LOCK(&lk);
4407 ACQUIRE_LOCK(&lk);
4408 if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
4409 return (0);
4410 TAILQ_FOREACH(adp, &inodedep->id_inoupdt, ad_next) {
4411 if (adp->ad_state & DEPCOMPLETE)
4412 continue;
4413 bp = adp->ad_buf;
4414 if (getdirtybuf(&bp, waitfor) == 0) {
4415 if (waitfor == MNT_NOWAIT)
4416 continue;
4417 break;
4418 }
4419 FREE_LOCK(&lk);
4420 if (waitfor == MNT_NOWAIT) {
4421 bawrite(bp);
4422 } else if ((error = BUF_WRITE(bp)) != 0) {
4423 ACQUIRE_LOCK(&lk);
4424 return (error);
4425 }
4426 ACQUIRE_LOCK(&lk);
4427 break;
4428 }
4429 if (adp != NULL)
4430 continue;
4431 TAILQ_FOREACH(adp, &inodedep->id_newinoupdt, ad_next) {
4432 if (adp->ad_state & DEPCOMPLETE)
4433 continue;
4434 bp = adp->ad_buf;
4435 if (getdirtybuf(&bp, waitfor) == 0) {
4436 if (waitfor == MNT_NOWAIT)
4437 continue;
4438 break;
4439 }
4440 FREE_LOCK(&lk);
4441 if (waitfor == MNT_NOWAIT) {
4442 bawrite(bp);
4443 } else if ((error = BUF_WRITE(bp)) != 0) {
4444 ACQUIRE_LOCK(&lk);
4445 return (error);
4446 }
4447 ACQUIRE_LOCK(&lk);
4448 break;
4449 }
4450 if (adp != NULL)
4451 continue;
4452 /*
4453 * If pass2, we are done, otherwise do pass 2.
4454 */
4455 if (waitfor == MNT_WAIT)
4456 break;
4457 waitfor = MNT_WAIT;
4458 }
4459 /*
4460 * Try freeing inodedep in case all dependencies have been removed.
4461 */
4462 if (inodedep_lookup(fs, ino, 0, &inodedep) != 0)
4463 (void) free_inodedep(inodedep);
4464 return (0);
4465}
4466
4467/*
4468 * Eliminate a pagedep dependency by flushing out all its diradd dependencies.
4469 * Called with splbio blocked.
4470 */
4471static int
4472flush_pagedep_deps(pvp, mp, diraddhdp)
4473 struct vnode *pvp;
4474 struct mount *mp;
4475 struct diraddhd *diraddhdp;
4476{
4477 struct proc *p = CURPROC; /* XXX */
4478 struct inodedep *inodedep;
4479 struct ufsmount *ump;
4480 struct diradd *dap;
4481 struct vnode *vp;
4482 int gotit, error = 0;
4483 struct buf *bp;
4484 ino_t inum;
4485
4486 ump = VFSTOUFS(mp);
4487 while ((dap = LIST_FIRST(diraddhdp)) != NULL) {
4488 /*
4489 * Flush ourselves if this directory entry
4490 * has a MKDIR_PARENT dependency.
4491 */
4492 if (dap->da_state & MKDIR_PARENT) {
4493 FREE_LOCK(&lk);
4494 if ((error = UFS_UPDATE(pvp, 1)) != 0)
4495 break;
4496 ACQUIRE_LOCK(&lk);
4497 /*
4498 * If that cleared dependencies, go on to next.
4499 */
4500 if (dap != LIST_FIRST(diraddhdp))
4501 continue;
4502 if (dap->da_state & MKDIR_PARENT) {
4503 FREE_LOCK(&lk);
4504 panic("flush_pagedep_deps: MKDIR_PARENT");
4505 }
4506 }
4507 /*
4508 * A newly allocated directory must have its "." and
4509 * ".." entries written out before its name can be
4510 * committed in its parent. We do not want or need
4511 * the full semantics of a synchronous VOP_FSYNC as
4512 * that may end up here again, once for each directory
4513 * level in the filesystem. Instead, we push the blocks
4514 * and wait for them to clear. We have to fsync twice
4515 * because the first call may choose to defer blocks
4516 * that still have dependencies, but deferral will
4517 * happen at most once.
4518 */
4519 inum = dap->da_newinum;
4520 if (dap->da_state & MKDIR_BODY) {
4521 FREE_LOCK(&lk);
4522 if ((error = VFS_VGET(mp, inum, &vp)) != 0)
4523 break;
4524 if ((error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)) ||
4525 (error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p))) {
4526 vput(vp);
4527 break;
4528 }
4529 drain_output(vp, 0);
4530 vput(vp);
4531 ACQUIRE_LOCK(&lk);
4532 /*
4533 * If that cleared dependencies, go on to next.
4534 */
4535 if (dap != LIST_FIRST(diraddhdp))
4536 continue;
4537 if (dap->da_state & MKDIR_BODY) {
4538 FREE_LOCK(&lk);
4539 panic("flush_pagedep_deps: MKDIR_BODY");
4540 }
4541 }
4542 /*
4543 * Flush the inode on which the directory entry depends.
4544 * Having accounted for MKDIR_PARENT and MKDIR_BODY above,
4545 * the only remaining dependency is that the updated inode
4546 * count must get pushed to disk. The inode has already
4547 * been pushed into its inode buffer (via VOP_UPDATE) at
4548 * the time of the reference count change. So we need only
4549 * locate that buffer, ensure that there will be no rollback
4550 * caused by a bitmap dependency, then write the inode buffer.
4551 */
4552 if (inodedep_lookup(ump->um_fs, inum, 0, &inodedep) == 0) {
4553 FREE_LOCK(&lk);
4554 panic("flush_pagedep_deps: lost inode");
4555 }
4556 /*
4557 * If the inode still has bitmap dependencies,
4558 * push them to disk.
4559 */
4560 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
4561 gotit = getdirtybuf(&inodedep->id_buf, MNT_WAIT);
4562 FREE_LOCK(&lk);
4563 if (gotit &&
4564 (error = BUF_WRITE(inodedep->id_buf)) != 0)
4565 break;
4566 ACQUIRE_LOCK(&lk);
4567 if (dap != LIST_FIRST(diraddhdp))
4568 continue;
4569 }
4570 /*
4571 * If the inode is still sitting in a buffer waiting
4572 * to be written, push it to disk.
4573 */
4574 FREE_LOCK(&lk);
4575 if ((error = bread(ump->um_devvp,
4576 fsbtodb(ump->um_fs, ino_to_fsba(ump->um_fs, inum)),
4577 (int)ump->um_fs->fs_bsize, NOCRED, &bp)) != 0)
4578 break;
4579 if ((error = BUF_WRITE(bp)) != 0)
4580 break;
4581 ACQUIRE_LOCK(&lk);
4582 /*
4583 * If we have failed to get rid of all the dependencies
4584 * then something is seriously wrong.
4585 */
4586 if (dap == LIST_FIRST(diraddhdp)) {
4587 FREE_LOCK(&lk);
4588 panic("flush_pagedep_deps: flush failed");
4589 }
4590 }
4591 if (error)
4592 ACQUIRE_LOCK(&lk);
4593 return (error);
4594}
4595
4596/*
4597 * A large burst of file addition or deletion activity can drive the
4598 * memory load excessively high. First attempt to slow things down
4599 * using the techniques below. If that fails, this routine requests
4600 * the offending operations to fall back to running synchronously
4601 * until the memory load returns to a reasonable level.
4602 */
4603int
4604softdep_slowdown(vp)
4605 struct vnode *vp;
4606{
4607 int max_softdeps_hard;
4608
4609 max_softdeps_hard = max_softdeps * 11 / 10;
4610 if (num_dirrem < max_softdeps_hard / 2 &&
4611 num_inodedep < max_softdeps_hard)
4612 return (0);
4613 stat_sync_limit_hit += 1;
4614 return (1);
4615}
4616
4617/*
4618 * If memory utilization has gotten too high, deliberately slow things
4619 * down and speed up the I/O processing.
4620 */
4621static int
4622request_cleanup(resource, islocked)
4623 int resource;
4624 int islocked;
4625{
4626 struct proc *p = CURPROC;
4627
4628 /*
4629 * We never hold up the filesystem syncer process.
4630 */
4631 if (p == filesys_syncer)
4632 return (0);
4633 /*
4634 * First check to see if the work list has gotten backlogged.
4635 * If it has, co-opt this process to help clean up two entries.
4636 * Because this process may hold inodes locked, we cannot
4637 * handle any remove requests that might block on a locked
4638 * inode as that could lead to deadlock.
4639 */
4640 if (num_on_worklist > max_softdeps / 10) {
4641 if (islocked)
4642 FREE_LOCK(&lk);
4643 process_worklist_item(NULL, LK_NOWAIT);
4644 process_worklist_item(NULL, LK_NOWAIT);
4645 stat_worklist_push += 2;
4646 if (islocked)
4647 ACQUIRE_LOCK(&lk);
4648 return(1);
4649 }
4650 /*
4651 * Next, we attempt to speed up the syncer process. If that
4652 * is successful, then we allow the process to continue.
4653 */
4654 if (speedup_syncer())
4655 return(0);
4656 /*
4657 * If we are resource constrained on inode dependencies, try
4658 * flushing some dirty inodes. Otherwise, we are constrained
4659 * by file deletions, so try accelerating flushes of directories
4660 * with removal dependencies. We would like to do the cleanup
4661 * here, but we probably hold an inode locked at this point and
4662 * that might deadlock against one that we try to clean. So,
4663 * the best that we can do is request the syncer daemon to do
4664 * the cleanup for us.
4665 */
4666 switch (resource) {
4667
4668 case FLUSH_INODES:
4669 stat_ino_limit_push += 1;
4670 req_clear_inodedeps += 1;
4671 stat_countp = &stat_ino_limit_hit;
4672 break;
4673
4674 case FLUSH_REMOVE:
4675 stat_blk_limit_push += 1;
4676 req_clear_remove += 1;
4677 stat_countp = &stat_blk_limit_hit;
4678 break;
4679
4680 default:
4681 if (islocked)
4682 FREE_LOCK(&lk);
4683 panic("request_cleanup: unknown type");
4684 }
4685 /*
4686 * Hopefully the syncer daemon will catch up and awaken us.
4687 * We wait at most tickdelay before proceeding in any case.
4688 */
4689 if (islocked == 0)
4690 ACQUIRE_LOCK(&lk);
4691 proc_waiting += 1;
4692 if (handle.callout == NULL)
4693 handle = timeout(pause_timer, 0, tickdelay > 2 ? tickdelay : 2);
4694 FREE_LOCK_INTERLOCKED(&lk);
4695 (void) tsleep((caddr_t)&proc_waiting, PPAUSE, "softupdate", 0);
4696 ACQUIRE_LOCK_INTERLOCKED(&lk);
4697 proc_waiting -= 1;
4698 if (islocked == 0)
4699 FREE_LOCK(&lk);
4700 return (1);
4701}
4702
4703/*
4704 * Awaken processes pausing in request_cleanup and clear proc_waiting
4705 * to indicate that there is no longer a timer running.
4706 */
4707void
4708pause_timer(arg)
4709 void *arg;
4710{
4711
4712 *stat_countp += 1;
4713 wakeup_one(&proc_waiting);
4714 if (proc_waiting > 0)
4715 handle = timeout(pause_timer, 0, tickdelay > 2 ? tickdelay : 2);
4716 else
4717 handle.callout = NULL;
4718}
4719
4720/*
4721 * Flush out a directory with at least one removal dependency in an effort to
4722 * reduce the number of dirrem, freefile, and freeblks dependency structures.
4723 */
4724static void
4725clear_remove(p)
4726 struct proc *p;
4727{
4728 struct pagedep_hashhead *pagedephd;
4729 struct pagedep *pagedep;
4730 static int next = 0;
4731 struct mount *mp;
4732 struct vnode *vp;
4733 int error, cnt;
4734 ino_t ino;
4735
4736 ACQUIRE_LOCK(&lk);
4737 for (cnt = 0; cnt < pagedep_hash; cnt++) {
4738 pagedephd = &pagedep_hashtbl[next++];
4739 if (next >= pagedep_hash)
4740 next = 0;
4741 LIST_FOREACH(pagedep, pagedephd, pd_hash) {
4742 if (LIST_FIRST(&pagedep->pd_dirremhd) == NULL)
4743 continue;
4744 mp = pagedep->pd_mnt;
4745 ino = pagedep->pd_ino;
4746 FREE_LOCK(&lk);
4747 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0)
4748 continue;
4749 if ((error = VFS_VGET(mp, ino, &vp)) != 0) {
4750 softdep_error("clear_remove: vget", error);
4751 vn_finished_write(mp);
4752 return;
4753 }
4754 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)))
4755 softdep_error("clear_remove: fsync", error);
4756 drain_output(vp, 0);
4757 vput(vp);
4758 vn_finished_write(mp);
4759 return;
4760 }
4761 }
4762 FREE_LOCK(&lk);
4763}
4764
4765/*
4766 * Clear out a block of dirty inodes in an effort to reduce
4767 * the number of inodedep dependency structures.
4768 */
4769static void
4770clear_inodedeps(p)
4771 struct proc *p;
4772{
4773 struct inodedep_hashhead *inodedephd;
4774 struct inodedep *inodedep;
4775 static int next = 0;
4776 struct mount *mp;
4777 struct vnode *vp;
4778 struct fs *fs;
4779 int error, cnt;
4780 ino_t firstino, lastino, ino;
4781
4782 ACQUIRE_LOCK(&lk);
4783 /*
4784 * Pick a random inode dependency to be cleared.
4785 * We will then gather up all the inodes in its block
4786 * that have dependencies and flush them out.
4787 */
4788 for (cnt = 0; cnt < inodedep_hash; cnt++) {
4789 inodedephd = &inodedep_hashtbl[next++];
4790 if (next >= inodedep_hash)
4791 next = 0;
4792 if ((inodedep = LIST_FIRST(inodedephd)) != NULL)
4793 break;
4794 }
4795 if (inodedep == NULL)
4796 return;
4797 /*
4798 * Ugly code to find mount point given pointer to superblock.
4799 */
4800 fs = inodedep->id_fs;
4801 TAILQ_FOREACH(mp, &mountlist, mnt_list)
4802 if ((mp->mnt_flag & MNT_SOFTDEP) && fs == VFSTOUFS(mp)->um_fs)
4803 break;
4804 /*
4805 * Find the last inode in the block with dependencies.
4806 */
4807 firstino = inodedep->id_ino & ~(INOPB(fs) - 1);
4808 for (lastino = firstino + INOPB(fs) - 1; lastino > firstino; lastino--)
4809 if (inodedep_lookup(fs, lastino, 0, &inodedep) != 0)
4810 break;
4811 /*
4812 * Asynchronously push all but the last inode with dependencies.
4813 * Synchronously push the last inode with dependencies to ensure
4814 * that the inode block gets written to free up the inodedeps.
4815 */
4816 for (ino = firstino; ino <= lastino; ino++) {
4817 if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
4818 continue;
4819 FREE_LOCK(&lk);
4820 if (vn_start_write(NULL, &mp, V_NOWAIT) != 0)
4821 continue;
4822 if ((error = VFS_VGET(mp, ino, &vp)) != 0) {
4823 softdep_error("clear_inodedeps: vget", error);
4824 vn_finished_write(mp);
4825 return;
4826 }
4827 if (ino == lastino) {
4828 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p)))
4829 softdep_error("clear_inodedeps: fsync1", error);
4830 } else {
4831 if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)))
4832 softdep_error("clear_inodedeps: fsync2", error);
4833 drain_output(vp, 0);
4834 }
4835 vput(vp);
4836 vn_finished_write(mp);
4837 ACQUIRE_LOCK(&lk);
4838 }
4839 FREE_LOCK(&lk);
4840}
4841
4842/*
4843 * Function to determine if the buffer has outstanding dependencies
4844 * that will cause a roll-back if the buffer is written. If wantcount
4845 * is set, return number of dependencies, otherwise just yes or no.
4846 */
4847static int
4848softdep_count_dependencies(bp, wantcount)
4849 struct buf *bp;
4850 int wantcount;
4851{
4852 struct worklist *wk;
4853 struct inodedep *inodedep;
4854 struct indirdep *indirdep;
4855 struct allocindir *aip;
4856 struct pagedep *pagedep;
4857 struct diradd *dap;
4858 int i, retval;
4859
4860 retval = 0;
4861 ACQUIRE_LOCK(&lk);
4862 LIST_FOREACH(wk, &bp->b_dep, wk_list) {
4863 switch (wk->wk_type) {
4864
4865 case D_INODEDEP:
4866 inodedep = WK_INODEDEP(wk);
4867 if ((inodedep->id_state & DEPCOMPLETE) == 0) {
4868 /* bitmap allocation dependency */
4869 retval += 1;
4870 if (!wantcount)
4871 goto out;
4872 }
4873 if (TAILQ_FIRST(&inodedep->id_inoupdt)) {
4874 /* direct block pointer dependency */
4875 retval += 1;
4876 if (!wantcount)
4877 goto out;
4878 }
4879 continue;
4880
4881 case D_INDIRDEP:
4882 indirdep = WK_INDIRDEP(wk);
4883
4884 LIST_FOREACH(aip, &indirdep->ir_deplisthd, ai_next) {
4885 /* indirect block pointer dependency */
4886 retval += 1;
4887 if (!wantcount)
4888 goto out;
4889 }
4890 continue;
4891
4892 case D_PAGEDEP:
4893 pagedep = WK_PAGEDEP(wk);
4894 for (i = 0; i < DAHASHSZ; i++) {
4895
4896 LIST_FOREACH(dap, &pagedep->pd_diraddhd[i], da_pdlist) {
4897 /* directory entry dependency */
4898 retval += 1;
4899 if (!wantcount)
4900 goto out;
4901 }
4902 }
4903 continue;
4904
4905 case D_BMSAFEMAP:
4906 case D_ALLOCDIRECT:
4907 case D_ALLOCINDIR:
4908 case D_MKDIR:
4909 /* never a dependency on these blocks */
4910 continue;
4911
4912 default:
4913 FREE_LOCK(&lk);
4914 panic("softdep_check_for_rollback: Unexpected type %s",
4915 TYPENAME(wk->wk_type));
4916 /* NOTREACHED */
4917 }
4918 }
4919out:
4920 FREE_LOCK(&lk);
4921 return retval;
4922}
4923
4924/*
4925 * Acquire exclusive access to a buffer.
4926 * Must be called with splbio blocked.
4927 * Return 1 if buffer was acquired.
4928 */
4929static int
4930getdirtybuf(bpp, waitfor)
4931 struct buf **bpp;
4932 int waitfor;
4933{
4934 struct buf *bp;
4935
4936 for (;;) {
4937 if ((bp = *bpp) == NULL)
4938 return (0);
4939 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT) == 0) {
4940 if ((bp->b_xflags & BX_BKGRDINPROG) == 0)
4941 break;
4942 BUF_UNLOCK(bp);
4943 if (waitfor != MNT_WAIT)
4944 return (0);
4945 bp->b_xflags |= BX_BKGRDWAIT;
4946 FREE_LOCK_INTERLOCKED(&lk);
4947 tsleep(&bp->b_xflags, PRIBIO, "getbuf", 0);
4948 ACQUIRE_LOCK_INTERLOCKED(&lk);
4949 continue;
4950 }
4951 if (waitfor != MNT_WAIT)
4952 return (0);
4953 FREE_LOCK_INTERLOCKED(&lk);
4954 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL) != ENOLCK)
4955 panic("getdirtybuf: inconsistent lock");
4956 ACQUIRE_LOCK_INTERLOCKED(&lk);
4957 }
4958 if ((bp->b_flags & B_DELWRI) == 0) {
4959 BUF_UNLOCK(bp);
4960 return (0);
4961 }
4962 bremfree(bp);
4963 return (1);
4964}
4965
4966/*
4967 * Wait for pending output on a vnode to complete.
4968 * Must be called with vnode locked.
4969 */
4970static void
4971drain_output(vp, islocked)
4972 struct vnode *vp;
4973 int islocked;
4974{
4975
4976 if (!islocked)
4977 ACQUIRE_LOCK(&lk);
4978 while (vp->v_numoutput) {
4979 vp->v_flag |= VBWAIT;
4980 FREE_LOCK_INTERLOCKED(&lk);
4981 tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "drainvp", 0);
4982 ACQUIRE_LOCK_INTERLOCKED(&lk);
4983 }
4984 if (!islocked)
4985 FREE_LOCK(&lk);
4986}
4987
4988/*
4989 * Called whenever a buffer that is being invalidated or reallocated
4990 * contains dependencies. This should only happen if an I/O error has
4991 * occurred. The routine is called with the buffer locked.
4992 */
4993static void
4994softdep_deallocate_dependencies(bp)
4995 struct buf *bp;
4996{
4997
4998 if ((bp->b_ioflags & BIO_ERROR) == 0)
4999 panic("softdep_deallocate_dependencies: dangling deps");
5000 softdep_error(bp->b_vp->v_mount->mnt_stat.f_mntonname, bp->b_error);
5001 panic("softdep_deallocate_dependencies: unrecovered I/O error");
5002}
5003
5004/*
5005 * Function to handle asynchronous write errors in the filesystem.
5006 */
5007void
5008softdep_error(func, error)
5009 char *func;
5010 int error;
5011{
5012
5013 /* XXX should do something better! */
5014 printf("%s: got error %d while accessing filesystem\n", func, error);
5015}
|