* Fix a number of alignment errors that was causing garbage to be parsed.
[dragonfly.git] / sbin / jscan / dump_mirror.c
1 /*
2  * Copyright (c) 2005 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/sbin/jscan/dump_mirror.c,v 1.2 2005/07/05 02:38:34 dillon Exp $
35  */
36
37 #include "jscan.h"
38
39 static void dump_mirror_stream(struct jstream *js);
40 static int dump_mirror_toprecord(struct jstream *js, off_t *off, 
41                                  off_t recsize, int level);
42 static int dump_mirror_subrecord(struct jstream *js, off_t *off, 
43                                  off_t recsize, int level, struct jattr *jattr);
44 static int dump_mirror_payload(int16_t rectype, struct jstream *js, off_t off,
45                                  int recsize, int level, struct jattr *jattr);
46 static int dump_mirror_rebuild(u_int16_t rectype, struct jstream *js, struct jattr *jattr);
47
48 void
49 dump_mirror(struct jfile *jf)
50 {
51     struct jstream *js;
52
53     while ((js = jscan_stream(jf)) != NULL) {
54         dump_mirror_stream(js);
55         jscan_dispose(js);
56     }
57 }
58
59 static void
60 dump_mirror_stream(struct jstream *js)
61 {
62         struct journal_rawrecbeg head;
63         int16_t sid;
64         mode_t save_umask;
65
66         save_umask = umask(0);
67         jsread(js, 0, &head, sizeof(head));
68
69         sid = head.streamid & JREC_STREAMID_MASK;
70         if (debug_opt) {
71             printf("STREAM %04x DATA (%lld) {\n",
72                 (int)(u_int16_t)head.streamid, js->js_normalized_total);
73         }
74         if (sid >= JREC_STREAMID_JMIN && sid < JREC_STREAMID_JMAX) {
75             off_t off = sizeof(head);
76             dump_mirror_toprecord(js, &off, js->js_normalized_total -
77                                   sizeof(struct journal_rawrecbeg), 
78                                   1);
79         } else {
80             switch(head.streamid & JREC_STREAMID_MASK) {
81             case JREC_STREAMID_SYNCPT & JREC_STREAMID_MASK:
82                 if (debug_opt)
83                     printf("    SYNCPT\n");
84                 break;
85             case JREC_STREAMID_PAD & JREC_STREAMID_MASK:
86                 if (debug_opt)
87                     printf("    PAD\n");
88                 break;
89             case JREC_STREAMID_DISCONT & JREC_STREAMID_MASK:
90                 if (debug_opt)
91                     printf("    DISCONT\n");
92                 break;
93             case JREC_STREAMID_ANNOTATE & JREC_STREAMID_MASK:
94                 if (debug_opt)
95                     printf("    ANNOTATION\n");
96                 break;
97             default:
98                 if (debug_opt)
99                     printf("    UNKNOWN\n");
100                 break;
101             }
102         }
103         umask(save_umask);
104         if (debug_opt) {
105             printf("}\n");
106             fflush(stdout);
107         }
108 }
109
110 static int
111 dump_mirror_toprecord(struct jstream *js, off_t *off, off_t recsize, int level)
112 {
113     struct journal_subrecord sub;
114     struct jattr jattr;
115     int payload;
116     int subsize;
117     int error;
118     off_t base = *off;
119
120     error = 0;
121     bzero(&jattr, sizeof(jattr));
122     jattr_reset(&jattr);
123
124     while (recsize > 0) {
125         if ((error = jsread(js, base, &sub, sizeof(sub))) != 0)
126             break;
127         if (debug_opt) {
128             printf("%*.*s", level * 4, level * 4, "");
129             printf("@%lld ", base);
130             printf("RECORD %s [%04x/%d]", type_to_name(sub.rectype), 
131                    (int)(u_int16_t)sub.rectype, sub.recsize);
132         }
133         if (sub.recsize == -1) {
134             if ((sub.rectype & JMASK_NESTED) == 0) {
135                 printf("Record size of -1 only works for nested records\n");
136                 error = -1;
137                 break;
138             }
139             payload = 0x7FFFFFFF;
140             subsize = 0x7FFFFFFF;
141         } else {
142             payload = sub.recsize - sizeof(sub);
143             subsize = (sub.recsize + 7) & ~7;
144         }
145         if (sub.rectype & JMASK_NESTED) {
146             if (debug_opt)
147                 printf(" {\n");
148             *off = base + sizeof(sub);
149             error = dump_mirror_subrecord(js, off,
150                                           payload, level + 1, &jattr);
151             if (debug_opt)
152                 printf("%*.*s}\n", level * 4, level * 4, "");
153         } else if (sub.rectype & JMASK_SUBRECORD) {
154             if (debug_opt) {
155                 printf(" DATA (%d)", payload);
156                 error = dump_debug_payload(sub.rectype, js, base + sizeof(sub), payload, level);
157             }
158             *off = base + sizeof(sub) + payload;
159             if (debug_opt)
160                 printf("\n");
161         } else if ((sub.rectype & JTYPE_MASK) == JLEAF_PAD) {
162             if (debug_opt) {
163                 if (payload)
164                     printf(" DATA (%d)", payload);
165                 printf("\n");
166             }
167         } else {
168             if (debug_opt)
169                 printf("[%d bytes of unknown content]\n", payload);
170         }
171         dump_mirror_rebuild(sub.rectype, js, &jattr);
172         jattr_reset(&jattr);
173         if (error)
174             break;
175         if (sub.recsize == -1) {
176             if ((sub.rectype & JMASK_NESTED) == 0) {
177                 printf("Record size of -1 only works for nested records\n");
178                 error = -1;
179                 break;
180             }
181             recsize -= ((*off + 7) & ~7) - base;
182             base = (*off + 7) & ~7;
183         } else {
184             if (subsize == 0)
185                 subsize = sizeof(sub);
186             recsize -= subsize;
187             base += subsize;
188         }
189         if (sub.rectype & JMASK_LAST)
190             break;
191     }
192     *off = base;
193     return(error);
194 }
195
196 static int
197 dump_mirror_subrecord(struct jstream *js, off_t *off, off_t recsize, int level,
198                       struct jattr *jattr)
199 {
200     struct journal_subrecord sub;
201     int payload;
202     int subsize;
203     int error;
204     u_int16_t rectype;
205     off_t base = *off;
206
207     error = 0;
208     while (recsize > 0) {
209         if ((error = jsread(js, base, &sub, sizeof(sub))) != 0)
210             break;
211         rectype = sub.rectype & JTYPE_MASK;
212         if (debug_opt) {
213             printf("%*.*s", level * 4, level * 4, "");
214             printf("@%lld ", base);
215             printf("SRECORD %s [%04x/%d]", type_to_name(sub.rectype), 
216                    (int)(u_int16_t)sub.rectype, sub.recsize);
217         }
218         if (sub.recsize == -1) {
219             payload = 0x7FFFFFFF;
220             subsize = 0x7FFFFFFF;
221         } else {
222             payload = sub.recsize - sizeof(sub);
223             subsize = (sub.recsize + 7) & ~7;
224         }
225         if (sub.rectype & JMASK_NESTED) {
226             if (debug_opt)
227                 printf(" {\n");
228
229             /*
230              * Only recurse through vattr records.  XXX currently assuming
231              * only on VATTR subrecord.
232              */
233             *off = base + sizeof(sub);
234             if (payload && rectype == JTYPE_VATTR) {
235                 error = dump_mirror_subrecord(js, off, 
236                                               payload, level + 1, jattr);
237             } else {
238                 error = dump_mirror_subrecord(js, off, 
239                                               payload, level + 1, NULL);
240             }
241             if (debug_opt)
242                 printf("%*.*s}\n", level * 4, level * 4, "");
243         } else if (sub.rectype & JMASK_SUBRECORD) {
244             if (debug_opt) {
245                 printf(" DATA (%d)", payload);
246                 dump_debug_payload(sub.rectype, js, base + sizeof(sub), 
247                                    payload, level);
248             }
249             error = dump_mirror_payload(sub.rectype, js, base + sizeof(sub),
250                                        payload, level, jattr);
251             *off = base + sizeof(sub) + payload;
252             if (debug_opt)
253                 printf("\n");
254         } else if ((sub.rectype & JTYPE_MASK) == JLEAF_PAD) {
255             if (debug_opt) {
256                 if (payload)
257                     printf(" DATA (%d)", payload);
258                 printf("\n");
259             }
260         } else {
261             if (debug_opt)
262                 printf("[%d bytes of unknown content]\n", sub.recsize);
263         }
264         if (error)
265             break;
266         if (sub.recsize == -1) {
267             recsize -= ((*off + 7) & ~7) - base;
268             base = (*off + 7) & ~7;
269         } else {
270             if (subsize == 0)
271                 subsize = sizeof(sub);
272             recsize -= subsize;
273             base += subsize;
274         }
275         if (sub.rectype & JMASK_LAST)
276             break;
277     }
278     *off = base;
279     return(error);
280 }
281
282 static int
283 dump_mirror_payload(int16_t rectype, struct jstream *js, off_t off, 
284              int recsize, int level __unused, struct jattr *jattr)
285 {
286     const char *buf;
287     struct jattr_data *data;
288     int error;
289
290     if (jattr == NULL)
291         return (0);
292
293     if ((rectype & ~JMASK_LAST) != JLEAF_FILEDATA) {
294         error = jsreadp(js, off, (const void **)&buf, recsize);
295         if (error)
296             return (error);
297     } else {
298         buf = NULL;
299         error = 0;
300     }
301
302     switch(rectype & ~JMASK_LAST) {
303     case JLEAF_PAD:
304     case JLEAF_ABORT:
305         break;
306     case JLEAF_SYMLINKDATA:
307     case JLEAF_FILEDATA:
308         printf("DOING FILEDATA1 %p  off %08llx bytes %d\n", jattr->last_data, off, recsize);
309         if ((data = jattr->last_data) == NULL) {
310                 jattr->data.off = off;
311                 jattr->data.bytes = recsize;
312                 jattr->last_data = &jattr->data;
313         } else {
314                 data->next = malloc(sizeof(jattr->data));
315                 data = data->next;
316                 data->off = off;
317                 data->bytes = recsize;
318                 data->next = NULL;
319                 jattr->last_data = data;
320         }
321         printf("DOING FILEDATA2 %p\n", jattr->last_data);
322         break;
323     case JLEAF_PATH1:
324         jattr->path1 = dupdatapath(buf, recsize);
325         break;
326     case JLEAF_PATH2:
327         jattr->path2 = dupdatapath(buf, recsize);
328         break;
329     case JLEAF_PATH3:
330         jattr->path3 = dupdatapath(buf, recsize);
331         break;
332     case JLEAF_PATH4:
333         jattr->path4 = dupdatapath(buf, recsize);
334         break;
335     case JLEAF_UID:
336         jattr->uid = buf_to_int64(buf, recsize);
337         break;
338     case JLEAF_GID:
339         jattr->gid = buf_to_int64(buf, recsize);
340         break;
341     case JLEAF_VTYPE:
342         jattr->vtype = buf_to_int64(buf, recsize);
343         break;
344     case JLEAF_MODES:
345         jattr->modes = buf_to_int64(buf, recsize);
346         break;
347     case JLEAF_FFLAGS:
348         jattr->fflags = buf_to_int64(buf, recsize);
349         break;
350     case JLEAF_PID:
351         jattr->pid = buf_to_int64(buf, recsize);
352         break;
353     case JLEAF_PPID:
354         jattr->ppid = buf_to_int64(buf, recsize);
355         break;
356     case JLEAF_COMM:
357         jattr->comm = dupdatastr(buf, recsize);
358         break;
359     case JLEAF_ATTRNAME:
360         jattr->attrname = dupdatastr(buf, recsize);
361         break;
362     case JLEAF_PATH_REF:
363         jattr->pathref = dupdatapath(buf, recsize);
364         break;
365     case JLEAF_RESERVED_0F:
366         break;
367     case JLEAF_SEEKPOS:
368         jattr->seekpos = buf_to_int64(buf, recsize);
369         break;
370     case JLEAF_INUM:
371         jattr->inum = buf_to_int64(buf, recsize);
372         break;
373     case JLEAF_NLINK:
374         jattr->nlink = buf_to_int64(buf, recsize);
375         break;
376     case JLEAF_FSID:
377         jattr->fsid = buf_to_int64(buf, recsize);
378         break;
379     case JLEAF_SIZE:
380         jattr->size = buf_to_int64(buf, recsize);
381         break;
382     case JLEAF_ATIME:
383         jattr->atime = *(const struct timeval *)buf;
384         break;
385     case JLEAF_MTIME:
386         jattr->mtime = *(const struct timeval *)buf;
387         break;
388     case JLEAF_CTIME:
389         jattr->ctime = *(const struct timeval *)buf;
390         break;
391     case JLEAF_GEN:
392         jattr->gen = buf_to_int64(buf, recsize);
393         break;
394     case JLEAF_FLAGS:
395         jattr->flags = buf_to_int64(buf, recsize);
396         break;
397     case JLEAF_UDEV:
398         jattr->udev = buf_to_int64(buf, recsize);
399         break;
400     case JLEAF_FILEREV:
401         jattr->filerev = buf_to_int64(buf, recsize);
402         break;
403     default:
404         break;
405     }
406     return (0);
407 }
408
409 static int
410 dump_mirror_rebuild(u_int16_t rectype, struct jstream *js, struct jattr *jattr)
411 {
412     struct jattr_data *data;
413     int error = 0;
414     int fd;
415
416 again:
417     switch(rectype) {
418     case JTYPE_SETATTR:
419         if (jattr->pathref) {
420             if (jattr->uid != (uid_t)-1)
421                 chown(jattr->pathref, jattr->uid, -1);
422             if (jattr->gid != (gid_t)-1)
423                 chown(jattr->pathref, -1, jattr->gid);
424             if (jattr->modes != (mode_t)-1)
425                 chmod(jattr->pathref, jattr->modes);
426             if (jattr->fflags != -1)
427                 chflags(jattr->pathref, jattr->fflags);
428             if (jattr->size != -1)
429                 truncate(jattr->pathref, jattr->size);
430         }
431         break;
432     case JTYPE_WRITE:
433     case JTYPE_PUTPAGES:
434         if (jattr->pathref && jattr->seekpos != -1) {
435             if ((fd = open(jattr->pathref, O_RDWR)) >= 0) {
436                 lseek(fd, jattr->seekpos, 0);
437                 for (data = &jattr->data; data; data = data->next) {
438                     printf("WRITEBLOCK @ %016llx/%d\n", data->off, data->bytes);
439                     if (data->bytes)
440                         jsreadcallback(js, write, fd, data->off, data->bytes);
441                 }
442                 close(fd);
443             }
444         }
445         break;
446     case JTYPE_SETACL:
447         break;
448     case JTYPE_SETEXTATTR:
449         break;
450     case JTYPE_CREATE:
451         /*
452          * note: both path1 and pathref will exist.
453          */
454         if (jattr->path1 && jattr->modes != (mode_t)-1) {
455             if ((fd = open(jattr->path1, O_CREAT, jattr->modes)) >= 0) {
456                 close(fd);
457                 rectype = JTYPE_SETATTR;
458                 goto again;
459             }
460         }
461         break;
462     case JTYPE_MKNOD:
463         break;
464     case JTYPE_LINK:
465         break;
466     case JTYPE_SYMLINK:
467         break;
468     case JTYPE_WHITEOUT:
469         break;
470     case JTYPE_REMOVE:
471         if (jattr->path1) {
472             remove(jattr->path1);
473         }
474         break;
475     case JTYPE_MKDIR:
476         if (jattr->path1 && jattr->modes != (mode_t)-1) {
477             mkdir(jattr->path1, jattr->modes);
478         }
479         break;
480     case JTYPE_RMDIR:
481         if (jattr->path1) {
482             rmdir(jattr->path1);
483         }
484         break;
485     case JTYPE_RENAME:
486         if (jattr->path1 && jattr->path2) {
487             rename(jattr->path1, jattr->path2);
488         }
489         break;
490     }
491     return(error);
492 }
493