gzlog.c File Reference

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/time.h>
#include "zlib.h"
#include "gzlog.h"

Go to the source code of this file.

Classes
struct	log

Macros
#define	local   static
#define	BAIL(n)
#define	PATIENCE   300
#define	MAX_STORE   16
#define	TRIGGER   1024
#define	DICT   32768U
#define	NO_OP   0
#define	APPEND_OP   1
#define	COMPRESS_OP   2
#define	REPLACE_OP   3
#define	PULL2(p)   ((p)[0]+((uint)((p)[1])<<8))
#define	PULL4(p)   (PULL2(p)+((ulong)PULL2(p+2)<<16))
#define	PULL8(p)   (PULL4(p)+((off_t)PULL4(p+4)<<32))
#define	PUT2(p, a)   do {(p)[0]=a;(p)[1]=(a)>>8;} while(0)
#define	PUT4(p, a)   do {PUT2(p,a);PUT2(p+2,a>>16);} while(0)
#define	PUT8(p, a)   do {PUT4(p,a);PUT4(p+4,a>>32);} while(0)
#define	LOGID   "\106\035\172" /* should be three non-zero characters */
#define	HEAD   sizeof(log_gzhead) /* should be 16 */
#define	EXTRA   sizeof(log_gzext) /* should be 35 */
#define	BODY   sizeof(log_gzbody)

Typedefs
typedef unsigned int	uint
typedef unsigned long	ulong

Functions
int	log_lock (struct log *log)
void	log_touch (struct log *log)
int	log_check (struct log *log)
void	log_unlock (struct log *log)
int	log_head (struct log *log)
int	log_mark (struct log *log, int op)
int	log_last (struct log *log, int last)
int	log_append (struct log *log, unsigned char *data, size_t len)
int	log_replace (struct log *log)
int	log_compress (struct log *log, unsigned char *data, size_t len)
void	log_log (struct log *log, int op, char *record)
int	log_recover (struct log *log, int op)
void	log_close (struct log *log)
int	log_open (struct log *log)
gzlog *	gzlog_open (char *path)
int	gzlog_compress (gzlog *logd)
int	gzlog_write (gzlog *logd, void *data, size_t len)
int	gzlog_close (gzlog *logd)

Variables
unsigned char	log_gzhead []
unsigned char	log_gzext []
unsigned char	log_gzbody []

Macro Definition Documentation

APPEND_OP

#define APPEND_OP   1

Definition at line 273 of file gzlog.c.

BAIL

#define BAIL

(

n

)

Definition at line 254 of file gzlog.c.

BODY

#define BODY   sizeof(log_gzbody)

Definition at line 337 of file gzlog.c.

COMPRESS_OP

#define COMPRESS_OP   2

Definition at line 274 of file gzlog.c.

DICT

#define DICT   32768U

Definition at line 269 of file gzlog.c.

EXTRA

#define EXTRA   sizeof(log_gzext) /* should be 35 */

Definition at line 328 of file gzlog.c.

HEAD

#define HEAD   sizeof(log_gzhead) /* should be 16 */

Definition at line 316 of file gzlog.c.

local

#define local   static

Definition at line 241 of file gzlog.c.

LOGID

#define LOGID   "\106\035\172" /* should be three non-zero characters */

Definition at line 288 of file gzlog.c.

MAX_STORE

#define MAX_STORE   16

Definition at line 261 of file gzlog.c.

NO_OP

#define NO_OP   0

Definition at line 272 of file gzlog.c.

PATIENCE

#define PATIENCE   300

Definition at line 258 of file gzlog.c.

PULL2

#define PULL2

(

p

)

((p)[0]+((uint)((p)[1])<<8))

Definition at line 278 of file gzlog.c.

PULL4

#define PULL4

(

p

)

(PULL2(p)+((ulong)PULL2(p+2)<<16))

Definition at line 279 of file gzlog.c.

PULL8

#define PULL8

(

p

)

(PULL4(p)+((off_t)PULL4(p+4)<<32))

Definition at line 280 of file gzlog.c.

PUT2

#define PUT2	(		p,
			a
	)		do {(p)[0]=a;(p)[1]=(a)>>8;} while(0)

Definition at line 283 of file gzlog.c.

PUT4

#define PUT4	(		p,
			a
	)		do {PUT2(p,a);PUT2(p+2,a>>16);} while(0)

Definition at line 284 of file gzlog.c.

PUT8

#define PUT8	(		p,
			a
	)		do {PUT4(p,a);PUT4(p+4,a>>32);} while(0)

Definition at line 285 of file gzlog.c.

REPLACE_OP

#define REPLACE_OP   3

Definition at line 275 of file gzlog.c.

TRIGGER

#define TRIGGER   1024

Definition at line 266 of file gzlog.c.

Typedef Documentation

uint

typedef unsigned int uint

Definition at line 242 of file gzlog.c.

ulong

typedef unsigned long ulong

Definition at line 243 of file gzlog.c.

Function Documentation

gzlog_close()

int gzlog_close

(

gzlog *

logd

)

Definition at line 1044 of file gzlog.c.

{
    struct log *log = logd;
 
    /* check arguments */
    if (log == NULL || strcmp(log->id, LOGID))
        return -3;
 
    /* close the log file and release the lock */
    log_close(log);
 
    /* free structure and return */
    if (log->path != NULL)
        free(log->path);
    strcpy(log->id, "bad");
    free(log);
    return 0;
}

References free(), log::id, log_close(), LOGID, NULL, and log::path.

gzlog_compress()

int gzlog_compress

(

gzlog *

logd

)

Definition at line 910 of file gzlog.c.

{
    int fd, ret;
    uint block;
    size_t len, next;
    unsigned char *data, buf[5];
    struct log *log = logd;
 
    /* check arguments */
    if (log == NULL || strcmp(log->id, LOGID))
        return -3;
 
    /* see if we lost the lock -- if so get it again and reload the extra
       field information (it probably changed), recover last operation if
       necessary */
    if (log_check(log) && log_open(log))
        return -1;
 
    /* create space for uncompressed data */
    len = ((size_t)(log->last - log->first) & ~(((size_t)1 << 10) - 1)) +
          log->stored;
    if ((data = malloc(len)) == NULL)
        return -2;
 
    /* do statement here is just a cheap trick for error handling */
    do {
        /* read in the uncompressed data */
        if (lseek(log->fd, log->first - 1, SEEK_SET) < 0)
            break;
        next = 0;
        while (next < len) {
            if (read(log->fd, buf, 5) != 5)
                break;
            block = PULL2(buf + 1);
            if (next + block > len ||
                read(log->fd, (char *)data + next, block) != block)
                break;
            next += block;
        }
        if (lseek(log->fd, 0, SEEK_CUR) != log->last + 4 + log->stored)
            break;
        log_touch(log);
 
        /* write the uncompressed data to the .add file */
        strcpy(log->end, ".add");
        fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
        if (fd < 0)
            break;
        ret = (size_t)write(fd, data, len) != len;
        if (ret | close(fd))
            break;
        log_touch(log);
 
        /* write the dictionary for the next compress to the .temp file */
        strcpy(log->end, ".temp");
        fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
        if (fd < 0)
            break;
        next = DICT > len ? len : DICT;
        ret = (size_t)write(fd, (char *)data + len - next, next) != next;
        if (ret | close(fd))
            break;
        log_touch(log);
 
        /* roll back to compressed data, mark the compress in progress */
        log->last = log->first;
        log->stored = 0;
        if (log_mark(log, COMPRESS_OP))
            break;
        BAIL(7);
 
        /* compress and append the data (clears mark) */
        ret = log_compress(log, data, len);
        free(data);
        return ret;
    } while (0);
 
    /* broke out of do above on i/o error */
    free(data);
    return -1;
}

References BAIL, close, COMPRESS_OP, DICT, log::end, fd, log::fd, log::first, free(), log::id, log::last, len, log_check(), log_compress(), log_mark(), log_open(), log_touch(), LOGID, lseek, malloc(), NULL, O_CREAT, O_TRUNC, O_WRONLY, log::path, PULL2, read(), SEEK_CUR, SEEK_SET, log::stored, and write.

Referenced by gzlog_write().

gzlog_open()

gzlog* gzlog_open

(

char *

path

)

Definition at line 867 of file gzlog.c.

{
    size_t n;
    struct log *log;
 
    /* check arguments */
    if (path == NULL || *path == 0)
        return NULL;
 
    /* allocate and initialize log structure */
    log = malloc(sizeof(struct log));
    if (log == NULL)
        return NULL;
    strcpy(log->id, LOGID);
    log->fd = -1;
 
    /* save path and end of path for name construction */
    n = strlen(path);
    log->path = malloc(n + 9);              /* allow for ".repairs" */
    if (log->path == NULL) {
        free(log);
        return NULL;
    }
    strcpy(log->path, path);
    log->end = log->path + n;
 
    /* gain exclusive access and verify log file -- may perform a
       recovery operation if needed */
    if (log_open(log)) {
        free(log->path);
        free(log);
        return NULL;
    }
 
    /* return pointer to log structure */
    return log;
}

References log::end, log::fd, free(), log::id, test-lz4-list::log(), log_open(), LOGID, malloc(), n, NULL, path, and log::path.

gzlog_write()

int gzlog_write	(	gzlog *	logd,
		void *	data,
		size_t	len
	)

Definition at line 997 of file gzlog.c.

{
    int fd, ret;
    struct log *log = logd;
 
    /* check arguments */
    if (log == NULL || strcmp(log->id, LOGID))
        return -3;
    if (data == NULL || len <= 0)
        return 0;
 
    /* see if we lost the lock -- if so get it again and reload the extra
       field information (it probably changed), recover last operation if
       necessary */
    if (log_check(log) && log_open(log))
        return -1;
 
    /* create and write .add file */
    strcpy(log->end, ".add");
    fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0)
        return -1;
    ret = (size_t)write(fd, data, len) != len;
    if (ret | close(fd))
        return -1;
    log_touch(log);
 
    /* mark log file with append in progress */
    if (log_mark(log, APPEND_OP))
        return -1;
    BAIL(8);
 
    /* append data (clears mark) */
    if (log_append(log, data, len))
        return -1;
 
    /* check to see if it's time to compress -- if not, then done */
    if (((log->last - log->first) >> 10) + (log->stored >> 10) < TRIGGER)
        return 0;
 
    /* time to compress */
    return gzlog_compress(log);
}

References APPEND_OP, BAIL, close, log::end, fd, log::first, gzlog_compress(), log::id, log::last, len, log_append(), log_check(), log_mark(), log_open(), log_touch(), LOGID, NULL, O_CREAT, O_TRUNC, O_WRONLY, log::path, log::stored, TRIGGER, and write.

log_append()

int log_append	(	struct log *	log,
		unsigned char *	data,
		size_t	len
	)

Definition at line 501 of file gzlog.c.

{
    uint put;
    off_t end;
    unsigned char buf[8];
 
    /* set the last block last-bit and length, in case recovering an
       interrupted append, then position the file pointer to append to the
       block */
    if (log_last(log, 1))
        return -1;
 
    /* append, adding stored blocks and updating the offset of the last stored
       block as needed, and update the total crc and length */
    while (len) {
        /* append as much as we can to the last block */
        put = (MAX_STORE << 10) - log->stored;
        if (put > len)
            put = (uint)len;
        if (put) {
            if (write(log->fd, data, put) != put)
                return -1;
            BAIL(1);
            log->tcrc = crc32(log->tcrc, data, put);
            log->tlen += put;
            log->stored += put;
            data += put;
            len -= put;
        }
 
        /* if we need to, add a new empty stored block */
        if (len) {
            /* mark current block as not last */
            if (log_last(log, 0))
                return -1;
 
            /* point to new, empty stored block */
            log->last += 4 + log->stored + 1;
            log->stored = 0;
        }
 
        /* mark last block as last, update its length */
        if (log_last(log, 1))
            return -1;
        BAIL(2);
    }
 
    /* write the new crc and length trailer, and truncate just in case (could
       be recovering from partial append with a missing foo.add file) */
    PUT4(buf, log->tcrc);
    PUT4(buf + 4, log->tlen);
    if (write(log->fd, buf, 8) != 8 ||
        (end = lseek(log->fd, 0, SEEK_CUR)) < 0 || ftruncate(log->fd, end))
        return -1;
 
    /* write the extra field, marking the log file as done, delete .add file */
    if (log_mark(log, NO_OP))
        return -1;
    strcpy(log->end, ".add");
    unlink(log->path);          /* ignore error, since may not exist */
    return 0;
}

References BAIL, crc32(), test_evm::end, log::end, log::fd, ftruncate, if(), log::last, len, log_last(), log_mark(), lseek, MAX_STORE, NO_OP, log::path, PUT4, SEEK_CUR, log::stored, log::tcrc, log::tlen, unlink, and write.

Referenced by gzlog_write(), and log_recover().

log_check()

int log_check

(

struct log *

log

)

Definition at line 384 of file gzlog.c.

{
    struct stat st;
 
    strcpy(log->end, ".lock");
    if (stat(log->path, &st) || st.st_mtime != log->lock)
        return 1;
    log_touch(log);
    return 0;
}

References log::end, log::lock, log_touch(), log::path, and stat.

Referenced by gzlog_compress(), gzlog_write(), and log_unlock().

log_close()

void log_close

(

struct log *

log

)

Definition at line 798 of file gzlog.c.

{
    if (log->fd >= 0)
        close(log->fd);
    log->fd = -1;
    log_unlock(log);
}

References close, log::fd, and log_unlock().

Referenced by gzlog_close(), and log_open().

log_compress()

int log_compress	(	struct log *	log,
		unsigned char *	data,
		size_t	len
	)

Definition at line 608 of file gzlog.c.

{
    int fd;
    uint got, max;
    ssize_t dict;
    off_t end;
    z_stream strm;
    unsigned char buf[DICT];
 
    /* compress and append compressed data */
    if (len) {
        /* set up for deflate, allocating memory */
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        if (deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8,
                         Z_DEFAULT_STRATEGY) != Z_OK)
            return -2;
 
        /* read in dictionary (last 32K of data that was compressed) */
        strcpy(log->end, ".dict");
        fd = open(log->path, O_RDONLY, 0);
        if (fd >= 0) {
            dict = read(fd, buf, DICT);
            close(fd);
            if (dict < 0) {
                deflateEnd(&strm);
                return -1;
            }
            if (dict)
                deflateSetDictionary(&strm, buf, (uint)dict);
        }
        log_touch(log);
 
        /* prime deflate with last bits of previous block, position write
           pointer to write those bits and overwrite what follows */
        if (lseek(log->fd, log->first - (log->back > 8 ? 2 : 1),
                SEEK_SET) < 0 ||
            read(log->fd, buf, 1) != 1 || lseek(log->fd, -1, SEEK_CUR) < 0) {
            deflateEnd(&strm);
            return -1;
        }
        deflatePrime(&strm, (8 - log->back) & 7, *buf);
 
        /* compress, finishing with a partial non-last empty static block */
        strm.next_in = data;
        max = (((uint)0 - 1) >> 1) + 1; /* in case int smaller than size_t */
        do {
            strm.avail_in = len > max ? max : (uint)len;
            len -= strm.avail_in;
            do {
                strm.avail_out = DICT;
                strm.next_out = buf;
                deflate(&strm, len ? Z_NO_FLUSH : Z_PARTIAL_FLUSH);
                got = DICT - strm.avail_out;
                if (got && write(log->fd, buf, got) != got) {
                    deflateEnd(&strm);
                    return -1;
                }
                log_touch(log);
            } while (strm.avail_out == 0);
        } while (len);
        deflateEnd(&strm);
        BAIL(5);
 
        /* find start of empty static block -- scanning backwards the first one
           bit is the second bit of the block, if the last byte is zero, then
           we know the byte before that has a one in the top bit, since an
           empty static block is ten bits long */
        if ((log->first = lseek(log->fd, -1, SEEK_CUR)) < 0 ||
            read(log->fd, buf, 1) != 1)
            return -1;
        log->first++;
        if (*buf) {
            log->back = 1;
            while ((*buf & ((uint)1 << (8 - log->back++))) == 0)
                ;       /* guaranteed to terminate, since *buf != 0 */
        }
        else
            log->back = 10;
 
        /* update compressed crc and length */
        log->ccrc = log->tcrc;
        log->clen = log->tlen;
    }
    else {
        /* no data to compress -- fix up existing gzip stream */
        log->tcrc = log->ccrc;
        log->tlen = log->clen;
    }
 
    /* complete and truncate gzip stream */
    log->last = log->first;
    log->stored = 0;
    PUT4(buf, log->tcrc);
    PUT4(buf + 4, log->tlen);
    if (log_last(log, 1) || write(log->fd, buf, 8) != 8 ||
        (end = lseek(log->fd, 0, SEEK_CUR)) < 0 || ftruncate(log->fd, end))
        return -1;
    BAIL(6);
 
    /* mark as being in the replace operation */
    if (log_mark(log, REPLACE_OP))
        return -1;
 
    /* execute the replace operation and mark the file as done */
    return log_replace(log);
}

References lzma_stream::avail_in, lzma_stream::avail_out, log::back, BAIL, log::ccrc, log::clen, close, deflate(), deflateEnd(), deflateInit2, deflatePrime(), deflateSetDictionary(), DICT, test_evm::end, log::end, fd, log::fd, log::first, ftruncate, log::last, len, log_last(), log_mark(), log_replace(), log_touch(), lseek, max, lzma_stream::next_in, lzma_stream::next_out, O_RDONLY, log::path, PUT4, read(), REPLACE_OP, SEEK_CUR, SEEK_SET, log::stored, strm, log::tcrc, log::tlen, write, Z_DEFAULT_COMPRESSION, Z_DEFAULT_STRATEGY, Z_DEFLATED, Z_NO_FLUSH, Z_NULL, Z_OK, and Z_PARTIAL_FLUSH.

Referenced by gzlog_compress(), and log_recover().

log_head()

int log_head

(

struct log *

log

)

Definition at line 410 of file gzlog.c.

{
    int op;
    unsigned char buf[HEAD + EXTRA];
 
    if (lseek(log->fd, 0, SEEK_SET) < 0 ||
        read(log->fd, buf, HEAD + EXTRA) != HEAD + EXTRA ||
        memcmp(buf, log_gzhead, HEAD)) {
        return -1;
    }
    log->first = PULL8(buf + HEAD);
    log->last = PULL8(buf + HEAD + 8);
    log->ccrc = PULL4(buf + HEAD + 16);
    log->clen = PULL4(buf + HEAD + 20);
    log->tcrc = PULL4(buf + HEAD + 24);
    log->tlen = PULL4(buf + HEAD + 28);
    log->stored = PULL2(buf + HEAD + 32);
    log->back = 3 + (buf[HEAD + 34] & 7);
    op = (buf[HEAD + 34] >> 3) & 3;
    return op;
}

References log::back, log::ccrc, log::clen, EXTRA, log::fd, log::first, HEAD, log::last, log_gzhead, lseek, op, PULL2, PULL4, PULL8, read(), SEEK_SET, log::stored, log::tcrc, and log::tlen.

Referenced by log_open().

log_last()

int log_last	(	struct log *	log,
		int	last
	)

Definition at line 462 of file gzlog.c.

{
    int back, len, mask;
    unsigned char buf[6];
 
    /* determine the locations of the bytes and bits to modify */
    back = log->last == log->first ? log->back : 8;
    len = back > 8 ? 2 : 1;                 /* bytes back from log->last */
    mask = 0x80 >> ((back - 1) & 7);        /* mask for block last-bit */
 
    /* get the byte to modify (one or two back) into buf[0] -- don't need to
       read the byte if the last-bit is eight bits back, since in that case
       the entire byte will be modified */
    buf[0] = 0;
    if (back != 8 && (lseek(log->fd, log->last - len, SEEK_SET) < 0 ||
                      read(log->fd, buf, 1) != 1))
        return -1;
 
    /* change the last-bit of the last stored block as requested -- note
       that all bits above the last-bit are set to zero, per the type bits
       of a stored block being 00 and per the convention that the bits to
       bring the stream to a byte boundary are also zeros */
    buf[1] = 0;
    buf[2 - len] = (*buf & (mask - 1)) + (last ? mask : 0);
 
    /* write the modified stored block header and lengths, move the file
       pointer to after the last stored block data */
    PUT2(buf + 2, log->stored);
    PUT2(buf + 4, log->stored ^ 0xffff);
    return lseek(log->fd, log->last - len, SEEK_SET) < 0 ||
           write(log->fd, buf + 2 - len, len + 4) != len + 4 ||
           lseek(log->fd, log->stored, SEEK_CUR) < 0 ? -1 : 0;
}

References log::back, log::fd, log::first, log::last, len, lseek, mask, PUT2, read(), SEEK_CUR, SEEK_SET, log::stored, and write.

Referenced by log_append(), and log_compress().

log_lock()

int log_lock

(

struct log *

log

)

Definition at line 348 of file gzlog.c.

{
    int fd;
    struct stat st;
 
    strcpy(log->end, ".lock");
    while ((fd = open(log->path, O_CREAT | O_EXCL, 0644)) < 0) {
        if (errno != EEXIST)
            return -1;
        if (stat(log->path, &st) == 0 && time(NULL) - st.st_mtime > PATIENCE) {
            unlink(log->path);
            continue;
        }
        sleep(2);       /* relinquish the CPU for two seconds while waiting */
    }
    close(fd);
    if (stat(log->path, &st) == 0)
        log->lock = st.st_mtime;
    return 0;
}

References close, EEXIST, log::end, fd, log::lock, NULL, O_CREAT, O_EXCL, log::path, PATIENCE, stat, time, and unlink.

Referenced by log_open().

log_log()

void log_log	(	struct log *	log,
		int	op,
		char *	record
	)

Definition at line 718 of file gzlog.c.

{
    time_t now;
    FILE *rec;
 
    now = time(NULL);
    strcpy(log->end, ".repairs");
    rec = fopen(log->path, "a");
    if (rec == NULL)
        return;
    fprintf(rec, "%.24s %s recovery: %s\n", ctime(&now), op == APPEND_OP ?
            "append" : (op == COMPRESS_OP ? "compress" : "replace"), record);
    fclose(rec);
    return;
}

References APPEND_OP, COMPRESS_OP, log::end, benchmark::FILE, NULL, log::path, and time.

Referenced by log_recover().

log_mark()

int log_mark	(	struct log *	log,
		int	op
	)

Definition at line 437 of file gzlog.c.

{
    int ret;
    unsigned char ext[EXTRA];
 
    PUT8(ext, log->first);
    PUT8(ext + 8, log->last);
    PUT4(ext + 16, log->ccrc);
    PUT4(ext + 20, log->clen);
    PUT4(ext + 24, log->tcrc);
    PUT4(ext + 28, log->tlen);
    PUT2(ext + 32, log->stored);
    ext[34] = log->back - 3 + (op << 3);
    fsync(log->fd);
    ret = lseek(log->fd, HEAD, SEEK_SET) < 0 ||
          write(log->fd, ext, EXTRA) != EXTRA ? -1 : 0;
    fsync(log->fd);
    return ret;
}

References log::back, log::ccrc, log::clen, ext, EXTRA, log::fd, log::first, fsync, HEAD, log::last, lseek, PUT2, PUT4, PUT8, SEEK_SET, log::stored, log::tcrc, log::tlen, and write.

Referenced by gzlog_compress(), gzlog_write(), log_append(), log_compress(), and log_replace().

log_open()

int log_open

(

struct log *

log

)

Definition at line 815 of file gzlog.c.

{
    int op;
 
    /* release open file resource if left over -- can occur if lock lost
       between gzlog_open() and gzlog_write() */
    if (log->fd >= 0)
        close(log->fd);
    log->fd = -1;
 
    /* negotiate exclusive access */
    if (log_lock(log) < 0)
        return -1;
 
    /* open the log file, foo.gz */
    strcpy(log->end, ".gz");
    log->fd = open(log->path, O_RDWR | O_CREAT, 0644);
    if (log->fd < 0) {
        log_close(log);
        return -1;
    }
 
    /* if new, initialize foo.gz with an empty log, delete old dictionary */
    if (lseek(log->fd, 0, SEEK_END) == 0) {
        if (write(log->fd, log_gzhead, HEAD) != HEAD ||
            write(log->fd, log_gzext, EXTRA) != EXTRA ||
            write(log->fd, log_gzbody, BODY) != BODY) {
            log_close(log);
            return -1;
        }
        strcpy(log->end, ".dict");
        unlink(log->path);
    }
 
    /* verify log file and load extra field information */
    if ((op = log_head(log)) < 0) {
        log_close(log);
        return -1;
    }
 
    /* check for interrupted process and if so, recover */
    if (op != NO_OP && log_recover(log, op)) {
        log_close(log);
        return -1;
    }
 
    /* touch the lock file to prevent another process from grabbing it */
    log_touch(log);
    return 0;
}

References BODY, close, log::end, EXTRA, log::fd, HEAD, log_close(), log_gzbody, log_gzext, log_gzhead, log_head(), log_lock(), log_recover(), log_touch(), lseek, NO_OP, O_CREAT, O_RDWR, op, log::path, SEEK_END, unlink, and write.

Referenced by gzlog_compress(), gzlog_open(), and gzlog_write().

log_recover()

int log_recover	(	struct log *	log,
		int	op
	)

Definition at line 738 of file gzlog.c.

{
    int fd, ret = 0;
    unsigned char *data = NULL;
    size_t len = 0;
    struct stat st;
 
    /* log recovery */
    log_log(log, op, "start");
 
    /* load foo.add file if expected and present */
    if (op == APPEND_OP || op == COMPRESS_OP) {
        strcpy(log->end, ".add");
        if (stat(log->path, &st) == 0 && st.st_size) {
            len = (size_t)(st.st_size);
            if ((off_t)len != st.st_size ||
                    (data = malloc(st.st_size)) == NULL) {
                log_log(log, op, "allocation failure");
                return -2;
            }
            if ((fd = open(log->path, O_RDONLY, 0)) < 0) {
                free(data);
                log_log(log, op, ".add file read failure");
                return -1;
            }
            ret = (size_t)read(fd, data, len) != len;
            close(fd);
            if (ret) {
                free(data);
                log_log(log, op, ".add file read failure");
                return -1;
            }
            log_log(log, op, "loaded .add file");
        }
        else
            log_log(log, op, "missing .add file!");
    }
 
    /* recover the interrupted operation */
    switch (op) {
    case APPEND_OP:
        ret = log_append(log, data, len);
        break;
    case COMPRESS_OP:
        ret = log_compress(log, data, len);
        break;
    case REPLACE_OP:
        ret = log_replace(log);
    }
 
    /* log status */
    log_log(log, op, ret ? "failure" : "complete");
 
    /* clean up */
    if (data != NULL)
        free(data);
    return ret;
}

References APPEND_OP, close, COMPRESS_OP, log::end, fd, free(), len, log_append(), log_compress(), log_log(), log_replace(), malloc(), NULL, O_RDONLY, log::path, read(), REPLACE_OP, and stat.

Referenced by log_open().

log_replace()

int log_replace

(

struct log *

log

)

Definition at line 571 of file gzlog.c.

{
    int ret;
    char *dest;
 
    /* delete foo.add file */
    strcpy(log->end, ".add");
    unlink(log->path);         /* ignore error, since may not exist */
    BAIL(3);
 
    /* rename foo.name to foo.dict, replacing foo.dict if it exists */
    strcpy(log->end, ".dict");
    dest = malloc(strlen(log->path) + 1);
    if (dest == NULL)
        return -2;
    strcpy(dest, log->path);
    strcpy(log->end, ".temp");
    ret = rename(log->path, dest);
    free(dest);
    if (ret && errno != ENOENT)
        return -1;
    BAIL(4);
 
    /* mark the foo.gz file as done */
    return log_mark(log, NO_OP);
}

References BAIL, dest, log::end, ENOENT, free(), log_mark(), malloc(), NO_OP, NULL, log::path, rename, and unlink.

Referenced by log_compress(), and log_recover().

log_touch()

void log_touch

(

struct log *

log

)

Definition at line 372 of file gzlog.c.

{
    struct stat st;
 
    strcpy(log->end, ".lock");
    utimes(log->path, NULL);
    if (stat(log->path, &st) == 0)
        log->lock = st.st_mtime;
}

References log::end, log::lock, NULL, log::path, and stat.

Referenced by gzlog_compress(), gzlog_write(), log_check(), log_compress(), and log_open().

log_unlock()

void log_unlock

(

struct log *

log

)

Definition at line 396 of file gzlog.c.

{
    if (log_check(log))
        return;
    strcpy(log->end, ".lock");
    unlink(log->path);
    log->lock = 0;
}

References log::end, log::lock, log_check(), log::path, and unlink.

Referenced by log_close().

Variable Documentation

log_gzbody

unsigned char log_gzbody[]

Initial value:

= {
    1, 0, 0, 0xff, 0xff,        
    0, 0, 0, 0,                 
    0, 0, 0, 0                  
}

Definition at line 331 of file gzlog.c.

Referenced by log_open().

log_gzext

unsigned char log_gzext[]

Initial value:

= {
    52, 0, 0, 0, 0, 0, 0, 0,    
    52, 0, 0, 0, 0, 0, 0, 0,    
    0, 0, 0, 0, 0, 0, 0, 0,     
    0, 0, 0, 0, 0, 0, 0, 0,     
    0, 0,                       
    5                           
}

Definition at line 319 of file gzlog.c.

Referenced by log_open().

log_gzhead

unsigned char log_gzhead[]

Initial value:

= {
    0x1f, 0x8b,                 
    8,                          
    4,                          
    0, 0, 0, 0,                 
    0, 0xff,                    
    39, 0, 'a', 'p', 35, 0      
                                
}

Definition at line 306 of file gzlog.c.

Referenced by log_head(), and log_open().