static int fifolog_reader_findsync(const struct fifolog_file *ff, off_t *o) { int e; unsigned seq, seqs; assert(*o < ff->logsize); e = fifolog_int_read(ff, *o); if (e) err(1, "Read error (%d) while looking for SYNC", e); seq = be32dec(ff->recbuf); if (*o == 0 && seq == 0) return (0); if (ff->recbuf[4] & FIFOLOG_FLG_SYNC) return (1); /* That was easy... */ while(1) { assert(*o < ff->logsize); (*o)++; seq++; if (*o == ff->logsize) return (2); /* wraparound */ e = fifolog_int_read(ff, *o); if (e) err(1, "Read error (%d) while looking for SYNC", e); seqs = be32dec(ff->recbuf); if (seqs != seq) return (3); /* End of log */ if (ff->recbuf[4] & FIFOLOG_FLG_SYNC) return (1); /* Bingo! */ } }
const char * fifolog_int_findend(const struct fifolog_file *ff, off_t *last) { off_t o, s; int e; unsigned seq0, seq; fifolog_int_file_assert(ff); o = 0; e = fifolog_int_read(ff, o); if (e) return("Read error, first record"); seq0 = be32dec(ff->recbuf); /* If the first records sequence is zero, the fifolog is empty */ if (seq0 == 0) { *last = o; return (NULL); } /* Do a binary search for a discontinuity in the sequence numbers */ s = ff->logsize / 2; do { e = fifolog_int_read(ff, o + s); if (e) return ("Read error while searching"); seq = be32dec(ff->recbuf); if (seq == seq0 + s) { o += s; seq0 = seq; } s /= 2; assert(o < ff->logsize); } while (s > 0); *last = o; return (NULL); }
void fifolog_reader_process(struct fifolog_reader *fr, off_t from, fifolog_reader_render_t *func, void *priv, time_t end) { uint32_t seq, lseq; off_t o = from; int i, e; time_t t; u_char *p, *q; z_stream *zs; CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC); zs = fr->ff->zs; lseq = 0; while (1) { e = fifolog_int_read(fr->ff, o); if (e) err(1, "Read error (%d)", e); if (++o >= fr->ff->logsize) o = 0; seq = be32dec(fr->ff->recbuf); if (lseq != 0 && seq != lseq + 1) break; lseq = seq; zs->avail_in = fr->ff->recsize - 5; zs->next_in = fr->ff->recbuf + 5; if (fr->ff->recbuf[4] & FIFOLOG_FLG_1BYTE) zs->avail_in -= fr->ff->recbuf[fr->ff->recsize - 1]; if (fr->ff->recbuf[4] & FIFOLOG_FLG_4BYTE) zs->avail_in -= be32dec(fr->ff->recbuf + fr->ff->recsize - 4); if (fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC) { i = inflateReset(zs); assert(i == Z_OK); zs->next_out = fr->obuf; zs->avail_out = fr->olen; t = be32dec(fr->ff->recbuf + 5); if (t > end) break; zs->next_in += 4; zs->avail_in -= 4; } while(zs->avail_in > 0) { i = inflate(zs, 0); if (i == Z_BUF_ERROR) { #if 1 fprintf(stderr, "Z_BUF_ERROR [%d,%d] [%d,%d,%d]\n", (int)(zs->next_in - fr->ff->recbuf), zs->avail_in, (int)(zs->next_out - fr->obuf), zs->avail_out, fr->olen); exit (250); #else i = Z_OK; #endif } if (i == Z_STREAM_END) { i = inflateReset(zs); } if (i != Z_OK) { fprintf(stderr, "inflate = %d\n", i); exit (250); } assert(i == Z_OK); if (zs->avail_out != fr->olen) { q = fr->obuf + (fr->olen - zs->avail_out); p = fifolog_reader_chop(fr, func, priv); if (p < q) (void)memmove(fr->obuf, p, q - p); zs->avail_out = fr->olen - (q - p); zs->next_out = fr->obuf + (q - p); } } } }
off_t fifolog_reader_seek(const struct fifolog_reader *fr, time_t t0) { off_t o, s, st; time_t t, tt; unsigned seq, seqs; const char *retval; int e; CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC); /* * First, find the first SYNC block */ o = 0; e = fifolog_reader_findsync(fr->ff, &o); if (e == 0) return (0); /* empty fifolog */ assert(e == 1); assert(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC); seq = be32dec(fr->ff->recbuf); t = be32dec(fr->ff->recbuf + 5); if (t > t0) { /* Check if there is a second older part we can use */ retval = fifolog_int_findend(fr->ff, &s); if (retval != NULL) err(1, "%s", retval); s++; e = fifolog_reader_findsync(fr->ff, &s); if (e == 0) return (0); /* empty fifolog */ if (e == 1) { o = s; seq = be32dec(fr->ff->recbuf); t = be32dec(fr->ff->recbuf + 5); } } /* Now do a binary search to find the sync block right before t0 */ s = st = (fr->ff->logsize - o) / 2; while (s > 1) { /* We know we shouldn't wrap */ if (o + st > fr->ff->logsize + 1) { s = st = s / 2; continue; } e = fifolog_int_read(fr->ff, o + st); if (e) { s = st = s / 2; continue; } /* If not in same part, sequence won't match */ seqs = be32dec(fr->ff->recbuf); if (seqs != seq + st) { s = st = s / 2; continue; } /* If not sync block, try next */ if (!(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC)) { st++; continue; } /* Check timestamp */ tt = be32dec(fr->ff->recbuf + 5); if (tt >= t0) { s = st = s / 2; continue; } o += st; seq = seqs; } fprintf(stderr, "Read from %jx\n", o * fr->ff->recsize); return (o); }
const char * fifolog_write_open(struct fifolog_writer *f, const char *fn, unsigned writerate, unsigned syncrate, unsigned compression) { const char *es; int i; time_t now; off_t o; CHECK_OBJ_NOTNULL(f, FIFOLOG_WRITER_MAGIC); /* Check for legal compression value */ if (compression > Z_BEST_COMPRESSION) return ("Illegal compression value"); f->writerate = writerate; f->syncrate = syncrate; f->compression = compression; /* Reset statistics */ memset(f->cnt, 0, sizeof f->cnt); es = fifolog_int_open(&f->ff, fn, 1); if (es != NULL) return (es); es = fifolog_int_findend(f->ff, &o); if (es != NULL) return (es); i = fifolog_int_read(f->ff, o); if (i) return ("Read error, looking for seq"); f->seq = be32dec(f->ff->recbuf); if (f->seq == 0) { /* Empty fifolog */ f->seq = random(); } else { f->recno = o + 1; f->seq++; } f->obufsize = f->ff->recsize; ALLOC(&f->obuf, f->obufsize); f->ibufsize = f->obufsize * 10; ALLOC(&f->ibuf, f->ibufsize); f->ibufptr = 0; i = deflateInit(f->ff->zs, (int)f->compression); assert(i == Z_OK); f->flag |= FIFOLOG_FLG_RESTART; f->flag |= FIFOLOG_FLG_SYNC; f->ff->zs->next_out = f->obuf + 9; f->ff->zs->avail_out = f->obufsize - 9; time(&now); f->starttime = now; f->lastsync = now; f->lastwrite = now; fifolog_write_assert(f); return (NULL); }