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