libjio.h

Go to the documentation of this file.

/*
 * libjio - A library for Journaled I/O
 * Alberto Bertogli (albertito@blitiri.com.ar)
 */

#ifndef _LIBJIO_H
#define _LIBJIO_H

#include <stdint.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <pthread.h>
#include <unistd.h>

/* Check if we're using Large File Support - otherwise refuse to build.
 * Otherwise, we would allow applications not using LFS to link with the
 * library (which uses LFS) and that's just begging for problems. There should
 * be a portable way for the C library to do some of this for us, but until I
 * find one, this is the best we can do */
#ifndef _LARGEFILE_SOURCE
#error "You must compile your application with Large File Support"
#endif

/*
 * Opaque types, the API does not expose these
 */

typedef struct jfs jfs_t;

typedef struct jtrans jtrans_t;


/*
 * Public types
 */

struct jfsck_result {
        int total;

        int invalid;

        int in_progress;

        int broken;

        int corrupt;

        int reapplied;
};

enum jfsck_return {
        J_ESUCCESS = 0,

        J_ENOENT = -1,

        J_ENOJOURNAL = -2,

        J_ENOMEM = -3,

        J_ECLEANUP = -4,

        J_EIO = -5,
};



/*
 * Core functions
 */

jfs_t *jopen(const char *name, int flags, int mode, unsigned int jflags);

int jclose(jfs_t *fs);

int jsync(jfs_t *fs);

jtrans_t *jtrans_new(jfs_t *fs, unsigned int flags);

int jtrans_add_w(jtrans_t *ts, const void *buf, size_t count, off_t offset);

int jtrans_add_r(jtrans_t *ts, void *buf, size_t count, off_t offset);

ssize_t jtrans_commit(jtrans_t *ts);

ssize_t jtrans_rollback(jtrans_t *ts);

void jtrans_free(jtrans_t *ts);

int jmove_journal(jfs_t *fs, const char *newpath);


/*
 * Autosync
 */

int jfs_autosync_start(jfs_t *fs, time_t max_sec, size_t max_bytes);

int jfs_autosync_stop(jfs_t *fs);


/*
 * Journal checker
 */

enum jfsck_return jfsck(const char *name, const char *jdir,
                struct jfsck_result *res, unsigned int flags);


/*
 * UNIX API wrappers
 */

ssize_t jread(jfs_t *fs, void *buf, size_t count);

ssize_t jpread(jfs_t *fs, void *buf, size_t count, off_t offset);

ssize_t jreadv(jfs_t *fs, const struct iovec *vector, int count);

ssize_t jwrite(jfs_t *fs, const void *buf, size_t count);

ssize_t jpwrite(jfs_t *fs, const void *buf, size_t count, off_t offset);

ssize_t jwritev(jfs_t *fs, const struct iovec *vector, int count);

int jtruncate(jfs_t *fs, off_t length);

off_t jlseek(jfs_t *fs, off_t offset, int whence);


/*
 * ANSI C stdio wrappers
 */

jfs_t *jfopen(const char *path, const char *mode);

int jfclose(jfs_t *stream);

jfs_t *jfreopen(const char *path, const char *mode, jfs_t *stream);

size_t jfread(void *ptr, size_t size, size_t nmemb, jfs_t *stream);

size_t jfwrite(const void *ptr, size_t size, size_t nmemb, jfs_t *stream);

int jfileno(jfs_t *stream);

int jfeof(jfs_t *stream);

void jclearerr(jfs_t *stream);

int jferror(jfs_t *stream);

int jfseek(jfs_t *stream, long offset, int whence);

long jftell(jfs_t *stream);

void jrewind(jfs_t *stream);

FILE *jfsopen(jfs_t *stream, const char *mode);


/*
 * jopen() flags.
 *
 * Internally used also for jtrans_t flags.
 */

#define J_NOLOCK        1

#define J_NOROLLBACK    2

#define J_LINGER        4

/* Range 8-256 is reserved for future public use */

#define J_RDONLY        512


/*
 * jtrans_t flags.
 *
 * For internal use only, but must be in the same space as the jopen() flags.
 */

#define J_COMMITTED     1024

#define J_ROLLBACKED    2048

#define J_ROLLBACKING   4096


/*
 * jfsck() flags
 */

#define J_CLEANUP       1

#endif

---