gzlog.h File Reference

Go to the source code of this file.

Typedefs
typedef void	gzlog

Functions
gzlog *	gzlog_open (char *path)
int	gzlog_write (gzlog *log, void *data, size_t len)
int	gzlog_compress (gzlog *log)
int	gzlog_close (gzlog *log)

Typedef Documentation

gzlog

typedef void gzlog

Definition at line 52 of file gzlog.h.

Function Documentation

gzlog_close()

int gzlog_close

(

gzlog *

log

)

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 *

log

)

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 *	log,
		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.