Split kern/vfs_journal.c. Leave the low level journal support code in
[dragonfly.git] / sys / kern / vfs_jops.c
1 /*
2  * Copyright (c) 2004-2006 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  * $DragonFly: src/sys/kern/vfs_jops.c,v 1.27 2006/05/08 18:45:51 dillon Exp $
35  */
36 /*
37  * Each mount point may have zero or more independantly configured journals
38  * attached to it.  Each journal is represented by a memory FIFO and worker
39  * thread.  Journal events are streamed through the FIFO to the thread,
40  * batched up (typically on one-second intervals), and written out by the
41  * thread. 
42  *
43  * Journal vnode ops are executed instead of mnt_vn_norm_ops when one or
44  * more journals have been installed on a mount point.  It becomes the
45  * responsibility of the journal op to call the underlying normal op as
46  * appropriate.
47  */
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/buf.h>
51 #include <sys/conf.h>
52 #include <sys/kernel.h>
53 #include <sys/queue.h>
54 #include <sys/lock.h>
55 #include <sys/malloc.h>
56 #include <sys/mount.h>
57 #include <sys/unistd.h>
58 #include <sys/vnode.h>
59 #include <sys/poll.h>
60 #include <sys/mountctl.h>
61 #include <sys/journal.h>
62 #include <sys/file.h>
63 #include <sys/proc.h>
64 #include <sys/msfbuf.h>
65 #include <sys/socket.h>
66 #include <sys/socketvar.h>
67
68 #include <machine/limits.h>
69
70 #include <vm/vm.h>
71 #include <vm/vm_object.h>
72 #include <vm/vm_page.h>
73 #include <vm/vm_pager.h>
74 #include <vm/vnode_pager.h>
75
76 #include <sys/file2.h>
77 #include <sys/thread2.h>
78
79 static int journal_attach(struct mount *mp);
80 static void journal_detach(struct mount *mp);
81 static int journal_install_vfs_journal(struct mount *mp, struct file *fp,
82                             const struct mountctl_install_journal *info);
83 static int journal_restart_vfs_journal(struct mount *mp, struct file *fp,
84                             const struct mountctl_restart_journal *info);
85 static int journal_remove_vfs_journal(struct mount *mp,
86                             const struct mountctl_remove_journal *info);
87 static int journal_restart(struct mount *mp, struct file *fp,
88                             struct journal *jo, int flags);
89 static int journal_destroy(struct mount *mp, struct journal *jo, int flags);
90 static int journal_resync_vfs_journal(struct mount *mp, const void *ctl);
91 static int journal_status_vfs_journal(struct mount *mp,
92                        const struct mountctl_status_journal *info,
93                        struct mountctl_journal_ret_status *rstat,
94                        int buflen, int *res);
95
96 static void jrecord_undo_file(struct jrecord *jrec, struct vnode *vp,
97                              int jrflags, off_t off, off_t bytes);
98
99 static int journal_setattr(struct vop_setattr_args *ap);
100 static int journal_write(struct vop_write_args *ap);
101 static int journal_fsync(struct vop_fsync_args *ap);
102 static int journal_putpages(struct vop_putpages_args *ap);
103 static int journal_setacl(struct vop_setacl_args *ap);
104 static int journal_setextattr(struct vop_setextattr_args *ap);
105 static int journal_ncreate(struct vop_ncreate_args *ap);
106 static int journal_nmknod(struct vop_nmknod_args *ap);
107 static int journal_nlink(struct vop_nlink_args *ap);
108 static int journal_nsymlink(struct vop_nsymlink_args *ap);
109 static int journal_nwhiteout(struct vop_nwhiteout_args *ap);
110 static int journal_nremove(struct vop_nremove_args *ap);
111 static int journal_nmkdir(struct vop_nmkdir_args *ap);
112 static int journal_nrmdir(struct vop_nrmdir_args *ap);
113 static int journal_nrename(struct vop_nrename_args *ap);
114
115 #define JRUNDO_SIZE     0x00000001
116 #define JRUNDO_UID      0x00000002
117 #define JRUNDO_GID      0x00000004
118 #define JRUNDO_FSID     0x00000008
119 #define JRUNDO_MODES    0x00000010
120 #define JRUNDO_INUM     0x00000020
121 #define JRUNDO_ATIME    0x00000040
122 #define JRUNDO_MTIME    0x00000080
123 #define JRUNDO_CTIME    0x00000100
124 #define JRUNDO_GEN      0x00000200
125 #define JRUNDO_FLAGS    0x00000400
126 #define JRUNDO_UDEV     0x00000800
127 #define JRUNDO_NLINK    0x00001000
128 #define JRUNDO_FILEDATA 0x00010000
129 #define JRUNDO_GETVP    0x00020000
130 #define JRUNDO_CONDLINK 0x00040000      /* write file data if link count 1 */
131 #define JRUNDO_VATTR    (JRUNDO_SIZE|JRUNDO_UID|JRUNDO_GID|JRUNDO_FSID|\
132                          JRUNDO_MODES|JRUNDO_INUM|JRUNDO_ATIME|JRUNDO_MTIME|\
133                          JRUNDO_CTIME|JRUNDO_GEN|JRUNDO_FLAGS|JRUNDO_UDEV|\
134                          JRUNDO_NLINK)
135 #define JRUNDO_ALL      (JRUNDO_VATTR|JRUNDO_FILEDATA)
136
137 static struct vnodeopv_entry_desc journal_vnodeop_entries[] = {
138     { &vop_default_desc,                vop_journal_operate_ap },
139     { &vop_mountctl_desc,               (void *)journal_mountctl },
140     { &vop_setattr_desc,                (void *)journal_setattr },
141     { &vop_write_desc,                  (void *)journal_write },
142     { &vop_fsync_desc,                  (void *)journal_fsync },
143     { &vop_putpages_desc,               (void *)journal_putpages },
144     { &vop_setacl_desc,                 (void *)journal_setacl },
145     { &vop_setextattr_desc,             (void *)journal_setextattr },
146     { &vop_ncreate_desc,                (void *)journal_ncreate },
147     { &vop_nmknod_desc,                 (void *)journal_nmknod },
148     { &vop_nlink_desc,                  (void *)journal_nlink },
149     { &vop_nsymlink_desc,               (void *)journal_nsymlink },
150     { &vop_nwhiteout_desc,              (void *)journal_nwhiteout },
151     { &vop_nremove_desc,                (void *)journal_nremove },
152     { &vop_nmkdir_desc,                 (void *)journal_nmkdir },
153     { &vop_nrmdir_desc,                 (void *)journal_nrmdir },
154     { &vop_nrename_desc,                (void *)journal_nrename },
155     { NULL, NULL }
156 };
157
158 static MALLOC_DEFINE(M_JOURNAL, "journal", "Journaling structures");
159 static MALLOC_DEFINE(M_JFIFO, "journal-fifo", "Journal FIFO");
160
161 int
162 journal_mountctl(struct vop_mountctl_args *ap)
163 {
164     struct mount *mp;
165     int error = 0;
166
167     mp = ap->a_head.a_ops->vv_mount;
168     KKASSERT(mp);
169
170     if (mp->mnt_vn_journal_ops == NULL) {
171         switch(ap->a_op) {
172         case MOUNTCTL_INSTALL_VFS_JOURNAL:
173             error = journal_attach(mp);
174             if (error == 0 && ap->a_ctllen != sizeof(struct mountctl_install_journal))
175                 error = EINVAL;
176             if (error == 0 && ap->a_fp == NULL)
177                 error = EBADF;
178             if (error == 0)
179                 error = journal_install_vfs_journal(mp, ap->a_fp, ap->a_ctl);
180             if (TAILQ_EMPTY(&mp->mnt_jlist))
181                 journal_detach(mp);
182             break;
183         case MOUNTCTL_RESTART_VFS_JOURNAL:
184         case MOUNTCTL_REMOVE_VFS_JOURNAL:
185         case MOUNTCTL_RESYNC_VFS_JOURNAL:
186         case MOUNTCTL_STATUS_VFS_JOURNAL:
187             error = ENOENT;
188             break;
189         default:
190             error = EOPNOTSUPP;
191             break;
192         }
193     } else {
194         switch(ap->a_op) {
195         case MOUNTCTL_INSTALL_VFS_JOURNAL:
196             if (ap->a_ctllen != sizeof(struct mountctl_install_journal))
197                 error = EINVAL;
198             if (error == 0 && ap->a_fp == NULL)
199                 error = EBADF;
200             if (error == 0)
201                 error = journal_install_vfs_journal(mp, ap->a_fp, ap->a_ctl);
202             break;
203         case MOUNTCTL_RESTART_VFS_JOURNAL:
204             if (ap->a_ctllen != sizeof(struct mountctl_restart_journal))
205                 error = EINVAL;
206             if (error == 0 && ap->a_fp == NULL)
207                 error = EBADF;
208             if (error == 0)
209                 error = journal_restart_vfs_journal(mp, ap->a_fp, ap->a_ctl);
210             break;
211         case MOUNTCTL_REMOVE_VFS_JOURNAL:
212             if (ap->a_ctllen != sizeof(struct mountctl_remove_journal))
213                 error = EINVAL;
214             if (error == 0)
215                 error = journal_remove_vfs_journal(mp, ap->a_ctl);
216             if (TAILQ_EMPTY(&mp->mnt_jlist))
217                 journal_detach(mp);
218             break;
219         case MOUNTCTL_RESYNC_VFS_JOURNAL:
220             if (ap->a_ctllen != 0)
221                 error = EINVAL;
222             error = journal_resync_vfs_journal(mp, ap->a_ctl);
223             break;
224         case MOUNTCTL_STATUS_VFS_JOURNAL:
225             if (ap->a_ctllen != sizeof(struct mountctl_status_journal))
226                 error = EINVAL;
227             if (error == 0) {
228                 error = journal_status_vfs_journal(mp, ap->a_ctl, 
229                                         ap->a_buf, ap->a_buflen, ap->a_res);
230             }
231             break;
232         default:
233             error = EOPNOTSUPP;
234             break;
235         }
236     }
237     return (error);
238 }
239
240 /*
241  * High level mount point setup.  When a 
242  */
243 static int
244 journal_attach(struct mount *mp)
245 {
246     KKASSERT(mp->mnt_jbitmap == NULL);
247     vfs_add_vnodeops(mp, &mp->mnt_vn_journal_ops, 
248                      journal_vnodeop_entries, 0);
249     mp->mnt_jbitmap = malloc(JREC_STREAMID_JMAX/8, M_JOURNAL, M_WAITOK|M_ZERO);
250     mp->mnt_streamid = JREC_STREAMID_JMIN;
251     return(0);
252 }
253
254 static void
255 journal_detach(struct mount *mp)
256 {
257     KKASSERT(mp->mnt_jbitmap != NULL);
258     if (mp->mnt_vn_journal_ops)
259         vfs_rm_vnodeops(&mp->mnt_vn_journal_ops);
260     free(mp->mnt_jbitmap, M_JOURNAL);
261     mp->mnt_jbitmap = NULL;
262 }
263
264 /*
265  * Install a journal on a mount point.  Each journal has an associated worker
266  * thread which is responsible for buffering and spooling the data to the
267  * target.  A mount point may have multiple journals attached to it.  An
268  * initial start record is generated when the journal is associated.
269  */
270 static int
271 journal_install_vfs_journal(struct mount *mp, struct file *fp, 
272                             const struct mountctl_install_journal *info)
273 {
274     struct journal *jo;
275     struct jrecord jrec;
276     int error = 0;
277     int size;
278
279     jo = malloc(sizeof(struct journal), M_JOURNAL, M_WAITOK|M_ZERO);
280     bcopy(info->id, jo->id, sizeof(jo->id));
281     jo->flags = info->flags & ~(MC_JOURNAL_WACTIVE | MC_JOURNAL_RACTIVE |
282                                 MC_JOURNAL_STOP_REQ);
283
284     /*
285      * Memory FIFO size, round to nearest power of 2
286      */
287     if (info->membufsize) {
288         if (info->membufsize < 65536)
289             size = 65536;
290         else if (info->membufsize > 128 * 1024 * 1024)
291             size = 128 * 1024 * 1024;
292         else
293             size = (int)info->membufsize;
294     } else {
295         size = 1024 * 1024;
296     }
297     jo->fifo.size = 1;
298     while (jo->fifo.size < size)
299         jo->fifo.size <<= 1;
300
301     /*
302      * Other parameters.  If not specified the starting transaction id
303      * will be the current date.
304      */
305     if (info->transid) {
306         jo->transid = info->transid;
307     } else {
308         struct timespec ts;
309         getnanotime(&ts);
310         jo->transid = ((int64_t)ts.tv_sec << 30) | ts.tv_nsec;
311     }
312
313     jo->fp = fp;
314
315     /*
316      * Allocate the memory FIFO
317      */
318     jo->fifo.mask = jo->fifo.size - 1;
319     jo->fifo.membase = malloc(jo->fifo.size, M_JFIFO, M_WAITOK|M_ZERO|M_NULLOK);
320     if (jo->fifo.membase == NULL)
321         error = ENOMEM;
322
323     /*
324      * Create the worker threads and generate the association record.
325      */
326     if (error) {
327         free(jo, M_JOURNAL);
328     } else {
329         fhold(fp);
330         journal_create_threads(jo);
331         jrecord_init(jo, &jrec, JREC_STREAMID_DISCONT);
332         jrecord_write(&jrec, JTYPE_ASSOCIATE, 0);
333         jrecord_done(&jrec, 0);
334         TAILQ_INSERT_TAIL(&mp->mnt_jlist, jo, jentry);
335     }
336     return(error);
337 }
338
339 /*
340  * Restart a journal with a new descriptor.   The existing reader and writer
341  * threads are terminated and a new descriptor is associated with the
342  * journal.  The FIFO rindex is reset to xindex and the threads are then
343  * restarted.
344  */
345 static int
346 journal_restart_vfs_journal(struct mount *mp, struct file *fp,
347                            const struct mountctl_restart_journal *info)
348 {
349     struct journal *jo;
350     int error;
351
352     TAILQ_FOREACH(jo, &mp->mnt_jlist, jentry) {
353         if (bcmp(jo->id, info->id, sizeof(jo->id)) == 0)
354             break;
355     }
356     if (jo)
357         error = journal_restart(mp, fp, jo, info->flags);
358     else
359         error = EINVAL;
360     return (error);
361 }
362
363 static int
364 journal_restart(struct mount *mp, struct file *fp, 
365                 struct journal *jo, int flags)
366 {
367     /*
368      * XXX lock the jo
369      */
370
371 #if 0
372     /*
373      * Record the fact that we are doing a restart in the journal.
374      * XXX it isn't safe to do this if the journal is being restarted
375      * because it was locked up and the writer thread has already exited.
376      */
377     jrecord_init(jo, &jrec, JREC_STREAMID_RESTART);
378     jrecord_write(&jrec, JTYPE_DISASSOCIATE, 0);
379     jrecord_done(&jrec, 0);
380 #endif
381
382     /*
383      * Stop the reader and writer threads and clean up the current 
384      * descriptor.
385      */
386     printf("RESTART WITH FP %p KILLING %p\n", fp, jo->fp);
387     journal_destroy_threads(jo, flags);
388
389     if (jo->fp)
390         fdrop(jo->fp);
391
392     /*
393      * Associate the new descriptor, reset the FIFO index, and recreate
394      * the threads.
395      */
396     fhold(fp);
397     jo->fp = fp;
398     jo->fifo.rindex = jo->fifo.xindex;
399     journal_create_threads(jo);
400
401     return(0);
402 }
403
404 /*
405  * Disassociate a journal from a mount point and terminate its worker thread.
406  * A final termination record is written out before the file pointer is
407  * dropped.
408  */
409 static int
410 journal_remove_vfs_journal(struct mount *mp, 
411                            const struct mountctl_remove_journal *info)
412 {
413     struct journal *jo;
414     int error;
415
416     TAILQ_FOREACH(jo, &mp->mnt_jlist, jentry) {
417         if (bcmp(jo->id, info->id, sizeof(jo->id)) == 0)
418             break;
419     }
420     if (jo)
421         error = journal_destroy(mp, jo, info->flags);
422     else
423         error = EINVAL;
424     return (error);
425 }
426
427 /*
428  * Remove all journals associated with a mount point.  Usually called
429  * by the umount code.
430  */
431 void
432 journal_remove_all_journals(struct mount *mp, int flags)
433 {
434     struct journal *jo;
435
436     while ((jo = TAILQ_FIRST(&mp->mnt_jlist)) != NULL) {
437         journal_destroy(mp, jo, flags);
438     }
439 }
440
441 static int
442 journal_destroy(struct mount *mp, struct journal *jo, int flags)
443 {
444     struct jrecord jrec;
445
446     TAILQ_REMOVE(&mp->mnt_jlist, jo, jentry);
447
448     jrecord_init(jo, &jrec, JREC_STREAMID_DISCONT);
449     jrecord_write(&jrec, JTYPE_DISASSOCIATE, 0);
450     jrecord_done(&jrec, 0);
451
452     journal_destroy_threads(jo, flags);
453
454     if (jo->fp)
455         fdrop(jo->fp);
456     if (jo->fifo.membase)
457         free(jo->fifo.membase, M_JFIFO);
458     free(jo, M_JOURNAL);
459
460     return(0);
461 }
462
463 static int
464 journal_resync_vfs_journal(struct mount *mp, const void *ctl)
465 {
466     return(EINVAL);
467 }
468
469 static int
470 journal_status_vfs_journal(struct mount *mp, 
471                        const struct mountctl_status_journal *info,
472                        struct mountctl_journal_ret_status *rstat,
473                        int buflen, int *res)
474 {
475     struct journal *jo;
476     int error = 0;
477     int index;
478
479     index = 0;
480     *res = 0;
481     TAILQ_FOREACH(jo, &mp->mnt_jlist, jentry) {
482         if (info->index == MC_JOURNAL_INDEX_ID) {
483             if (bcmp(jo->id, info->id, sizeof(jo->id)) != 0)
484                 continue;
485         } else if (info->index >= 0) {
486             if (info->index < index)
487                 continue;
488         } else if (info->index != MC_JOURNAL_INDEX_ALL) {
489             continue;
490         }
491         if (buflen < sizeof(*rstat)) {
492             if (*res)
493                 rstat[-1].flags |= MC_JOURNAL_STATUS_MORETOCOME;
494             else
495                 error = EINVAL;
496             break;
497         }
498         bzero(rstat, sizeof(*rstat));
499         rstat->recsize = sizeof(*rstat);
500         bcopy(jo->id, rstat->id, sizeof(jo->id));
501         rstat->index = index;
502         rstat->membufsize = jo->fifo.size;
503         rstat->membufused = jo->fifo.windex - jo->fifo.xindex;
504         rstat->membufunacked = jo->fifo.rindex - jo->fifo.xindex;
505         rstat->bytessent = jo->total_acked;
506         rstat->fifostalls = jo->fifostalls;
507         ++rstat;
508         ++index;
509         *res += sizeof(*rstat);
510         buflen -= sizeof(*rstat);
511     }
512     return(error);
513 }
514
515 /************************************************************************
516  *                      PARALLEL TRANSACTION SUPPORT ROUTINES           *
517  ************************************************************************
518  *
519  * JRECLIST_*() - routines which create and iterate over jrecord structures,
520  *                because a mount point may have multiple attached journals.
521  */
522
523 /*
524  * Initialize the passed jrecord_list and create a jrecord for each 
525  * journal we need to write to.  Unnecessary mallocs are avoided by
526  * using the passed jrecord structure as the first jrecord in the list.
527  * A starting transaction is pushed for each jrecord.
528  *
529  * Returns non-zero if any of the journals require undo records.
530  */
531 static
532 int
533 jreclist_init(struct mount *mp, struct jrecord_list *jreclist, 
534               struct jrecord *jreccache, int16_t rectype)
535 {
536     struct journal *jo;
537     struct jrecord *jrec;
538     int wantrev;
539     int count;
540     int16_t streamid;
541
542     TAILQ_INIT(&jreclist->list);
543
544     /*
545      * Select the stream ID to use for the transaction.  We must select
546      * a stream ID that is not currently in use by some other parallel
547      * transaction.  
548      *
549      * Don't bother calculating the next streamid when reassigning
550      * mnt_streamid, since parallel transactions are fairly rare.  This
551      * also allows someone observing the raw records to clearly see
552      * when parallel transactions occur.
553      */
554     streamid = mp->mnt_streamid;
555     count = 0;
556     while (mp->mnt_jbitmap[streamid >> 3] & (1 << (streamid & 7))) {
557         if (++streamid == JREC_STREAMID_JMAX)
558                 streamid = JREC_STREAMID_JMIN;
559         if (++count == JREC_STREAMID_JMAX - JREC_STREAMID_JMIN) {
560                 printf("jreclist_init: all streamid's in use! sleeping\n");
561                 tsleep(jreclist, 0, "jsidfl", hz * 10);
562                 count = 0;
563         }
564     }
565     mp->mnt_jbitmap[streamid >> 3] |= 1 << (streamid & 7);
566     mp->mnt_streamid = streamid;
567     jreclist->streamid = streamid;
568
569     /*
570      * Now initialize a stream on each journal.
571      */
572     count = 0;
573     wantrev = 0;
574     TAILQ_FOREACH(jo, &mp->mnt_jlist, jentry) {
575         if (count == 0)
576             jrec = jreccache;
577         else
578             jrec = malloc(sizeof(*jrec), M_JOURNAL, M_WAITOK);
579         jrecord_init(jo, jrec, streamid);
580         jrec->user_save = jrecord_push(jrec, rectype);
581         TAILQ_INSERT_TAIL(&jreclist->list, jrec, user_entry);
582         if (jo->flags & MC_JOURNAL_WANT_REVERSABLE)
583             wantrev = 1;
584         ++count;
585     }
586     return(wantrev);
587 }
588
589 /*
590  * Terminate the journaled transactions started by jreclist_init().  If
591  * an error occured, the transaction records will be aborted.
592  */
593 static
594 void
595 jreclist_done(struct mount *mp, struct jrecord_list *jreclist, int error)
596 {
597     struct jrecord *jrec;
598     int count;
599
600     /*
601      * Cleanup the jrecord state on each journal.
602      */
603     TAILQ_FOREACH(jrec, &jreclist->list, user_entry) {
604         jrecord_pop(jrec, jrec->user_save);
605         jrecord_done(jrec, error);
606     }
607
608     /*
609      * Free allocated jrec's (the first is always supplied)
610      */
611     count = 0;
612     while ((jrec = TAILQ_FIRST(&jreclist->list)) != NULL) {
613         TAILQ_REMOVE(&jreclist->list, jrec, user_entry);
614         if (count)
615             free(jrec, M_JOURNAL);
616         ++count;
617     }
618
619     /*
620      * Clear the streamid so it can be reused.
621      */
622     mp->mnt_jbitmap[jreclist->streamid >> 3] &= ~(1 << (jreclist->streamid & 7));
623 }
624
625 /*
626  * This procedure writes out UNDO records for available reversable
627  * journals.
628  *
629  * XXX could use improvement.  There is no need to re-read the file
630  * for each journal.
631  */
632 static
633 void
634 jreclist_undo_file(struct jrecord_list *jreclist, struct vnode *vp, 
635                    int jrflags, off_t off, off_t bytes)
636 {
637     struct jrecord *jrec;
638     int error;
639
640     error = 0;
641     if (jrflags & JRUNDO_GETVP)
642         error = vget(vp, LK_SHARED);
643     if (error == 0) {
644         TAILQ_FOREACH(jrec, &jreclist->list, user_entry) {
645             if (jrec->jo->flags & MC_JOURNAL_WANT_REVERSABLE) {
646                 jrecord_undo_file(jrec, vp, jrflags, off, bytes);
647             }
648         }
649     }
650     if (error == 0 && jrflags & JRUNDO_GETVP)
651         vput(vp);
652 }
653
654 /************************************************************************
655  *                      LOW LEVEL UNDO SUPPORT ROUTINE                  *
656  ************************************************************************
657  *
658  * This function is used to support UNDO records.  It will generate an
659  * appropriate record with the requested portion of the file data.  Note
660  * that file data is only recorded if JRUNDO_FILEDATA is passed.  If bytes
661  * is -1, it will be set to the size of the file.
662  */
663 static void
664 jrecord_undo_file(struct jrecord *jrec, struct vnode *vp, int jrflags, 
665                   off_t off, off_t bytes)
666 {
667     struct vattr attr;
668     void *save1; /* warning, save pointers do not always remain valid */
669     void *save2;
670     int error;
671
672     /*
673      * Setup.  Start the UNDO record, obtain a shared lock on the vnode,
674      * and retrieve attribute info.
675      */
676     save1 = jrecord_push(jrec, JTYPE_UNDO);
677     error = VOP_GETATTR(vp, &attr);
678     if (error)
679         goto done;
680
681     /*
682      * Generate UNDO records as requested.
683      */
684     if (jrflags & JRUNDO_VATTR) {
685         save2 = jrecord_push(jrec, JTYPE_VATTR);
686         jrecord_leaf(jrec, JLEAF_VTYPE, &attr.va_type, sizeof(attr.va_type));
687         if ((jrflags & JRUNDO_NLINK) && attr.va_nlink != VNOVAL)
688             jrecord_leaf(jrec, JLEAF_NLINK, &attr.va_nlink, sizeof(attr.va_nlink));
689         if ((jrflags & JRUNDO_SIZE) && attr.va_size != VNOVAL)
690             jrecord_leaf(jrec, JLEAF_SIZE, &attr.va_size, sizeof(attr.va_size));
691         if ((jrflags & JRUNDO_UID) && attr.va_uid != VNOVAL)
692             jrecord_leaf(jrec, JLEAF_UID, &attr.va_uid, sizeof(attr.va_uid));
693         if ((jrflags & JRUNDO_GID) && attr.va_gid != VNOVAL)
694             jrecord_leaf(jrec, JLEAF_GID, &attr.va_gid, sizeof(attr.va_gid));
695         if ((jrflags & JRUNDO_FSID) && attr.va_fsid != VNOVAL)
696             jrecord_leaf(jrec, JLEAF_FSID, &attr.va_fsid, sizeof(attr.va_fsid));
697         if ((jrflags & JRUNDO_MODES) && attr.va_mode != (mode_t)VNOVAL)
698             jrecord_leaf(jrec, JLEAF_MODES, &attr.va_mode, sizeof(attr.va_mode));
699         if ((jrflags & JRUNDO_INUM) && attr.va_fileid != VNOVAL)
700             jrecord_leaf(jrec, JLEAF_INUM, &attr.va_fileid, sizeof(attr.va_fileid));
701         if ((jrflags & JRUNDO_ATIME) && attr.va_atime.tv_sec != VNOVAL)
702             jrecord_leaf(jrec, JLEAF_ATIME, &attr.va_atime, sizeof(attr.va_atime));
703         if ((jrflags & JRUNDO_MTIME) && attr.va_mtime.tv_sec != VNOVAL)
704             jrecord_leaf(jrec, JLEAF_MTIME, &attr.va_mtime, sizeof(attr.va_mtime));
705         if ((jrflags & JRUNDO_CTIME) && attr.va_ctime.tv_sec != VNOVAL)
706             jrecord_leaf(jrec, JLEAF_CTIME, &attr.va_ctime, sizeof(attr.va_ctime));
707         if ((jrflags & JRUNDO_GEN) && attr.va_gen != VNOVAL)
708             jrecord_leaf(jrec, JLEAF_GEN, &attr.va_gen, sizeof(attr.va_gen));
709         if ((jrflags & JRUNDO_FLAGS) && attr.va_flags != VNOVAL)
710             jrecord_leaf(jrec, JLEAF_FLAGS, &attr.va_flags, sizeof(attr.va_flags));
711         if ((jrflags & JRUNDO_UDEV) && attr.va_rdev != VNOVAL)
712             jrecord_leaf(jrec, JLEAF_UDEV, &attr.va_rdev, sizeof(attr.va_rdev));
713         jrecord_pop(jrec, save2);
714     }
715
716     /*
717      * Output the file data being overwritten by reading the file and
718      * writing it out to the journal prior to the write operation.  We
719      * do not need to write out data past the current file EOF.
720      *
721      * XXX support JRUNDO_CONDLINK - do not write out file data for files
722      * with a link count > 1.  The undo code needs to locate the inode and
723      * regenerate the hardlink.
724      */
725     if ((jrflags & JRUNDO_FILEDATA) && attr.va_type == VREG) {
726         if (attr.va_size != VNOVAL) {
727             if (bytes == -1)
728                 bytes = attr.va_size - off;
729             if (off + bytes > attr.va_size)
730                 bytes = attr.va_size - off;
731             if (bytes > 0)
732                 jrecord_file_data(jrec, vp, off, bytes);
733         } else {
734             error = EINVAL;
735         }
736     }
737     if ((jrflags & JRUNDO_FILEDATA) && attr.va_type == VLNK) {
738         struct iovec aiov;
739         struct uio auio;
740         char *buf;
741
742         buf = malloc(PATH_MAX, M_JOURNAL, M_WAITOK);
743         aiov.iov_base = buf;
744         aiov.iov_len = PATH_MAX;
745         auio.uio_iov = &aiov;
746         auio.uio_iovcnt = 1;
747         auio.uio_offset = 0;
748         auio.uio_rw = UIO_READ;
749         auio.uio_segflg = UIO_SYSSPACE;
750         auio.uio_td = curthread;
751         auio.uio_resid = PATH_MAX;
752         error = VOP_READLINK(vp, &auio, proc0.p_ucred);
753         if (error == 0) {
754                 jrecord_leaf(jrec, JLEAF_SYMLINKDATA, buf, 
755                                 PATH_MAX - auio.uio_resid);
756         }
757         free(buf, M_JOURNAL);
758     }
759 done:
760     if (error)
761         jrecord_leaf(jrec, JLEAF_ERROR, &error, sizeof(error));
762     jrecord_pop(jrec, save1);
763 }
764
765 /************************************************************************
766  *                      JOURNAL VNOPS                                   *
767  ************************************************************************
768  *
769  * These are function shims replacing the normal filesystem ops.  We become
770  * responsible for calling the underlying filesystem ops.  We have the choice
771  * of executing the underlying op first and then generating the journal entry,
772  * or starting the journal entry, executing the underlying op, and then
773  * either completing or aborting it.  
774  *
775  * The journal is supposed to be a high-level entity, which generally means
776  * identifying files by name rather then by inode.  Supplying both allows
777  * the journal to be used both for inode-number-compatible 'mirrors' and
778  * for simple filesystem replication.
779  *
780  * Writes are particularly difficult to deal with because a single write may
781  * represent a hundred megabyte buffer or more, and both writes and truncations
782  * require the 'old' data to be written out as well as the new data if the
783  * log is reversable.  Other issues:
784  *
785  * - How to deal with operations on unlinked files (no path available),
786  *   but which may still be filesystem visible due to hard links.
787  *
788  * - How to deal with modifications made via a memory map.
789  *
790  * - Future cache coherency support will require cache coherency API calls
791  *   both prior to and after the call to the underlying VFS.
792  *
793  * ALSO NOTE: We do not have to shim compatibility VOPs like MKDIR which have
794  * new VFS equivalents (NMKDIR).
795  */
796
797 /*
798  * Journal vop_settattr { a_vp, a_vap, a_cred, a_td }
799  */
800 static
801 int
802 journal_setattr(struct vop_setattr_args *ap)
803 {
804     struct jrecord_list jreclist;
805     struct jrecord jreccache;
806     struct jrecord *jrec;
807     struct mount *mp;
808     void *save;
809     int error;
810
811     mp = ap->a_head.a_ops->vv_mount;
812     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_SETATTR)) {
813         jreclist_undo_file(&jreclist, ap->a_vp, JRUNDO_VATTR, 0, 0);
814     }
815     error = vop_journal_operate_ap(&ap->a_head);
816     if (error == 0) {
817         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
818             jrecord_write_cred(jrec, curthread, ap->a_cred);
819             jrecord_write_vnode_ref(jrec, ap->a_vp);
820             save = jrecord_push(jrec, JTYPE_REDO);
821             jrecord_write_vattr(jrec, ap->a_vap);
822             jrecord_pop(jrec, save);
823         }
824     }
825     jreclist_done(mp, &jreclist, error);
826     return (error);
827 }
828
829 /*
830  * Journal vop_write { a_vp, a_uio, a_ioflag, a_cred }
831  */
832 static
833 int
834 journal_write(struct vop_write_args *ap)
835 {
836     struct jrecord_list jreclist;
837     struct jrecord jreccache;
838     struct jrecord *jrec;
839     struct mount *mp;
840     struct uio uio_copy;
841     struct iovec uio_one_iovec;
842     void *save;
843     int error;
844
845     /*
846      * This is really nasty.  UIO's don't retain sufficient information to
847      * be reusable once they've gone through the VOP chain.  The iovecs get
848      * cleared, so we have to copy the UIO.
849      *
850      * XXX fix the UIO code to not destroy iov's during a scan so we can
851      *     reuse the uio over and over again.
852      *
853      * XXX UNDO code needs to journal the old data prior to the write.
854      */
855     uio_copy = *ap->a_uio;
856     if (uio_copy.uio_iovcnt == 1) {
857         uio_one_iovec = ap->a_uio->uio_iov[0];
858         uio_copy.uio_iov = &uio_one_iovec;
859     } else {
860         uio_copy.uio_iov = malloc(uio_copy.uio_iovcnt * sizeof(struct iovec),
861                                     M_JOURNAL, M_WAITOK);
862         bcopy(ap->a_uio->uio_iov, uio_copy.uio_iov, 
863                 uio_copy.uio_iovcnt * sizeof(struct iovec));
864     }
865
866     /*
867      * Write out undo data.  Note that uio_offset is incorrect if
868      * IO_APPEND is set, but fortunately we have no undo file data to
869      * write out in that case.
870      */
871     mp = ap->a_head.a_ops->vv_mount;
872     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_WRITE)) {
873         if (ap->a_ioflag & IO_APPEND) {
874             jreclist_undo_file(&jreclist, ap->a_vp, JRUNDO_SIZE|JRUNDO_MTIME, 0, 0);
875         } else {
876             jreclist_undo_file(&jreclist, ap->a_vp, 
877                                JRUNDO_FILEDATA|JRUNDO_SIZE|JRUNDO_MTIME, 
878                                uio_copy.uio_offset, uio_copy.uio_resid);
879         }
880     }
881     error = vop_journal_operate_ap(&ap->a_head);
882
883     /*
884      * XXX bad hack to figure out the offset for O_APPEND writes (note: 
885      * uio field state after the VFS operation).
886      */
887     uio_copy.uio_offset = ap->a_uio->uio_offset - 
888                           (uio_copy.uio_resid - ap->a_uio->uio_resid);
889
890     /*
891      * Output the write data to the journal.
892      */
893     if (error == 0) {
894         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
895             jrecord_write_cred(jrec, NULL, ap->a_cred);
896             jrecord_write_vnode_ref(jrec, ap->a_vp);
897             save = jrecord_push(jrec, JTYPE_REDO);
898             jrecord_write_uio(jrec, JLEAF_FILEDATA, &uio_copy);
899             jrecord_pop(jrec, save);
900         }
901     }
902     jreclist_done(mp, &jreclist, error);
903
904     if (uio_copy.uio_iov != &uio_one_iovec)
905         free(uio_copy.uio_iov, M_JOURNAL);
906     return (error);
907 }
908
909 /*
910  * Journal vop_fsync { a_vp, a_waitfor, a_td }
911  */
912 static
913 int
914 journal_fsync(struct vop_fsync_args *ap)
915 {
916 #if 0
917     struct mount *mp;
918     struct journal *jo;
919 #endif
920     int error;
921
922     error = vop_journal_operate_ap(&ap->a_head);
923 #if 0
924     mp = ap->a_head.a_ops->vv_mount;
925     if (error == 0) {
926         TAILQ_FOREACH(jo, &mp->mnt_jlist, jentry) {
927             /* XXX synchronize pending journal records */
928         }
929     }
930 #endif
931     return (error);
932 }
933
934 /*
935  * Journal vop_putpages { a_vp, a_m, a_count, a_sync, a_rtvals, a_offset }
936  *
937  * note: a_count is in bytes.
938  */
939 static
940 int
941 journal_putpages(struct vop_putpages_args *ap)
942 {
943     struct jrecord_list jreclist;
944     struct jrecord jreccache;
945     struct jrecord *jrec;
946     struct mount *mp;
947     void *save;
948     int error;
949
950     mp = ap->a_head.a_ops->vv_mount;
951     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_PUTPAGES) && 
952         ap->a_count > 0
953     ) {
954         jreclist_undo_file(&jreclist, ap->a_vp, 
955                            JRUNDO_FILEDATA|JRUNDO_SIZE|JRUNDO_MTIME, 
956                            ap->a_offset, btoc(ap->a_count));
957     }
958     error = vop_journal_operate_ap(&ap->a_head);
959     if (error == 0 && ap->a_count > 0) {
960         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
961             jrecord_write_vnode_ref(jrec, ap->a_vp);
962             save = jrecord_push(jrec, JTYPE_REDO);
963             jrecord_write_pagelist(jrec, JLEAF_FILEDATA, ap->a_m, ap->a_rtvals, 
964                                    btoc(ap->a_count), ap->a_offset);
965             jrecord_pop(jrec, save);
966         }
967     }
968     jreclist_done(mp, &jreclist, error);
969     return (error);
970 }
971
972 /*
973  * Journal vop_setacl { a_vp, a_type, a_aclp, a_cred, a_td }
974  */
975 static
976 int
977 journal_setacl(struct vop_setacl_args *ap)
978 {
979     struct jrecord_list jreclist;
980     struct jrecord jreccache;
981     struct jrecord *jrec;
982     struct mount *mp;
983     int error;
984
985     mp = ap->a_head.a_ops->vv_mount;
986     jreclist_init(mp, &jreclist, &jreccache, JTYPE_SETACL);
987     error = vop_journal_operate_ap(&ap->a_head);
988     if (error == 0) {
989         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
990 #if 0
991             if ((jo->flags & MC_JOURNAL_WANT_REVERSABLE))
992                 jrecord_undo_file(jrec, ap->a_vp, JRUNDO_XXX, 0, 0);
993 #endif
994             jrecord_write_cred(jrec, curthread, ap->a_cred);
995             jrecord_write_vnode_ref(jrec, ap->a_vp);
996 #if 0
997             save = jrecord_push(jrec, JTYPE_REDO);
998             /* XXX type, aclp */
999             jrecord_pop(jrec, save);
1000 #endif
1001         }
1002     }
1003     jreclist_done(mp, &jreclist, error);
1004     return (error);
1005 }
1006
1007 /*
1008  * Journal vop_setextattr { a_vp, a_name, a_uio, a_cred, a_td }
1009  */
1010 static
1011 int
1012 journal_setextattr(struct vop_setextattr_args *ap)
1013 {
1014     struct jrecord_list jreclist;
1015     struct jrecord jreccache;
1016     struct jrecord *jrec;
1017     struct mount *mp;
1018     void *save;
1019     int error;
1020
1021     mp = ap->a_head.a_ops->vv_mount;
1022     jreclist_init(mp, &jreclist, &jreccache, JTYPE_SETEXTATTR);
1023     error = vop_journal_operate_ap(&ap->a_head);
1024     if (error == 0) {
1025         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1026 #if 0
1027             if ((jo->flags & MC_JOURNAL_WANT_REVERSABLE))
1028                 jrecord_undo_file(jrec, ap->a_vp, JRUNDO_XXX, 0, 0);
1029 #endif
1030             jrecord_write_cred(jrec, curthread, ap->a_cred);
1031             jrecord_write_vnode_ref(jrec, ap->a_vp);
1032             jrecord_leaf(jrec, JLEAF_ATTRNAME, ap->a_name, strlen(ap->a_name));
1033             save = jrecord_push(jrec, JTYPE_REDO);
1034             jrecord_write_uio(jrec, JLEAF_FILEDATA, ap->a_uio);
1035             jrecord_pop(jrec, save);
1036         }
1037     }
1038     jreclist_done(mp, &jreclist, error);
1039     return (error);
1040 }
1041
1042 /*
1043  * Journal vop_ncreate { a_ncp, a_vpp, a_cred, a_vap }
1044  */
1045 static
1046 int
1047 journal_ncreate(struct vop_ncreate_args *ap)
1048 {
1049     struct jrecord_list jreclist;
1050     struct jrecord jreccache;
1051     struct jrecord *jrec;
1052     struct mount *mp;
1053     void *save;
1054     int error;
1055
1056     mp = ap->a_head.a_ops->vv_mount;
1057     jreclist_init(mp, &jreclist, &jreccache, JTYPE_CREATE);
1058     error = vop_journal_operate_ap(&ap->a_head);
1059     if (error == 0) {
1060         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1061             jrecord_write_cred(jrec, NULL, ap->a_cred);
1062             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1063             if (*ap->a_vpp)
1064                 jrecord_write_vnode_ref(jrec, *ap->a_vpp);
1065             save = jrecord_push(jrec, JTYPE_REDO);
1066             jrecord_write_vattr(jrec, ap->a_vap);
1067             jrecord_pop(jrec, save);
1068         }
1069     }
1070     jreclist_done(mp, &jreclist, error);
1071     return (error);
1072 }
1073
1074 /*
1075  * Journal vop_nmknod { a_ncp, a_vpp, a_cred, a_vap }
1076  */
1077 static
1078 int
1079 journal_nmknod(struct vop_nmknod_args *ap)
1080 {
1081     struct jrecord_list jreclist;
1082     struct jrecord jreccache;
1083     struct jrecord *jrec;
1084     struct mount *mp;
1085     void *save;
1086     int error;
1087
1088     mp = ap->a_head.a_ops->vv_mount;
1089     jreclist_init(mp, &jreclist, &jreccache, JTYPE_MKNOD);
1090     error = vop_journal_operate_ap(&ap->a_head);
1091     if (error == 0) {
1092         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1093             jrecord_write_cred(jrec, NULL, ap->a_cred);
1094             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1095             save = jrecord_push(jrec, JTYPE_REDO);
1096             jrecord_write_vattr(jrec, ap->a_vap);
1097             jrecord_pop(jrec, save);
1098             if (*ap->a_vpp)
1099                 jrecord_write_vnode_ref(jrec, *ap->a_vpp);
1100         }
1101     }
1102     jreclist_done(mp, &jreclist, error);
1103     return (error);
1104 }
1105
1106 /*
1107  * Journal vop_nlink { a_ncp, a_vp, a_cred }
1108  */
1109 static
1110 int
1111 journal_nlink(struct vop_nlink_args *ap)
1112 {
1113     struct jrecord_list jreclist;
1114     struct jrecord jreccache;
1115     struct jrecord *jrec;
1116     struct mount *mp;
1117     void *save;
1118     int error;
1119
1120     mp = ap->a_head.a_ops->vv_mount;
1121     jreclist_init(mp, &jreclist, &jreccache, JTYPE_LINK);
1122     error = vop_journal_operate_ap(&ap->a_head);
1123     if (error == 0) {
1124         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1125             jrecord_write_cred(jrec, NULL, ap->a_cred);
1126             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1127             /* XXX PATH to VP and inode number */
1128             /* XXX this call may not record the correct path when
1129              * multiple paths are available */
1130             save = jrecord_push(jrec, JTYPE_REDO);
1131             jrecord_write_vnode_link(jrec, ap->a_vp, ap->a_ncp);
1132             jrecord_pop(jrec, save);
1133         }
1134     }
1135     jreclist_done(mp, &jreclist, error);
1136     return (error);
1137 }
1138
1139 /*
1140  * Journal vop_symlink { a_ncp, a_vpp, a_cred, a_vap, a_target }
1141  */
1142 static
1143 int
1144 journal_nsymlink(struct vop_nsymlink_args *ap)
1145 {
1146     struct jrecord_list jreclist;
1147     struct jrecord jreccache;
1148     struct jrecord *jrec;
1149     struct mount *mp;
1150     void *save;
1151     int error;
1152
1153     mp = ap->a_head.a_ops->vv_mount;
1154     jreclist_init(mp, &jreclist, &jreccache, JTYPE_SYMLINK);
1155     error = vop_journal_operate_ap(&ap->a_head);
1156     if (error == 0) {
1157         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1158             jrecord_write_cred(jrec, NULL, ap->a_cred);
1159             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1160             save = jrecord_push(jrec, JTYPE_REDO);
1161             jrecord_leaf(jrec, JLEAF_SYMLINKDATA,
1162                         ap->a_target, strlen(ap->a_target));
1163             jrecord_pop(jrec, save);
1164             if (*ap->a_vpp)
1165                 jrecord_write_vnode_ref(jrec, *ap->a_vpp);
1166         }
1167     }
1168     jreclist_done(mp, &jreclist, error);
1169     return (error);
1170 }
1171
1172 /*
1173  * Journal vop_nwhiteout { a_ncp, a_cred, a_flags }
1174  */
1175 static
1176 int
1177 journal_nwhiteout(struct vop_nwhiteout_args *ap)
1178 {
1179     struct jrecord_list jreclist;
1180     struct jrecord jreccache;
1181     struct jrecord *jrec;
1182     struct mount *mp;
1183     int error;
1184
1185     mp = ap->a_head.a_ops->vv_mount;
1186     jreclist_init(mp, &jreclist, &jreccache, JTYPE_WHITEOUT);
1187     error = vop_journal_operate_ap(&ap->a_head);
1188     if (error == 0) {
1189         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1190             jrecord_write_cred(jrec, NULL, ap->a_cred);
1191             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1192         }
1193     }
1194     jreclist_done(mp, &jreclist, error);
1195     return (error);
1196 }
1197
1198 /*
1199  * Journal vop_nremove { a_ncp, a_cred }
1200  */
1201 static
1202 int
1203 journal_nremove(struct vop_nremove_args *ap)
1204 {
1205     struct jrecord_list jreclist;
1206     struct jrecord jreccache;
1207     struct jrecord *jrec;
1208     struct mount *mp;
1209     int error;
1210
1211     mp = ap->a_head.a_ops->vv_mount;
1212     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_REMOVE) &&
1213         ap->a_ncp->nc_vp
1214     ) {
1215         jreclist_undo_file(&jreclist, ap->a_ncp->nc_vp, 
1216                            JRUNDO_ALL|JRUNDO_GETVP|JRUNDO_CONDLINK, 0, -1);
1217     }
1218     error = vop_journal_operate_ap(&ap->a_head);
1219     if (error == 0) {
1220         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1221             jrecord_write_cred(jrec, NULL, ap->a_cred);
1222             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1223         }
1224     }
1225     jreclist_done(mp, &jreclist, error);
1226     return (error);
1227 }
1228
1229 /*
1230  * Journal vop_nmkdir { a_ncp, a_vpp, a_cred, a_vap }
1231  */
1232 static
1233 int
1234 journal_nmkdir(struct vop_nmkdir_args *ap)
1235 {
1236     struct jrecord_list jreclist;
1237     struct jrecord jreccache;
1238     struct jrecord *jrec;
1239     struct mount *mp;
1240     int error;
1241
1242     mp = ap->a_head.a_ops->vv_mount;
1243     jreclist_init(mp, &jreclist, &jreccache, JTYPE_MKDIR);
1244     error = vop_journal_operate_ap(&ap->a_head);
1245     if (error == 0) {
1246         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1247 #if 0
1248             if (jo->flags & MC_JOURNAL_WANT_AUDIT) {
1249                 jrecord_write_audit(jrec);
1250             }
1251 #endif
1252             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1253             jrecord_write_cred(jrec, NULL, ap->a_cred);
1254             jrecord_write_vattr(jrec, ap->a_vap);
1255             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1256             if (*ap->a_vpp)
1257                 jrecord_write_vnode_ref(jrec, *ap->a_vpp);
1258         }
1259     }
1260     jreclist_done(mp, &jreclist, error);
1261     return (error);
1262 }
1263
1264 /*
1265  * Journal vop_nrmdir { a_ncp, a_cred }
1266  */
1267 static
1268 int
1269 journal_nrmdir(struct vop_nrmdir_args *ap)
1270 {
1271     struct jrecord_list jreclist;
1272     struct jrecord jreccache;
1273     struct jrecord *jrec;
1274     struct mount *mp;
1275     int error;
1276
1277     mp = ap->a_head.a_ops->vv_mount;
1278     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_RMDIR)) {
1279         jreclist_undo_file(&jreclist, ap->a_ncp->nc_vp,
1280                            JRUNDO_VATTR|JRUNDO_GETVP, 0, 0);
1281     }
1282     error = vop_journal_operate_ap(&ap->a_head);
1283     if (error == 0) {
1284         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1285             jrecord_write_cred(jrec, NULL, ap->a_cred);
1286             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_ncp);
1287         }
1288     }
1289     jreclist_done(mp, &jreclist, error);
1290     return (error);
1291 }
1292
1293 /*
1294  * Journal vop_nrename { a_fncp, a_tncp, a_cred }
1295  */
1296 static
1297 int
1298 journal_nrename(struct vop_nrename_args *ap)
1299 {
1300     struct jrecord_list jreclist;
1301     struct jrecord jreccache;
1302     struct jrecord *jrec;
1303     struct mount *mp;
1304     int error;
1305
1306     mp = ap->a_head.a_ops->vv_mount;
1307     if (jreclist_init(mp, &jreclist, &jreccache, JTYPE_RENAME) &&
1308         ap->a_tncp->nc_vp
1309     ) {
1310         jreclist_undo_file(&jreclist, ap->a_tncp->nc_vp, 
1311                            JRUNDO_ALL|JRUNDO_GETVP|JRUNDO_CONDLINK, 0, -1);
1312     }
1313     error = vop_journal_operate_ap(&ap->a_head);
1314     if (error == 0) {
1315         TAILQ_FOREACH(jrec, &jreclist.list, user_entry) {
1316             jrecord_write_cred(jrec, NULL, ap->a_cred);
1317             jrecord_write_path(jrec, JLEAF_PATH1, ap->a_fncp);
1318             jrecord_write_path(jrec, JLEAF_PATH2, ap->a_tncp);
1319         }
1320     }
1321     jreclist_done(mp, &jreclist, error);
1322     return (error);
1323 }
1324